环境准备

打开桌面版的 Docker，直接 cmd 运行即可。MaxKBv1.3.0 的 logo 是吸附的，推荐使用该版本。

镜像拉取

1
2

docker pull registry.cn-hangzhou.aliyuncs.com/lucky-warehouse/maxkb
docker pull registry.cn-hangzhou.aliyuncs.com/lucky-warehouse/maxkb:v1.3.0

容器运行

1

docker run -d --restart=always --name=maxkb -p 18080:8080 -v ~/.maxkb:/var/lib/postgresql/data registry.cn-hangzhou.aliyuncs.com/lucky-warehouse/maxkb:v1.3.0

访问地址

• 本地访问：http://localhost:18080

默认账号

1
2

admin
MaxKB@123..

模型配置

添加模型

登录—>系统设置—> 模型设置 —> 添加 Ollama：

• 名称：qwen0.5b
• 类型：大语言模型
• 模型：qwen0.5b，如果没有则通过 ollama list 把 name 复制出来即可

API 域名

需要先内网穿透出来或者解除 IP 限制才能访问到宿主机，可以去看下我ollama那篇文章

API Key 随便填

创建应用

应用 -> 创建应用

应用名称：lucky-gpt

应用描述：基于N100小主机，部署的无显卡qwen:0.5小模型

应用类型：简单配置（新手）

提示词

我弄了一个mysql的知识库，所以提示词可以下面这样写

1
2
3
4
5
6
7
8
9
10
11

# 角色
你是后端开发领域的专家，精通mysql数据库相关知识。
# 回答要求
- 请严格根据下面[已知信息]来回答用户的[问题]
- 禁止使用任何你自己的知识
- 请使用能让小白听懂的语言回答
- 如果[已知信息]中没有答案，请回复："抱歉，关于您的问题，我暂时没有找到相关信息，建议联系人工客服。"
# 已知信息
{data}
# 用户问题
{question}

（1）勾选多轮对话

（2）选择前面配置的AI模型

（3）问题优化也勾选（后续搭建知识库的话）

开场白

1
2
3
4
5
6

您好！我是小维的 MySQL 数据库专家。精通数据库架构设计和理论知识。

我可以为您提供以下帮助：
- 请解释什么是回表？
- 主从复制的原理？
- ACID特性是什么？

然后右边直接输入问题，即可调用自己部署的本地大模型

第三方调用

点概览，可以查看演示，访问限制等

支持嵌入到第三方应用中，很好用，直接复制到对应项目的前端页面中即可

创建知识库

导航那点击知识库---->创建---->输入名称---->描述---->通用型---->上传文件最好是md格式的

看到列表里的文件状态是成功即可，…的设置里可以改这个

再去给自己的大模型关联上知识库：

配置参考如下：

RAG = Retrieval-Augmented Generation
中文：检索增强生成

一句话理解：

先从资料中"查答案"，再让大模型"根据资料作答"。

为什么需要 RAG？

企业内部的资料，大模型不一定有，所以会出现乱说

还有不可能把几百页的说明书给大模型的，这样开销很大

大模型有两个问题：

1. 会胡编（幻觉 hallucination）
2. 不知道私有数据

RAG 解决方式：

1
2
3
4
5
6
7

问题
 ↓
去知识库查资料
 ↓
把资料交给大模型
 ↓
大模型根据资料回答

RAG 整体流程

离线阶段： 文档解析 → Chunk 切分 → Embedding 向量化 → 向量入库

在线阶段： 用户问题 Embedding → 语义缓存匹配 → Milvus 向量检索 + BM25 混合召回 → Reranker 精排 → Prompt 拼接 → 大模型生成答案

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

┌──────────────────────────────────────────────────────────────────────┐
│                          离 线 阶 段                                  │
│                                                                      │
│  PDF 文档解析                                                         │
│       ↓                                                              │
│  文本分片（Chunking）  按段落/章节字数等，LLM有上下文长度限制              │
│       ↓                                                              │
│  Embedding  将文字翻译为高维度向量，语义相近则空间距离就近                 │
│       ↓                                                              │
│  向量数据库（Milvus）  存储 向量 + 原始文本的对照表                      │
└──────────────────────────────────────────────────────────────────────┘

┌──────────────────────────────────────────────────────────────────────┐
│                          在 线 阶 段                                  │
│                                                                      │
│  用户提问                                                             │
│       ↓                                                              │
│  Embedding 向量化                                                     │
│       ↓                                                              │
│  语义缓存匹配  ──命中──→  直接返回缓存答案                              │
│       ↓ 未命中                                                        │
│  双路检索召回                                                          │
│  ┌──────────────────────────┐  ┌──────────────────────────┐           │
│  │    BM25 稀疏检索          │  │    BGE 稠密检索           │           │
│  │                          │  │                          │           │
│  │  用户查询                 │  │  用户查询                 │           │
│  │    ↓                     │  │    ↓                     │           │
│  │  分词 → 词频统计（TF）     │  │  BGE 模型 Embedding       │           │
│  │    ↓                     │  │    ↓                     │           │
│  │  逆文档频率（IDF）计算     │  │  生成查询向量 Q            │           │
│  │    ↓                     │  │    ↓                     │           │
│  │  TF × IDF 得分            │  │  ANN 索引检索（HNSW/IVF） │           │
│  │    ↓                     │  │  余弦相似度计算 cos(Q,D)   │           │
│  │  按关键词匹配度排序        │  │    ↓                     │           │
│  │    ↓                     │  │  按语义相似度排序          │           │
│  │  返回 Top-K 候选文档      │  │  返回 Top-K 候选文档      │           │
│  └──────────┬───────────────┘  └──────────┬───────────────┘           │
│             └──────────┬──────────────────┘                           │
│                  ↓                                                    │
│          RRF 融合算法（Reciprocal Rank Fusion）                        │
│                  ↓                                                    │
│          Reranker 精排（bge-reranker-base）                            │
│                  ↓                                                    │
│          构造 Prompt（角色设定 + 规则 + 检索资料 + 问题）                 │
│                  ↓                                                    │
│          调用大模型（GLM）                                              │
│                  ↓                                                    │
│          生成答案                                                      │
└──────────────────────────────────────────────────────────────────────┘

常见问题与解决方案

1. 文档解析出现乱码，表格行错位 → OCR + 人工复核
2. 颗粒度问题 → 切太大噪音太多，太小语义丢失
3. 检索准确率 → 加入混合检索 + rerank
4. 用户提问模糊性 → 比如问"货没了去补"，需要查询重写（Query Rewrite）后再去搜索

大模型选型和评估标准：

1. 推理能力
2. 指令遵循能力
3. 防幻觉能力

进阶方案：GraphRAG 和 Agentic RAG

分块策略

chunk_size：256 / 512 / 1024（token 或字节）

chunk_overlap：10%~20% 相邻块重叠部分，防止语意断裂

策略：

基础分块： 固定长度、递归字符（首选，按优先级分隔符递归切分 \n\n → \n → " "，能保留句子完整性）、按句切分

结构感知： HTML、Markdown、对话格式

语义/主题： 向量相似度

高级策略： 小-大分块、代理分块（让模型切分，成本很高）

复杂文档最佳实践： 采用混合分块，可以先按结构粗切，再语义/递归细切，做命中率测试

建议：

LangChain 分块伪代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

from langchain.text_splitter import (
    RecursiveCharacterTextSplitter,
    CharacterTextSplitter,
    MarkdownHeaderTextSplitter,
    HTMLHeaderTextSplitter,
)

# 1. 递归字符分块（首选）
splitter = RecursiveCharacterTextSplitter(
    chunk_size=512,       # 每块最大长度
    chunk_overlap=50,     # 相邻块重叠
    separators=["\n\n", "\n", "。", "！", "？", " "],  # 按优先级递归切分
    length_function=len,  # 按字符数计算
)
chunks = splitter.split_text(document)

# 2. 固定长度分块
splitter = CharacterTextSplitter(
    chunk_size=256,
    chunk_overlap=20,
    separator="\n",       # 尽量在换行处切
)
chunks = splitter.split_text(document)

# 3. Markdown 结构感知分块
headers_to_split = [
    ("#", "h1"),
    ("##", "h2"),
    ("###", "h3"),
]
splitter = MarkdownHeaderTextSplitter(headers_to_split=headers_to_split)
# 按标题层级拆分，每个 chunk 自带标题元数据
docs = splitter.split_text(markdown_text)

# 4. HTML 结构感知分块
headers_to_split = [("h1", "Header 1"), ("h2", "Header 2")]
splitter = HTMLHeaderTextSplitter(headers_to_split=headers_to_split)
docs = splitter.split_text(html_text)

# 5. 语义分块（需要 embedding 模型）
from langchain_experimental.text_splitter import SemanticChunker
from langchain_openai import OpenAIEmbeddings

splitter = SemanticChunker(
    OpenAIEmbeddings(),
    breakpoint_threshold_type="percentile",  # 按相似度百分位切
)
docs = splitter.split_text(document)

检索策略

1. 假想性文档嵌入： 让 LLM 生成理想答案，再去向量化检索
2. 混合搜索： 先通过向量相似度找到相近的，再 BM25 稀疏检索锁定匹配结构，加权融合结果合并，向量 0.6，关键词 0.4
3. 多子问题检索： 让大语言模型生成多个语义等价的子问题，再去查，然后用 RAG-Fusion 的 RRF 算法对多个查询结果进行打分重排，强调共识文档——就是多个评委都打分了就是它了
4. 抽象+具体双路： 用户问的过具体，可以让 LLM 抽象问题，将 2 个都拿去检索，既抓细节，又抓背景

标量就是一个单独的数。
例如：1、3.14、-5

向量（Vector）

向量是一维数组，通常表示为列向量：

$$\begin{bmatrix}x_1 \\x_2 \\\vdots \\x_n\end{bmatrix}$$

向量可理解为空间中的点，每个元素对应不同坐标轴的坐标。

向量中有多少个元素，就叫几维向量。

例如：

$$[1,2,3,4]$$

向量加法

要求两个向量维度相同。

交换律：

$$A + B = B + A$$

示例：

$$[1,2] + [3,4] = [4,6]$$

向量内积（点积）

要求两个向量维度相同。

定义：

$$A \cdot B = x_1 y_1 + x_2 y_2 + \cdots + x_n y_n$$

交换律：

$$A \cdot B = B \cdot A$$

示例：

$$[1,2] \cdot [3,4] = 1 \cdot 3 + 2 \cdot 4 = 11$$

向量的模（长度）

定义：

$$\|A\| = \sqrt{x_1^2 + x_2^2 + \cdots + x_n^2}$$

向量夹角的余弦值

要求两个向量维度相同。

定义：

$$\cos \theta = \frac{A \cdot B}{\|A\| \cdot \|B\|}$$

矩阵（Matrix）

矩阵是一个二维数组，每个元素为标量，可通过行号和列号索引。

矩阵加法

要求两个矩阵维度相同。

$$\begin{bmatrix}1 & 2\\3 & 4\end{bmatrix}+\begin{bmatrix}4 & 2\\3 & 1\end{bmatrix}=\begin{bmatrix}5 & 4\\6 & 5\end{bmatrix}$$

矩阵乘法（点积矩阵乘法）

前提

左矩阵 A 的列数等于右矩阵 B 的行数

设：

$$A=\begin{pmatrix}a & b \\c & d\end{pmatrix},\quadB=\begin{pmatrix}e & f \\g & h\end{pmatrix}$$

则：

$$A \times B =\begin{pmatrix}ae+bg & af+bh \\ce+dg & cf+dh\end{pmatrix}$$

$$A=\begin{pmatrix}a&b&c\\d&e&f\\g&h&i\end{pmatrix},\quadB=\begin{pmatrix}j&k&l\\m&n&o\\p&q&r\end{pmatrix}$$

$$AB =\begin{pmatrix}aj+bm+cp & ak+bn+cq & al+bo+cr \\dj+em+fp & dk+en+fq & dl+eo+fr \\gj+hm+ip & gk+hn+iq & gl+ho+ir\end{pmatrix}$$

矩阵 A 是 2 行 3 列 2×3

1
2

| 1  2  3 |
| 4  5  6 |

矩阵 B 是 3 行 2 列 3×2

1
2
3

| 1  2 |
| 3  4 |
| 5  6 |

结果 C= A × B = 2×2

计算过程：

1
2
3
4
5
6
7

第 1 行 × 第 1 列：     1*1 + 2*3 + 3*5 = 1 + 6 + 15 = 22
第 1 行 × 第 2 列：     1*2 + 2*4 + 3*6 = 2 + 8 + 18 = 28
第 2 行 × 第 1 列：     4*1 + 5*3 + 6*5 = 4 + 15 + 30 = 49
第 2 行 × 第 2 列：     4*2 + 5*4 + 6*6 = 8 + 20 + 36 = 64
最终结果：
| 22  28 |
| 49  64 |

性质

不满足交换律：

$$A \cdot B \ne B \cdot A$$

满足分配律：

$$A(B + C) = AB + AC$$

满足结合律：

$$A(BC) = (AB)C$$

Hadamard 乘法（逐元素乘）

要求两个矩阵形状一致。

示例：

$$\begin{bmatrix}1 & 2 \\3 & 4\end{bmatrix}\circ\begin{bmatrix}1 & 2 \\0 & -1\end{bmatrix}=\begin{bmatrix}1 & 4 \\0 & -4\end{bmatrix}$$

矩阵转置（Transpose）

行列互换。

$$\begin{bmatrix}1 & 2 \\3 & 4\end{bmatrix}^T=\begin{bmatrix}1 & 3 \\2 & 4\end{bmatrix}$$

例如：

$$3 \times 2 \rightarrow 2 \times 3$$

向量与矩阵转换

reshape

$$[1,2,3,4]\rightarrow\begin{bmatrix}1 & 2\\3 & 4\end{bmatrix}$$

$$[1,2,3,4,5,6]\rightarrow\begin{bmatrix}1 & 2\\3 & 4\\5 & 6\end{bmatrix}$$

flatten

$$\begin{bmatrix}1 & 2\\3 & 4\\5 & 6\end{bmatrix}\rightarrow[1,2,3,4,5,6]$$

张量（Tensor）

矩阵是二维，张量是多维数据结构。

示例：

3 个 2×2 矩阵：

$$3\times2\times2$$

4 个 3×2×2 张量：

$$4\times3\times2\times2$$

在深度学习中，输入、输出、中间结果几乎都是张量。

导数（Derivative）

• 如果函数是位置，导数就是速度

• 如果函数是距离变化，导数就是变化速度

• 函数曲线上某点的导数 = 该点切线斜率

• 变化方向（正增长还是负增长）

• 变化快慢（增长多快）

• 曲线斜率（图像有多陡）

如果没有导数，你看不出未来趋势。
有了导数，你能预测变化、做优化、画切线、做智能算法。

$$f'(x_0) = \lim_{\Delta x \to 0} \frac{f(x_0 + \Delta x) - f(x_0)}{\Delta x}$$

函数在某个点x下标0的导数，就是函数值变化量与自变量变化量的比值，当变化量趋于无穷小

导数的直观理解（速度类比）

想象你站在某条路上的一个位置：

$$x_0$$

你想知道此刻你的 瞬时速度（也就是导数）。

你不能直接问"现在速度是多少"，
因为你只知道 位置，不是 速度

1. 走一点点距离

向前走一小段距离：

$$\Delta x$$

2. 看位置变化多少

计算位置的变化：

$$f(x_0 + \Delta x) - f(x_0)$$

3. 求平均速度

平均速度 = 路程变化 / 时间变化：

$$\frac{f(x_0 + \Delta x) - f(x_0)}{\Delta x}$$

4. 但我们要的是"瞬时速度"！

平均速度不够，我们想知道 这一瞬间的速度！

怎么办？

让这段"时间"越来越短：

$$\Delta x \to 0$$

5. 当时间趋近 0，平均速度变成瞬时速度

于是得到：

$$f'(x_0) = \lim_{\Delta x \to 0}\frac{f(x_0 + \Delta x) - f(x_0)}{\Delta x}$$

幂函数求导

公式：$(x^n)' = n x^{n-1}$

案例：$f(x) = x^2$ 求导
解：$f'(x)=2x$

常数求导

公式：$(c)' = 0$

案例：$f(x)=5$
不管怎么移动 x，y 都不变，没变化 → 变化速度=0
解：$f'(x)=0$

线性函数求导

公式：$(ax+b)' = a$

案例：$f(x)=3x+1$
线性函数求导=斜率
解：$f'(x)=3$

乘积法则

公式：$(f(x)g(x))'=f'(x)g(x)+f(x)g'(x)$

案例：$f(x)=x,\; g(x)=x^2$
前导后不导 + 前不导后导
解：$(x \cdot x^2)'$
$(x \cdot x^2)' = 1 \cdot x^2 + x \cdot 2x$
化简：$(x \cdot x^2)' = x^2 + 2x^2 = 3x^2$

商法则

$$\text{公式：}\left(\frac{f(x)}{g(x)}\right)' = \frac{f'(x)g(x)-f(x)g'(x)}{[g(x)]^2}$$

求导：$\left(\frac{x}{x^2}\right)'$

$f(x)=x,\; g(x)=x^2,\quad f'(x)=1,\; g'(x)=2x$

代入商法则：

$$\left(\frac{x}{x^2}\right)' = \frac{1 \cdot x^2 - x \cdot 2x}{(x^2)^2} = \frac{x^2 - 2x^2}{x^4} = \frac{-x^2}{x^4} = -\frac{1}{x^2}$$

链式法则

$$\text{公式：}\left(f(g(x))\right)' = f'(g(x)) \cdot g'(x)$$

案例：$y = (3x+1)^2$

外层 $f(u)=u^2,\quad$ 内层 $u=3x+1$
外层先导，把 u 是内层带进去，再乘内层导数
$f'(u)=2u,\quad u'=3$
$y' = 2(3x+1) \cdot 3$
$y' = 6(3x+1)$，$y' = 18x+6$，$y' = 18x+6$

标准差

数据：[2, 4, 6]

1. 平均值：

$$\mu = (2 + 4 + 6) / 3 = 4$$

2. 差值平方：

$$(2-4)^2 = 4,\quad (4-4)^2 = 0,\quad (6-4)^2 = 4$$

3. 方差：

$$\sigma^2 = (4 + 0 + 4) / 3 = 8/3$$

4. 标准差：

$$\sigma = \sqrt{8/3} \approx 1.63$$

Claude Code是Anthropic打造的终端原生AI编程工具

环境要求

NodeJS 18.0+，推荐使用 v24.13.0

安装配置

推荐使用 cc-switch 统一管理配置

1
2
3
4
5
6
7

npm config set registry https://registry.npmmirror.com/    #设置国内镜像源

# 全局安装最新稳定版
npm install -g @anthropic-ai/claude-code

# 验证安装成功（显示版本号即生效）
claude --version

Token Plan 配置

直接去 C:\Users\Administrator\.claude 下编辑 settings.json，配置小米AI的token plan即可

1
2
3
4
5
6
7
8
9
10
11
12

{
  "env": {
    "ANTHROPIC_AUTH_TOKEN": "tp-c7p5iymh5lh28eg4e4f1hn2iyw1y????",
    "ANTHROPIC_BASE_URL": "https://token-plan-cn.xiaomimimo.com/anthropic",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "mimo-v2.5-pro",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "mimo-v2.5-pro",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "mimo-v2.5-pro",
    "ANTHROPIC_MODEL": "mimo-v2.5-pro",
    "CLAUDE_CODE_EFFORT_LEVEL": "max"
  },
  "skipWebFetchPreflight": true
}

启动验证

终端输入 claude 后确定，能看到以下信息说明配置成功：

1
2

│   mimo-v2.5-pro ·API Usage Billing   │ Auto mode is now available for Max subscribers when using Opus 4.7
│        C:\Users\Administrator

VSCode 集成

去VSCode插件市场搜索 Claude Code 集成，就能直接在VSCode上开发

常用命令

1
2

/context    # 查看上下文用量，如果携带太多可以采用压缩
/compact    # 压缩上下文

记忆与上下文的区别： 记忆可以跨越对话，上下文不行

技能配置

这是全局的技能配置路径：C:\Users\Administrator\.claude\skills 下创建技能文件夹和它对应的 SKILL.md

项目级技能配置：.claude/skills/技能文件夹名/SKILL.md

创建子agents：.claude/agents/tester.md（测试专家）

CodeX

环境要求

用 NodeJS v24.13.0

安装

1
2
3

npm install -g @openai/codex

codex --version

注意： 以前要是装过有缓存，可能请求超时，直接删除 C:\Users\Administrator\.codex 文件夹即可

使用步骤

1. 创建一个空的文件夹项目，用来给codex表演，cmd进入这个文件夹

2. 输入 / 去修改默认配置，model选最新的 gpt-5.2-codex，effort 选 xhigh

3. 继续输入 /，permissions 选 full access，给它全部权限

4. 输入 /init 就能生成一个md文档

示例任务

以下是一个完整的项目开发示例：

1

我打算做一个新的电影评分软件，基本实现电影评分和评论功能，你需要完成整个项目的完整开发，并且部署上线，你需要抓取豆瓣上正在上线的电影，自动更新，这是一个完整的项目，你负责全部流程，最终交付给我部署后的网址，你可以利用相关部署的skills来帮助你，如果没有你自己搜索并下载使用，再交付前，你肉眼检查，没啥问题再给我

环境说明：

• env_name：创建的环境名称（如 py312）
• package_name：需要安装的包名（如 numpy）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

# 查看所有环境
conda env list

# 进入某个py环境
conda activate env_name

# 退出当前py环境
conda deactivate

# 删除指定的py环境
conda remove -n env_name --all

# 删除Anaconda镜像源并恢复默认
conda config --remove-key channels

# 查看当前环境下是否安装了指定的包
conda list | findstr 指定的包名       # win
conda list | grep 指定的包名          # Mac

# 查看指定环境下是否安装了指定的包
conda list -n env_name | findstr 指定的包名     # win
conda list -n env_name | grep 指定的包名        # Mac

# 安装需要的第三方包（库）【进入到py虚拟环境下】
conda install package_name          # 安装最新版
conda install package_name==版本号   # 安装指定版本

# conda安装不成功时，尝试pip命令
pip install package_name==版本号 -i 源链接

# 卸载指定的包（库）【进入到py虚拟环境下】
conda uninstall package_name
pip uninstall package_name         # 通过pip安装的包卸载

常用镜像源：

• 清华源：https://pypi.tuna.tsinghua.edu.cn/simple
• 阿里源：https://mirrors.aliyun.com/pypi/simple

创建 py 环境

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 打开cmd创建python版本号为3.12的虚拟环境
conda create -n py312 python=3.12         # 输入：y，回车

# 激活环境
conda activate py312

# 退出当前环境
conda deactivate

# 删除指定的py环境
conda remove -n py312 --all

# 安装Jupyter相关包
pip install jupyterlab
pip install notebook
python -m notebook                        # 浏览器中打开Jupyter Notebook

软件安装

Miniconda

安装步骤：

1. 新建文件夹 D:\soft\miniconda3
2. 安装 Miniconda3-py312_24.9.2-0-Windows-x86_64.exe，默认下一步即可

WIN+R 输入 cmd

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

conda init
conda info
先配置下面，记得创建文件夹cdataenv\pkgs 和 envs
conda config --add pkgs_dirs D:\soft2\cdataenv\pkgs
conda config --add envs_dirs D:\soft2\cdataenv\envs

pip config set global.cache-dir D:\soft2\cdataenv\pip_cache
setx PIP_CACHE_DIR D:\soft2\cdataenv\pip_cache
set PIP_CACHE_DIR=D:\soft2\cdataenv\pip_cache


conda create -n py312 python=3.12         输入：y，回车
conda create -n py310 python=3.10


conda activate py312
(py312) C:\Users\Administrator>where python
C:\Users\Administrator\.conda\envs\py312\python.exe

如果上面配置好了还是在c盘就问ai
解决D:\soft\miniconda3我安装在这，为什么c盘里.conda占用12.6，我希望放这下D:\soft2\cdataenv

Pycharm

作用： 用于编写 python 代码，运行课程中的代码

• Win版下载（专业版）
• Mac M4版下载

激活码参考：pycharm 激活码

深度学习环境配置

打开 cmd，进入需要的 py 环境：conda activate py312

Numpy

作用： 用于科学计算，提供了高性能的多维数组对象和丰富的数学函数

1

pip install numpy==1.26.4 -i https://pypi.tuna.tsinghua.edu.cn/simple

当清华源下载失败时，可尝试更换为阿里源、别开代理

Pandas

作用： 用于数据分析，提供了灵活的数据结构（如 DataFrame），使数据清洗和分析变得简单高效

1

pip install pandas==2.2.2 -i https://pypi.tuna.tsinghua.edu.cn/simple

Mineru

作用： 开源的，用于复杂PDF 文档解析和转换 的工具。它的核心目标是将 PDF 文档高效、准确地转换为易于编辑和阅读的Markdown 格式

1
2
3

pip install --upgrade pip -i https://mirrors.aliyun.com/pypi/simple
pip install uv -i https://mirrors.aliyun.com/pypi/simple
uv pip install -U "mineru[core]" -i https://mirrors.aliyun.com/pypi/simple

使用方法

• 命令行使用 （离线使用）

1

mineru -p <input_path> -o <output_path>

• fastapi 部署 （部署为服务，在线使用）

1

mineru-api --host 0.0.0.0 --port 8000 --allow-public-http-client

Jieba

作用： jieba 是一个专门用于中文文本分词的 Python 库，可以将连续的中文字符切分为有意义的词语

1

pip install jieba -i https://pypi.tuna.tsinghua.edu.cn/simple

Matplotlib

作用： 用于数据可视化，能够创建静态、动态和交互式图表

1

pip install matplotlib==3.9.2 -i https://pypi.tuna.tsinghua.edu.cn/simple

Scikit-learn

作用： 提供了简单高效的数据挖掘和数据分析工具，支持多种机器学习算法

1

pip install Scikit-learn==1.5.1 -i https://pypi.tuna.tsinghua.edu.cn/simple

Peft

作用： 模型微调

1

pip install peft==0.15.0 -i https://pypi.tuna.tsinghua.edu.cn/simple

Transformers

作用： 通过自注意力机制和位置编码，实现对序列数据的高效处理

1

pip install transformers==4.56.2 -i https://pypi.tuna.tsinghua.edu.cn/simple

FastAPI

作用： 现代、快速（高性能）的 Python Web 框架，用于构建 API

1
2
3
4

# Win命令
pip install fastapi[standard] -i https://pypi.tuna.tsinghua.edu.cn/simple
# Mac命令
pip install fastapi -i https://pypi.tuna.tsinghua.edu.cn/simple

Mypy

作用： 静态类型检查工具，它使用 Python 的类型提示（Type Hints）来检查代码中的类型错误

1

pip install mypy -i https://pypi.tuna.tsinghua.edu.cn/simple

Pytorch

作用： 深度学习领域的顶级框架，提供了构建和训练神经网络的工具

CPU 版本安装：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# 进入虚拟环境
conda activate py312

# 安装CPU版本torch
python -m pip install torch==2.6.0 -i https://pypi.tuna.tsinghua.edu.cn/simple/

# 测试是否安装成功
python
>>> import torch
>>> print(torch.__version__)
# 返回：2.6.0+cpu 代表安装成功


# 安装GPU版本torch
# 进入py312环境
pip uninstall torch torchvision torchaudio -y
# cmd执行
nvidia-smi    # 发现cuda版本12.7    3060笔记本电脑和4060ti主机
# 3060-4080的GPU版本 个人的2台电脑，控制驱动版本
pip install torch==2.6.0 torchvision torchaudio --index-url https://download.pytorch.org/whl/cu124
# 5070ti的GPU版本
pip install torch==2.11.0 torchvision torchaudio --index-url https://download.pytorch.org/whl/cu128

import torch
print(torch.cuda.is_available())
print(torch.cuda.get_device_name(0))
print(torch.cuda.current_device())
print(torch.cuda.get_device_capability())

Gensim

作用： 用于主题建模和文本相似性计算

1
2
3
4
5
6
7
8
9
10

# 在线安装（推荐）
conda activate py312
pip install gensim -i https://pypi.tuna.tsinghua.edu.cn/simple

# 离线安装
# 1. 访问 https://pypi.org/project/gensim/
# 2. 点击 Release history → 选择版本 → Download files
# 3. 下载对应的 .whl 文件（如 gensim-4.2.0-cp38-cp38-win_amd64.whl）
# 4. 进入 whl 文件所在目录，执行：
pip install gensim-4.2.0-cp38-cp38-win_amd64.whl

Anaconda 与 Miniconda 对比

Anaconda

Anaconda 是一个开源的 Python 和 R 编程语言发行版，专为科学计算和数据科学设计。它简化了包管理和部署，自身包含了 python 解释器，不需要额外安装 Python SDK。

主要特点：

• 包含了 Conda 包管理器，可以轻松安装、更新、管理和卸载 Python 包和依赖项
• 多版本支持：可以在同一系统上管理和切换不同版本的 Python 和包
• 默认安装了大量常用的包，适合需要快速搭建数据科学和机器学习环境的用户
• 提供了 Anaconda Navigator 图形界面，用户可以轻松管理包和环境

缺点：

• 安装包较大（几百兆到几个 GB），占用较多的磁盘空间
• 更新和维护所有包的版本不如手动安装的方式灵活

Miniconda

Miniconda 是 Anaconda 的一个精简版本，它仅包含 Conda 包管理器及其依赖项，用户可以根据需要安装其他包。

优点：

• 轻量级：安装包小，安装速度快，占用磁盘空间少
• 灵活性：用户可以根据自己的需求安装需要的包

缺点：

• 初始安装后需要手动安装所需的包，适合有一定经验的用户
• 不包含 Anaconda Navigator 图形界面，所有操作需要通过命令行完成

总结： Miniconda 提供了与 Anaconda 同样的功能，但以更轻量和灵活的方式实现，所以安装 Anaconda 和 Miniconda 都是可以的。

Pycharm 配置 conda 环境

1

文件 → 设置 → 项目 → python 解释器 → 添加解释器 → Conda 环境 → 使用现有环境 → 选文件路径 D:\soft\miniconda3\Scripts\conda.exe → 加载环境 → 下拉选择需要的虚拟环境确定即可

1
2
3

PyCharm →File → Settings → Tools → Terminal → Shell path 查看终端，默认进入这个环境

cmd.exe /K "D:\soft\miniconda3\condabin\conda.bat activate py312"

激活码

1

EUWT4EE9X2-eyJsaWNlbnNlSWQiOiJFVVdUNEVFOVgyIiwibGljZW5zZWVOYW1lIjoic2lnbnVwIHNjb290ZXIiLCJhc3NpZ25lZU5hbWUiOiIiLCJhc3NpZ25lZUVtYWlsIjoiIiwibGljZW5zZVJlc3RyaWN0aW9uIjoiIiwiY2hlY2tDb25jdXJyZW50VXNlIjpmYWxzZSwicHJvZHVjdHMiOlt7ImNvZGUiOiJQU0kiLCJmYWxsYmFja0RhdGUiOiIyMDI1LTA4LTAxIiwicGFpZFVwVG8iOiIyMDI1LTA4LTAxIiwiZXh0ZW5kZWQiOnRydWV9LHsiY29kZSI6IlBDIiwiZmFsbGJhY2tEYXRlIjoiMjAyNS0wOC0wMSIsInBhaWRVcFRvIjoiMjAyNS0wOC0wMSIsImV4dGVuZGVkIjpmYWxzZX0seyJjb2RlIjoiUFBDIiwiZmFsbGJhY2tEYXRlIjoiMjAyNS0wOC0wMSIsInBhaWRVcFRvIjoiMjAyNS0wOC0wMSIsImV4dGVuZGVkIjp0cnVlfSx7ImNvZGUiOiJQV1MiLCJmYWxsYmFja0RhdGUiOiIyMDI1LTA4LTAxIiwicGFpZFVwVG8iOiIyMDI1LTA4LTAxIiwiZXh0ZW5kZWQiOnRydWV9LHsiY29kZSI6IlBDV01QIiwiZmFsbGJhY2tEYXRlIjoiMjAyNS0wOC0wMSIsInBhaWRVcFRvIjoiMjAyNS0wOC0wMSIsImV4dGVuZGVkIjp0cnVlfV0sIm1ldGFkYXRhIjoiMDEyMDIyMDkwMlBTQU4wMDAwMDUiLCJoYXNoIjoiVFJJQUw6MzUzOTQ0NTE3IiwiZ3JhY2VQZXJpb2REYXlzIjo3LCJhdXRvUHJvbG9uZ2F0ZWQiOmZhbHNlLCJpc0F1dG9Qcm9sb25nYXRlZCI6ZmFsc2V9-FT9l1nyyF9EyNmlelrLP9rGtugZ6sEs3CkYIKqGgSi608LIamge623nLLjI8f6O4EdbCfjJcPXLxklUe1O/5ASO3JnbPFUBYUEebCWZPgPfIdjw7hfA1PsGUdw1SBvh4BEWCMVVJWVtc9ktE+gQ8ldugYjXs0s34xaWjjfolJn2V4f4lnnCv0pikF7Ig/Bsyd/8bsySBJ54Uy9dkEsBUFJzqYSfR7Z/xsrACGFgq96ZsifnAnnOvfGbRX8Q8IIu0zDbNh7smxOwrz2odmL72UaU51A5YaOcPSXRM9uyqCnSp/ENLzkQa/B9RNO+VA7kCsj3MlJWJp5Sotn5spyV+gA==-MIIETDCCAjSgAwIBAgIBDTANBgkqhkiG9w0BAQsFADAYMRYwFAYDVQQDDA1KZXRQcm9maWxlIENBMB4XDTIwMTAxOTA5MDU1M1oXDTIyMTAyMTA5MDU1M1owHzEdMBsGA1UEAwwUcHJvZDJ5LWZyb20tMjAyMDEwMTkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCUlaUFc1wf+CfY9wzFWEL2euKQ5nswqb57V8QZG7d7RoR6rwYUIXseTOAFq210oMEe++LCjzKDuqwDfsyhgDNTgZBPAaC4vUU2oy+XR+Fq8nBixWIsH668HeOnRK6RRhsr0rJzRB95aZ3EAPzBuQ2qPaNGm17pAX0Rd6MPRgjp75IWwI9eA6aMEdPQEVN7uyOtM5zSsjoj79Lbu1fjShOnQZuJcsV8tqnayeFkNzv2LTOlofU/Tbx502Ro073gGjoeRzNvrynAP03pL486P3KCAyiNPhDs2z8/COMrxRlZW5mfzo0xsK0dQGNH3UoG/9RVwHG4eS8LFpMTR9oetHZBAgMBAAGjgZkwgZYwCQYDVR0TBAIwADAdBgNVHQ4EFgQUJNoRIpb1hUHAk0foMSNM9MCEAv8wSAYDVR0jBEEwP4AUo562SGdCEjZBvW3gubSgUouX8bOhHKQaMBgxFjAUBgNVBAMMDUpldFByb2ZpbGUgQ0GCCQDSbLGDsoN54TATBgNVHSUEDDAKBggrBgEFBQcDATALBgNVHQ8EBAMCBaAwDQYJKoZIhvcNAQELBQADggIBABqRoNGxAQct9dQUFK8xqhiZaYPd30TlmCmSAaGJ0eBpvkVeqA2jGYhAQRqFiAlFC63JKvWvRZO1iRuWCEfUMkdqQ9VQPXziE/BlsOIgrL6RlJfuFcEZ8TK3syIfIGQZNCxYhLLUuet2HE6LJYPQ5c0jH4kDooRpcVZ4rBxNwddpctUO2te9UU5/FjhioZQsPvd92qOTsV+8Cyl2fvNhNKD1Uu9ff5AkVIQn4JU23ozdB/R5oUlebwaTE6WZNBs+TA/qPj+5/we9NH71WRB0hqUoLI2AKKyiPw++FtN4Su1vsdDlrAzDj9ILjpjJKA1ImuVcG329/WTYIKysZ1CWK3zATg9BeCUPAV1pQy8ToXOq+RSYen6winZ2OO93eyHv2Iw5kbn1dqfBw1BuTE29V2FJKicJSu8iEOpfoafwJISXmz1wnnWL3V/0NxTulfWsXugOoLfv0ZIBP1xH9kmf22jjQ2JiHhQZP7ZDsreRrOeIQ/c4yR8IQvMLfC0WKQqrHu5ZzXTH4NO3CwGWSlTY74kE91zXB5mwWAx1jig+UXYc2w4RkVhy0//lOmVya/PEepuuTTI4+UJwC7qbVlh5zfhj8oTNUXgN0AOc+Q0/WFPl1aw5VV/VrO8FCoB15lFVlpKaQ1Yh+DVU8ke+rt9Th0BCHXe0uZOEmH0nOnH/0onD

llama.cpp 是"底层推理引擎"，Ollama 和 LM Studio 均是基于它封装的上层应用，Ollama 是"命令行版"，LM Studio 是"图形界面版"，三者本质都是让你在自己电脑上跑大模型，只是封装层级不同。

Ollama

Ollama是一个开源的大型语言模型服务工具，它帮助用户快速在本地运行大模型。

除了要搭建服务给别人调用，否则不推荐使用！

官网下载安装包：https://ollama.com/

1、默认是安装到C盘的，改N盘，N:\AI\Ollama新建它
2、将OLLAMA的安装包放在N:\AI\Ollama下
3、路径CMD回车
OllamaSetup.exe /DIR=N:\AI\OLLAMA

设置它，创建N:\AI\Ollama\models放模型

首先看显卡性能、6g显存–>qwen:4b 无显存–>qwen:0.5b

ollama https://github.com/ollama/ollama

个人登录 https://ollama.com/luckyNwa，能领取免费的cloud模型使用

查看模型库qwen2

https://ollama.com/library/qwen2

装了半小时

1
2
3
4
5
6
7
8
9

ollama list

N100 无显卡
ollama run qwen:0.5b
ollama run qwen3.5:cloud    云端有免费额度
ollama run qwen3.5:397b-cloud

ollama run gemma-4-26b-local
ollama rm gemma-4-26b-local     移除模型

API

访问地址：http://ip:11434/api/generate

1
2
3
4

{
  "model": "qwen:0.5b",
  "prompt": "你是谁?"
}

返回 JSON 对象流。

更多 API 查看：Ollama API 文档

环境变量配置

如果想将本地运行的模型外网或局域网访问，则需要去配置 环境变量

修改 IP 访问：

1

OLLAMA_HOST=0.0.0.0:11434

修改跨域访问：

1

OLLAMA_ORIGINS=*

否则访问会出现 403，再关闭 Ollama 重启即可，笔记本防火墙需要关闭。

修改 GPU 释放：

1

OLLAMA_KEEP_ALIVE=2m

默认是 5m，降低 GPU 占用。

修改模型位置：

1

OLLAMA_MODELS=D:\lucky\OllamaModels

改完关闭进程，再 cmd 启动：

1

ollama run qwen:0.5b

使用docker安装

1
2
3
4
5

docker pull registry.cn-hangzhou.aliyuncs.com/lucky-warehouse/ollama

docker run -d -v /nwa/ollama:/root/.ollama -p 11434:11434 --privileged=true --name ollama registry.cn-hangzhou.aliyuncs.com/lucky-warehouse/ollama

docker exec -it ollama ollama run qwen:0.5b

进入容器操作

1
2
3

docker exec -it ollama bash
ollama run qwen:0.5b
export OLLAMA_HOST=0.0.0.0:11434

搞半天没啥软用，端口忘记穿透了

网络配置

发现在 1Panel 中的 IP 地址是 172.17.0.5，每次重启容器会变，需要注意。分析之后发现都存于 172.17.0.1 这个网关下，填这个就行了。而且 MaxKB（看另一篇文章） 也是这个地址，可以直接输入它在 MaxKB 中：

1

http://172.17.0.5:11434

llama.cpp

llama.cpp的Github地址：Releases · ggml-org/llama.cpp

N:\AI\llama.cpp下安装2个llama.cpp，一个12版本一个13版本的 , 13需要比较新的驱动和显卡

复制C:\Program Files\NVIDIA GPU Computing Toolkit\ 到文件夹地址上并查看当前cuda工具包的版本====CUDA\v12.2的

发现是12的，下载12的Release b8828 · ggml-org/llama.cpp 8828版本稳定点

下载13的去https://developer.nvidia.com/cuda-downloads?target_os=Windows&target_arch=x86_64&target_version=10&target_type=exe_local

需要会开科学上网

1
2

nvcc --version   当前使用版本
nvidia-smi

1
2
3

cmd 路径 N:\AI\llama.cpp\cuda12

.\llama-cli.exe -m ..\models\ZL-Qwen3.6-35B-MOE-FP4.gguf -ngl 100 --color auto --reasoning off

异常 回答速度 [ Prompt: 43.8 t/s | Generation: 10.9 t/s ]

正常速度 [ Prompt: 133.5 t/s | Generation: 21.4 t/s ] 4080 16g显存，这个混合专家模型18.4GB

去N:\AI\llama.cpp\cuda12下cmd运行

1

.\llama-bench.exe --list-devices    输入这个查看cuda有没有用上

结果：

1
2
3
4
5
6
7
8

N:\AI\llama.cpp\cuda12>.\llama-bench.exe --list-devices
ggml_cuda_init: found 1 CUDA devices (Total VRAM: 16375 MiB):
  Device 0: NVIDIA GeForce RTX 4080, compute capability 8.9, VMM: yes, VRAM: 16375 MiB
load_backend: loaded CUDA backend from N:\AI\llama.cpp\cuda12\ggml-cuda.dll
load_backend: loaded RPC backend from N:\AI\llama.cpp\cuda12\ggml-rpc.dll
load_backend: loaded CPU backend from N:\AI\llama.cpp\cuda12\ggml-cpu-alderlake.dll
Available devices:
  CUDA0: NVIDIA GeForce RTX 4080 (16375 MiB, 15048 MiB free)

测试拉满这个12g模型，显卡对应token速度

1

.\llama-bench.exe -m ..\models\gemma-4-26B-A4B-it-UD-IQ4_NL\gemma-4-26B-A4B-it-UD-IQ4_NL\gemma-4-26B-A4B-it-UD-IQ4_NL.gguf -ngl 100

cuda版本没对上用cpu运行结果如下：

1
2
3
4
5
6
7
8
9
10

N:\AI\llama.cpp\cuda12>.\llama-bench.exe -m ..\models\gemma-4-26B-A4B-it-UD-IQ4_NL\gemma-4-26B-A4B-it-UD-IQ4_NL\gemma-4-26B-A4B-it-UD-IQ4_NL.gguf -ngl 100

load_backend: loaded RPC backend from N:\AI\llama\llama-b8827-bin-win-cuda-13.1-x64\ggml-rpc.dll
load_backend: loaded CPU backend from N:\AI\llama\llama-b8827-bin-win-cuda-13.1-x64\ggml-cpu-alderlake.dll
| model                          |       size |     params | backend    | threads |            test |                  t/s |
| ------------------------------ | ---------: | ---------: | ---------- | ------: | --------------: | -------------------: |
| gemma4 ?B IQ4_NL - 4.5 bpw     |  12.48 GiB |    25.23 B | CPU        |      16 |           pp512 |         52.06 ± 0.09 |
| gemma4 ?B IQ4_NL - 4.5 bpw     |  12.48 GiB |    25.23 B | CPU        |      16 |           tg128 |         10.69 ± 0.10 |

build: fcc750875 (8828)

显卡加载正常：

1
2
3
4
5
6
7
8
9
10
11
12

N:\AI\llama.cpp\cuda12>.\llama-bench.exe -m ..\models\gemma-4-26B-A4B-it-UD-IQ4_NL\gemma-4-26B-A4B-it-UD-IQ4_NL\gemma-4-26B-A4B-it-UD-IQ4_NL.gguf -ngl 100
ggml_cuda_init: found 1 CUDA devices (Total VRAM: 16375 MiB):
  Device 0: NVIDIA GeForce RTX 4080, compute capability 8.9, VMM: yes, VRAM: 16375 MiB
load_backend: loaded CUDA backend from N:\AI\llama.cpp\cuda12\ggml-cuda.dll
load_backend: loaded RPC backend from N:\AI\llama.cpp\cuda12\ggml-rpc.dll
load_backend: loaded CPU backend from N:\AI\llama.cpp\cuda12\ggml-cpu-alderlake.dll
| model                          |       size |     params | backend    | ngl |            test |                  t/s |
| ------------------------------ | ---------: | ---------: | ---------- | --: | --------------: | -------------------: |
| gemma4 26B.A4B IQ4_NL - 4.5 bpw |  12.48 GiB |    25.23 B | CUDA       | 100 |           pp512 |     5417.02 ± 110.14 |
| gemma4 26B.A4B IQ4_NL - 4.5 bpw |  12.48 GiB |    25.23 B | CUDA       | 100 |           tg128 |        131.50 ± 0.50 |

build: fcc750875 (8828)

4080 16G显存结果：

1
2
3
4
5
6
7
8
9
10
11
12

N:\AI\llama.cpp\cuda12>.\llama-bench.exe -m ..\models\Qwen3-14B-Q4_K_M.gguf -ngl 100
ggml_cuda_init: found 1 CUDA devices (Total VRAM: 16375 MiB):
  Device 0: NVIDIA GeForce RTX 4080, compute capability 8.9, VMM: yes, VRAM: 16375 MiB
load_backend: loaded CUDA backend from N:\AI\llama.cpp\cuda12\ggml-cuda.dll
load_backend: loaded RPC backend from N:\AI\llama.cpp\cuda12\ggml-rpc.dll
load_backend: loaded CPU backend from N:\AI\llama.cpp\cuda12\ggml-cpu-alderlake.dll
| model                          |       size |     params | backend    | ngl |            test |                  t/s |
| ------------------------------ | ---------: | ---------: | ---------- | --: | --------------: | -------------------: |
| qwen3 14B Q4_K - Medium        |   8.38 GiB |    14.77 B | CUDA       | 100 |           pp512 |     3866.13 ± 125.80 |
| qwen3 14B Q4_K - Medium        |   8.38 GiB |    14.77 B | CUDA       | 100 |           tg128 |         66.49 ± 0.03 |

build: fcc750875 (8828)

3080 10Gx显存结果：

1
2
3
4
5
6
7
8
9
10
11
12

D:\AI\llama.cpp\cuda12>.\llama-bench.exe -m ..\models\Qwen3-14B-Q4_K_M.gguf -ngl 100
ggml_cuda_init: found 1 CUDA devices (Total VRAM: 10239 MiB):
  Device 0: NVIDIA GeForce RTX 3080, compute capability 8.6, VMM: yes, VRAM: 10239 MiB
load_backend: loaded CUDA backend from D:\AI\llama.cpp\cuda12\ggml-cuda.dll
load_backend: loaded RPC backend from D:\AI\llama.cpp\cuda12\ggml-rpc.dll
load_backend: loaded CPU backend from D:\AI\llama.cpp\cuda12\ggml-cpu-zen4.dll
| model                          |       size |     params | backend    | ngl |            test |                  t/s |
| ------------------------------ | ---------: | ---------: | ---------- | --: | --------------: | -------------------: |
| qwen3 14B Q4_K - Medium        |   8.38 GiB |    14.77 B | CUDA       | 100 |           pp512 |      2341.71 ± 48.03 |
| qwen3 14B Q4_K - Medium        |   8.38 GiB |    14.77 B | CUDA       | 100 |           tg128 |         65.09 ± 0.76 |

build: fcc750875 (8828)

16G显存跑下面

1
2
3

.\llama-server.exe -m N:\AI\llama.cpp\models\gemma-4-26B-A4B-it-UD-IQ4_NL\gemma-4-26B-A4B-it-UD-IQ4_NL\gemma-4-26B-A4B-it-UD-IQ4_NL.gguf -ngl 100 -c 16384 -ctk q8_0 -ctv q8_0

.\llama-server.exe -m "N:\AI\llama.cpp\models\Qwen3-Coder-30B-A3B-Instruct-Q3_K_M\Qwen3-Coder-30B-A3B-Instruct-Q3_K_M\Qwen3-Coder-30B-A3B-Instruct-Q3_K_M.gguf" -ngl 100 -c 16384 -ctk q8_0 -ctv q8_0

10G显存跑

1
2
3

.\llama-server.exe -m "..\models\Qwen3-14B-Q4_K_M.gguf" -ngl 999 -c 4096 -ctk q4_0 -ctv q4_0 -fa on --host 0.0.0.0 --port 8080

3080、4080跑这个模型都 59 t/s

http://127.0.0.1:8080

LM Studio

它就是一个"本地版 ChatGPT"——你可以把各种开源大模型下载到电脑上，断网也能用，而且所有数据都不上传云端，完全隐私安全

https://lmstudio.ai

安装进入自动llama.cpp-win-x86_64-nvidia-cuda12-avx2 (2.13.0)这个比较慢，开科学虚拟卡模式

模型下载

国内模型库（ModelScope）

gemma-4-26B-A4B-it-GGUF · 模型库

页面的右边有4bit的，Q4量化的，可以在4080显卡16g显存下跑，下载放到N:\AI\llama.cpp\models\gemma-4-26B-A4B-it-UD-IQ4_NL\gemma-4-26B-A4B-it-UD-IQ4_NL下

别装了，ollama太拉了，就是llamcpp套一层壳的，速度还比llamcpp慢，用lm studio和llamcpp折腾玩耍大模型

新建Modelfile

1
2

FROM ./gemma-4-26B-A4B-it-UD-IQ4_NL.gguf
TEMPLATE """{{ .Prompt }}"""

cmd 进入这个路径

1

ollama create gemma-4-26b-local -f Modelfile

出现success 即可

需要科学上网：国外模型库（huggingface）

AI 大模型客户端

连接用户与大模型之间的"桥梁"或"遥控器"，自身不包含大模型，需要搭配后端服务使用

Lobe Chat

Lobe Chat是一个可以本地部署的、支持多模型的 AI 聊天客户端，类似于一个"万能 AI 遥控器"，把各种大模型整合到一个界面里统一管理

1

docker run -d -p 3210:3210 -e OLLAMA_PROXY_URL=http://host.docker.internal:11434 lobehub/lobe-chat

去设置那语言模型，只勾选 Ollama，模型列表只留下 deepseek-r1:7b，再检查默认助手（模型就选 deepseek-r1:7b）只能使用。

Cherry Studio（使用中）

Cherry Studio 是一款全能型 AI 助手桌面客户端,能把各种大模型统一接入的"AI 工作台

直接去官网下载win版本，配置一下，开箱即用

https://cherry-ai.com

其他

基于开源项目 ChatGPT-Next-Web 搭建的私人 ChatGPT 聊天应用，支持自定义域名访问。

搭建步骤

（1）获取源码并部署

访问开源项目仓库：https://github.com/Yidadaa/ChatGPT-Next-Web

在页面下方找到 Deploy 按钮，点击进入 Vercel 平台进行部署：

（2）配置环境变量

• 项目名称：可自定义，如 lucky-next-chat
• OPENAI_API_KEY：ChatGPT 的 API 密钥（可通过淘宝购买）
• CODE：网站访问密码

（3）完成部署

点击 Deploy 后，等待片刻直到显示 Congratulations!，然后点击继续。

Vercel 管理地址：https://vercel.com/luckynwa6/chat-gpt-next-web

（4）配置自定义域名

Vercel 添加域名：

进入 Settings → Domains → Add，输入你的二级域名（如 chat.luckynwa.top）

DNS 解析配置：

前往你的域名服务商（如 DNSPod），添加域名解析记录：

DNSPod 管理地址：https://console.dnspod.cn/dns/luckynwa.top/record

（5）更新密钥

如果需要更换 API Key 或密码，进入 Vercel 项目的 Settings → Environment Variables 进行修改。

修改后需要重新部署才能生效

最终访问

配置完成后，通过你的域名即可访问：

https://chat.luckynwa.top/#/

numpy一般用来定义矩阵并调用里面的方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

import numpy as np

arr1 = np.arange(15).reshape(3, 5)  # 创建ndarray对象
print(arr1)
print("*" * 20)
print(f'np的轴：{arr1.ndim}')  # 2
print(f'np的维度：{arr1.shape}')  # 3行5列
print(f'np的元素类型：{arr1.dtype}')  # int32
print(f'np的元素个数：{arr1.size}')  # 15
print(f'np的元素字节数：{arr1.itemsize}')  # 4   32除8
print(f'np的元素类型：{type(arr1)}')  # <class 'numpy.ndarray'>
print("*" * 20)

# 矩阵运算

arr2 = np.array([10, 20, 30, 40])
arr3 = np.arange(4)  # 都是一行四列
print(arr2)
print(arr3)

print(arr2 + arr3)
print(arr2 - arr3)
print("*" * 20)
# 矩阵的乘法，行列数一致
arr4 = np.array([[1, 2, 3], [4, 5, 6]])
arr5 = np.array([[1, 2, 3], [4, 5, 6]])
print(arr4 * arr5)
print(np.multiply(arr4, arr5))  # 这2个结果一样都是相乘
print("*" * 20)
# 矩阵乘，行列数不一致，需要a的列和b的行一致
arr4 = np.array([[1, 2, 3], [4, 5, 6]])
arr5 = np.array([[9, 8], [6, 5], [3, 2]])
print(np.dot(arr4, arr5))
print(arr4.dot(arr5))
print(arr4 @ arr5)  # 这3效果一致

常见的创建方式

把py列表转ndarray类型

1
2
3
4
5
6
7
8
9

# 把py列表转ndarray对象
import numpy as np

my_list = [11, 22, 33, 55, 67]
print(type(my_list))

arr2 = np.array(my_list)
print(arr2)
print(type(arr2))

arange(起始,结束,步长,dtype=类型)函数创建ndarray类型 类似py的range()函数

1
2
3
4
5
6
7

arr3 = np.arange(0, 10, 2, dtype=np.float32) #指定np的类型，有int32 int64等
print(arr3)
print(type(arr3))
print(f'元素的类型：{arr3.dtype}')
# [0. 2. 4. 6. 8.]
# <class 'numpy.ndarray'>
# 元素的类型：float32

random.rand() 生成 包左不包右 随机小数矩阵

randint(起始，结束，size=（行，列）)

1
2
3
4
5
6
7

print("*" * 20)
arr4 = np.random.rand(3, 5)
print(arr4)

print("*" * 20)
arr5 = np.random.randint(3, 5, size=(2, 6)) #2行3列   范围3-4，包左不包右，随机整数
print(arr5)

等比/等差数列

开始和结束点都是10的幂,base指定2为底数

1
2
3
4
5
6
7
8
9

arr3 = np.logspace(0, 0, 10)
print(arr3)

arr4 = np.logspace(0, 1, 10, base=2)  # 等比数列
print(arr4)

arr5 = np.linspace(1, 10, 10) # 等差数列浮点型   ,endpoint= False 不包含结束值, dtype=np.int32指定类型
print(arr5)

排序函数

1
2
3
4
5
6
7
8
9
10
11
12
13

import numpy as np

arr1 = np.array([12, 2, 33, 14, 5])

print(arr1)

arr2 = np.sort(arr1)  # 这样不修改原来数组
print("*" * 20)
print(arr1)
print(arr2)

arr1.sort()  # 这样直接修改原来数组
print(arr1)

类型转换

1
2
3
4
5
6
7
8
9

import numpy as np

arr1 = np.arange(0, 10, 2, dtype=np.int64)
print(arr1)
print(type(arr1))

arr2 = arr1.astype(np.float64)
print(arr2)
print(type(arr2))

常用方法速查

矩阵运算

示例：

1
2
3

A = np.array([[1,2],[3,4]])
B = np.array([[5,6],[7,8]])
C = A @ B

常用数学函数

矩阵属性

形状操作（Reshape / Flatten）

示例：

1
2

A = np.array([[1,2],[3,4],[5,6]])
A.reshape(2,3)

索引操作

普通索引

1
2
3
4

A[0,1]     # 第一行第二列
A[:,1]     # 所有行，第2列
A[1,:]     # 第2行，所有列
A[0:2, :]  # 前两行

布尔索引

1

A[A > 0]

拼接操作（Concatenate / Stack）

线性代数

示例：

1
2

A = np.array([[1,2],[3,4]])
inv = np.linalg.inv(A)

随机模块

类型转换

读写文件

常见小技巧

1. 快速生成单位矩阵

1

np.eye(4)

2. 生成一个 10x10 的随机矩阵

1

np.random.randn(10,10)

3. 快速查看数据统计信息

1

A.min(), A.max(), A.mean(), A.std()

4. 比较两个矩阵是否相等

1

np.allclose(A, B)

1
2
3
4
5

docker run --name twikoo \
  -e TWIKOO_THROTTLE=1000 \
  -p 3737:8080 \
  -v ${PWD}/data:/app/data \
  -d registry.cn-hangzhou.aliyuncs.com/lucky-warehouse/twikoo

博客主题配置中修改如下：

1
2
3
4
5

twikoo:
  envId: http://xxxxxx:3737/
  region:
  visitor: true
  option:

use 也选它，上面连接去浏览器输入有东西出来就配置好了。

Nginx 反向代理

必须申请一个二级域名，不然会出现跨域情况。

twikoo.luckynwa.top 的 Nginx 配置如下（必须带上 IP，不然 tw 设置无法查看访问者具体位置）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

server {
    listen  443 ssl;
    server_name  twikoo.luckynwa.top;

    ssl_certificate /etc/nginx/cert/twikoo.luckynwa.top.cer;
    ssl_certificate_key /etc/nginx/cert/twikoo.luckynwa.top.key;

    ssl_session_timeout  5m;

    ssl_protocols SSLv3 TLSv1 TLSv1.1 TLSv1.2;
    ssl_ciphers  HIGH:!ADH:!EXPORT56:RC4+RSA:+MEDIUM;
    ssl_prefer_server_ciphers  on;

    location / {
        proxy_pass http://xxxxxx:3737;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

Vercel+MongoDB部署（使用中）

打开https://cloud.mongodb.com/注册并登录

使用n165… gmail的谷歌账号登录

1. 点左侧 Database Access，添加一个数据库用户（设好用户名和密码）
2. 点左侧 Network Access，添加 IP 为 0.0.0.0/0（允许所有 IP 访问）
3. 回到 Database 页面，点击你的集群 -> Connect -> Connect your application
4. 复制下面，替换密码

1

mongodb+srv://n1656213092:第二步设的密码@cluster0.5x5rf.mongodb.net/?retryWrites=true&w=majority&appName=Cluster0

打开我的GitHub的这个仓库，https://github.com/luckyNwa6/twikoo，Fork这仓库

点击以下链接将Twikoo一键部署到Vercel：

https://vercel.com/import/project?template=https://github.com/imaegoo/twikoo/tree/main/src/server/vercel-min

进入Settings - Environment Variables页面。
新建一个NAME为MONGODB_URI;VALUE为复制里的信息

进入Deployments界面，点击右边的竖三点，点击Redeploy

提示 100 运行正常就可以了，得配置域名国内才能访问

邮箱通知

控制面板在项目中的留言区，可以设置各种功能，比如留言时 QQ 邮箱通知提醒

默认在–昵称–输入admin 展示这个设置 现在昵称这个LuckyNwa 展示设置，密7…

QQ 邮箱开启 SMTP 服务，授权码记得保存，配置到控制面板中即可。

默认twikoo数据文件会在/root/data中 db0.json是评论信息 其他是系统配置的json

用 管理员 PowerShell

1
2

dism.exe /online /enable-feature /featurename:Microsoft-Windows-Subsystem-Linux /all /norestart
dism.exe /online /enable-feature /featurename:VirtualMachinePlatform /all /norestart

重启电脑

1
2
3

wsl --set-default-version 2
wsl --update
wsl --status

安装 Ubuntu（不开科学也挺快）

1

wsl --install -d Ubuntu

过后创建号：lucky / 221...

更新系统

1
2

sudo apt update
sudo apt upgrade -y

#临时用管理员

1

sudo -i

安装 Miniconda

1
2

wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh
bash Miniconda3-latest-Linux-x86_64.sh     # 一直回车 或 yes

生效

1

source ~/.bashrc

验证

1

conda --version

配置 SSH

1
2
3
4

sudo apt install openssh-server -y
sudo service ssh start
service ssh status
passwd        # 221...

端口转发到 2222（管理员 PowerShell）

1

netsh interface portproxy add v4tov4 listenport=2222 listenaddress=0.0.0.0 connectport=22 connectaddress=172.24.212.8

开防火墙

1

netsh advfirewall firewall add rule name="WSL SSH" dir=in action=allow protocol=TCP localport=2222

测试

1

ssh lucky@127.0.0.1 -p 2222

配置 root SSH 登录

1
2
3

sudo -i
passwd root     # 也改成 221..
nano /etc/ssh/sshd_config

#不去找注释了，直接新增下面2行

1
2

PermitRootLogin yes
PasswordAuthentication yes

#保存退出 重启

1
2
3

Ctrl + O
Enter
Ctrl + X

1

service ssh restart

修复终端提示符过长

1
2

unset PROMPT_COMMAND
echo 'unset PROMPT_COMMAND' >> ~/.bashrc

安装 Python 3.10 环境

1
2
3
4
5
6

conda tos accept --override-channels --channel https://repo.anaconda.com/pkgs/main
conda tos accept --override-channels --channel https://repo.anaconda.com/pkgs/r
conda remove -n vllm --all -y         # 移除环境
conda create -n vllm python=3.10 -y   # 安装环境
conda activate vllm
pip install -U pip

1
2

apt-get update
apt-get install -y gcc

安装 vLLM 依赖

指定版本，因为我的显卡3080的驱动不支持太新的pytorch版本，安装vllm自动安装pytorch

1
2
3
4
5
6
7
8

pip install vllm==0.8.5
pip show vllm
pip install transformers==4.51.1 --force-reinstall
pip install numpy==2.0.2 --force-reinstall
pip install --force-reinstall \
  fastapi==0.110.0 \
  starlette==0.36.3 \
  prometheus-fastapi-instrumentator==7.0.0

配置模型下载路径

1
2
3
4
5
6
7
8

mkdir -p /nwa/hf_models
chmod -R 777 /nwa/hf_models
export HF_HOME=/nwa/hf_models
echo 'export HF_HOME=/nwa/hf_models' >> ~/.bashrc
source ~/.bashrc
echo $HF_HOME
# 设置国内镜像就不用科学下载了
export HF_ENDPOINT=https://hf-mirror.com

检查 GPU 环境

1
2
3
4

apt install -y nvidia-utils-560
nvidia-smi
python -c "import torch; print(torch.version.cuda)"
python -c "import torch; print(torch.backends.cuda.is_built())"

下载模型

方法一：HuggingFace 官方源

1
2
3
4
5

pip install -U huggingface_hub
huggingface-cli download Qwen/Qwen3-4B-Instruct-2507 \
  --local-dir /nwa/hf_models/Qwen3-4B-Instruct-2507 \
  --resume-download \
  --local-dir-use-symlinks False

方法二：ModelScope 国内源

1
2
3

pip install modelscope -U
modelscope download --model Qwen/Qwen3-4B-Instruct-2507 \
  --local_dir /nwa/hf_models/Qwen3-4B-Instruct-2507

部署 vLLM 推理服务

直接从线上下载部署

1
2
3

vllm serve Qwen/Qwen2.5-7B-Instruct \
  --host 0.0.0.0 \
  --port 9089

用已下载的模型部署（推荐）

1
2
3
4
5
6
7
8
9

vllm serve /nwa/hf_models/Qwen3-4B-Instruct-2507 \
  --host 0.0.0.0 \
  --port 9089 \
  --dtype half \
  --kv-cache-dtype fp8 \
  --max-model-len 1024 \
  --gpu-memory-utilization 0.99 \
  --enforce-eager \
  --trust-remote-code

切换到 root 并激活环境

1
2

su - root
conda activate vllm

映射 vLLM 端口到宿主机

管理员执行

1
2

netsh interface portproxy add v4tov4 listenport=9089 listenaddress=0.0.0.0 connectport=9089 connectaddress=172.24.212.8
netsh advfirewall firewall add rule name="vllm-9089" dir=in action=allow protocol=TCP localport=9089

Embedding 和 Reranker 部署

创建环境并安装依赖

1
2
3
4
5
6
7
8
9
10
11
12
13
14

conda create -n embedding python=3.10 -y

conda activate embedding
pip config set global.index-url https://mirrors.aliyun.com/pypi/simple   # 配置pip默认阿里云镜像
export VLLM_USE_MODELSCOPE=True
pip install modelscope
pip install vllm==0.8.5
pip show vllm
pip install transformers==4.51.1 --force-reinstall
pip install numpy==2.0.2 --force-reinstall
pip install --force-reinstall \
  fastapi==0.110.0 \
  starlette==0.36.3 \
  prometheus-fastapi-instrumentator==7.0.0

下载 Embedding 模型

1
2

modelscope download --model Qwen/Qwen3-Embedding-0.6B \
  --local_dir /nwa/hf_models/Qwen3-Embedding-0.6B

启动 Embedding 服务

1
2

conda activate embedding
vllm serve --task embed /nwa/hf_models/Qwen3-Embedding-0.6B --host 0.0.0.0 --port 8000

验证：localhost:8000/v1/models

映射到宿主机

1
2

netsh interface portproxy add v4tov4 listenport=8000 listenaddress=0.0.0.0 connectport=8000 connectaddress=172.24.212.8
netsh advfirewall firewall add rule name="embedding-8000" dir=in action=allow protocol=TCP localport=8000

下载 Reranker 模型

1
2

modelscope download --model BAAI/bge-reranker-base \
  --local_dir /nwa/hf_models/BAAI/bge-reranker-base

启动 Reranker 服务

1

vllm serve /nwa/hf_models/BAAI/bge-reranker-base --task score --host 0.0.0.0 --port 7999

验证：localhost:7999/v1/models

映射到宿主机

1
2

netsh interface portproxy add v4tov4 listenport=7999 listenaddress=0.0.0.0 connectport=7999 connectaddress=172.24.212.8
netsh advfirewall firewall add rule name="embedding-7999" dir=in action=allow protocol=TCP localport=7999

改造为 systemd 自动启动服务

服务一：Embedding

1

sudo nano /etc/systemd/system/vllm-embedding.service

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

[Unit]
Description=vLLM Embedding Server
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
User=root
WorkingDirectory=/root

ExecStart=/root/miniconda3/envs/embedding/bin/vllm serve \
    /nwa/hf_models/Qwen3-Embedding-0.6B \
    --task embed \
    --host 0.0.0.0 \
    --port 8000

Restart=always
RestartSec=5

Environment="PATH=/root/miniconda3/envs/embedding/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
Environment="PYTHONUNBUFFERED=1"

[Install]
WantedBy=multi-user.target

服务二：Reranker

1

sudo nano /etc/systemd/system/vllm-reranker.service

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

[Unit]
Description=vLLM Reranker Server
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
User=root
WorkingDirectory=/root

ExecStart=/root/miniconda3/envs/embedding/bin/vllm serve \
    /nwa/hf_models/BAAI/bge-reranker-base \
    --task score \
    --host 0.0.0.0 \
    --port 7999

Restart=always
RestartSec=5

Environment="PATH=/root/miniconda3/envs/embedding/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
Environment="PYTHONUNBUFFERED=1"

[Install]
WantedBy=multi-user.target

启用并启动服务

1
2
3
4
5
6
7

sudo systemctl daemon-reload

sudo systemctl enable vllm-embedding
sudo systemctl enable vllm-reranker

sudo systemctl start vllm-embedding
sudo systemctl start vllm-reranker

查看状态

1
2

systemctl status vllm-embedding
systemctl status vllm-reranker

查看日志

1
2

journalctl -u vllm-embedding -f
journalctl -u vllm-reranker -f

1
2

products.stream().forEach(System.out::println);          // 遍历打印对象，products是列表
Arrays.stream(strArray).forEach(System.out::println);    // 数组遍历打印每一项

Lambda 表达式

Lambda 表达式是 JDK8 引入的函数式编程特性，使用时必须满足：

1. 必须有且仅有一个抽象方法的接口（函数式接口）
2. Lambda 体中调用方法的参数列表与返回值类型，要与函数式接口中抽象方法的参数列表和返回值类型保持一致
3. 若 Lambda 参数列表中的第一个参数是实例方法的调用者，而第二个参数是实例方法的参数时，可以使用 ClassName::method 形式
4. JDK 里的 Runnable、Comparator、Consumer、BiConsumer 接口满足条件，自定义接口只要满足也可以使用

Lambda 表达式语法：

1

(参数列表) -> {重写方法的代码};

• () 里面需要参数就写上，没有则不写，多个参数用逗号隔开
• ->：传参符号
• {}：重写接口的抽象方法的方法体

案例 1：Runnable 线程创建

Runnable 是一个接口，传统方式需要重写 run 方法，使用 Lambda 可以简化代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class Lambda {
    public static void main(String[] args) {
        // 匿名内部类方式
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "线程的实现方法2");
            }
        }).start();

        // Lambda 方式（单行代码可省略大括号）
        new Thread(() -> System.out.println(Thread.currentThread().getName() + "牛逼的Lambda")).start();
    }
}

案例 2：Comparator 集合排序

需要一个实体类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

package com.nwa;

public class Entity {
    private String name;
    private int age;

    public Entity() {}

    public Entity(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }

    @Override
    public String toString() {
        return "Entity{name='" + name + "', age=" + age + '}';
    }
}

如果在实体类中实现 Comparable<Entity> 接口，可以直接调用 Collections.sort(entities) 进行排序：

1
2
3
4
5
6
7
8
9

implements Comparable<Entity>

@Override
public int compareTo(Entity other) {
    return Integer.compare(this.age, other.age);
}

// 调用
Collections.sort(entities);  // 从小到大排序

排序方式对比：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

package com.nwa;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class Lambda2 {
    public static void main(String[] args) {
        ArrayList<Entity> entities = new ArrayList<>();
        entities.add(new Entity("小A", 19));
        entities.add(new Entity("小B", 29));
        entities.add(new Entity("小C", 22));

        // 方式1：匿名内部类
        Collections.sort(entities, new Comparator<Entity>() {
            @Override
            public int compare(Entity entity1, Entity entity2) {
                return entity1.getAge() - entity2.getAge();
            }
        });

        // 方式2：Lambda表达式
        Collections.sort(entities, (entity1, entity2) -> entity1.getAge() - entity2.getAge());

        // 方式3：方法引用（最简洁）
        Collections.sort(entities, Comparator.comparingInt(Entity::getAge));

        for (Entity entity : entities) {
            System.out.println(entity);
        }
    }
}