KIOSHIROI's CS-learning Road

笔记-CSAPP 第12章并发编程

Thu, 14 May 2026 00:00:00 GMT

import { RedirectCard } from '@/components/user'

笔记-DDIA

Thu, 14 May 2026 00:00:00 GMT

import { RedirectCard } from '@/components/user'

笔记-CSAPP 第6章存储器层次结构

Thu, 14 May 2026 00:00:00 GMT

import { RedirectCard } from '@/components/user'

笔记-CSAPP 第8章异常控制流

Thu, 14 May 2026 00:00:00 GMT

import { RedirectCard } from '@/components/user'

笔记-CUDA入门

Tue, 03 Mar 2026 00:00:00 GMT

import { RedirectCard } from '@/components/user'

笔记-Lecture 05: Deployment

Tue, 03 Mar 2026 00:00:00 GMT

import { RedirectCard } from '@/components/user'

笔记-Lecture 04: Data Management

Sun, 08 Feb 2026 00:00:00 GMT

import { RedirectCard } from '@/components/user'

笔记-Lecture 03: Troubleshooting & Testing

Wed, 04 Feb 2026 00:00:00 GMT

import { RedirectCard } from '@/components/user'

笔记-Lecture 02: Development Infrastructure & Tooling

Sun, 01 Feb 2026 00:00:00 GMT

This note is hosted on Notion: Lecture 02: Development Infrastructure & Tooling

笔记-Lecture 01: When to Use ML and Course Vision

Wed, 28 Jan 2026 00:00:00 GMT

import { RedirectCard } from '@/components/user'

MXFP——为量化而生的浮点数们

Wed, 28 Jan 2026 00:00:00 GMT

import { RedirectCard } from '@/components/user'

智能边缘系统搭建常用教程链接（自用）

Mon, 02 Jun 2025 00:00:00 GMT

不知道什么原因，kagent在arm64架构的虚拟机上使用macOS方法才能安装

kind安装
helm安装
docker安装

# 卸载旧版本（如有）
sudo apt-get remove docker docker-client docker-client-latest docker-common docker-latest docker-latest-logrotate docker-logrotate docker-selinux docker-engine-selinux docker-engine

# 安装依赖
sudo apt-get update
sudo apt-get install -y apt-transport-https ca-certificates curl software-properties-common

# 添加 Docker 官方 GPG 密钥
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

# 添加 Docker 软件源
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# 安装 Docker
sudo apt-get update
sudo apt-get install -y docker-ce docker-ce-cli containerd.io

# 启动 Docker 服务
sudo systemctl enable --now docker

k8s集群搭建 linux下载火狐浏览器命令 ARM linux 安装Miniconda [linux 安装 conda]https://blog.csdn.net/Alex_81D/article/details/135692506 ckash for windows chinese github registry clash for windows install agent function call

unbuntu安装

# Ubuntu 20.04 ARM 源（focal）
deb http://mirrors.aliyun.com/ubuntu-ports/ focal main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu-ports/ focal main restricted universe multiverse

deb http://mirrors.aliyun.com/ubuntu-ports/ focal-security main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu-ports/ focal-security main restricted universe multiverse

deb http://mirrors.aliyun.com/ubuntu-ports/ focal-updates main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu-ports/ focal-updates main restricted universe multiverse

deb http://mirrors.aliyun.com/ubuntu-ports/ focal-backports main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu-ports/ focal-backports main restricted universe multiverse

mac下安装k8s

记得有一步会有问题

最好用的ubuntu k8s集群搭建方法

桥接模式 netplan使用 finalshell下载

gpg那一步请使用以下指令：

# 从 Ubuntu 密钥服务器获取并添加公钥
sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys B53DC80D13EDEF05

# 将公钥导出到专用密钥环（推荐）
sudo gpg --export --armor B53DC80D13EDEF05 | sudo tee /usr/share/keyrings/kubernetes-archive-keyring.gpg

Q:为什么go使用k8s.io库会报错 unknown reversion?
- A: 因为k8s.io库要求其版本与k8s版本一致，所以需要在go.mod中指定版本。

近期状态与计划

Sat, 31 May 2025 00:00:00 GMT

期末考试
保研
科研

做完当前工作打算学习一下AI Infra以及系统安全的知识。想学一下网球，下学期蹭一下网球课？还有粤语课和fruitstudio课

k8s 重置 kagent 默认 OPENAI_API_KEY secret

Wed, 09 Apr 2025 00:00:00 GMT

内容为AI生成是的，你可以通过更新关联的 Kubernetes Secret 来修改 OPENAI_API_KEY 的值。以下是具体步骤：

1. 修改 Secret 中的 API 密钥

ModelConfig 引用了名为 kagent-openai 的 Secret 中的 OPENAI_API_KEY 字段。你需要更新该 Secret 的值：

步骤 1：编辑 Secret

kubectl edit secret kagent-openai -n kagent

步骤 2：修改 `OPENAI_API_KEY` 的值

在编辑器中，找到 data.OPENAI_API_KEY 字段，将其值替换为新的 Base64 编码值。例如：

apiVersion: v1
data:
  OPENAI_API_KEY: "新的Base64编码值=="  # 替换为实际值
kind: Secret
metadata:
  name: kagent-openai
  namespace: kagent

注意：如果直接输入明文 API Key，需要先将其转换为 Base64 编码：
```
echo -n "your_new_openai_api_key" | base64
```

步骤 3：保存并退出

保存文件后，Kubernetes 会自动更新 Secret。

2. 验证 Secret 更新

确认 Secret 已生效：

kubectl get secret kagent-openai -n kagent -o jsonpath='{.data.OPENAI_API_KEY}' | base64 -d

输出应为新设置的 API Key。

3. 触发 Operator 重新同步

大多数 Operator（如 kagent）会监听 Secret 变化并自动重新加载配置。如果没有自动生效，可以尝试以下操作：

# 重启 Operator Pod（假设 Operator 名称包含 "kagent-operator"）
kubectl rollout restart deployment -n kagent -l app=kagent-operator

4. 验证 ModelConfig 状态

检查 ModelConfig 是否正常：

kubectl describe modelconfig default-model-config -n kagent

确保 Status.Conditions.Reason 显示为 ModelConfigReconciled，且无错误。

常见问题

权限不足：确保你有权限修改 Secret 和 ModelConfig 资源：

kubectl auth can-i update secret -n kagent
kubectl auth can-i update modelconfig -n kagent

API Key 生效延迟：如果配置未生效，可能是 Operator 的同步延迟。等待几分钟后重试。
Secret 删除风险： ⚠️ 不要直接删除 Secret，否则会导致依赖它的服务认证失败。

替代方案：直接更新 ModelConfig 的 Secret 引用

如果想让 ModelConfig 指向另一个 Secret，直接修改其定义：

kubectl edit modelconfig default-model-config -n kagent

修改 spec.apiKeySecretName 和 spec.apiKeySecretKey 字段，保存后 Operator 会同步更新。

笔记：计算机视觉

Thu, 27 Feb 2025 00:00:00 GMT

1

融合
配准
底片
- middle format
- full format
- 半底片

图像显示打印

半调输出
- 利用人眼的集成特性，通过控制二值点的形式（数量尺寸形状）来获取视觉上不同的灰度感觉。
- 是一种将灰度图像转化为二值图像的技术。
幅度调制（不行）
频率调制：缺点：点增益
控制数量实现：
- 调制模版
  - 2x2 -> 5
  - 3x3 -> 10
  - 4x4(最常用)
dpi:dot per inch(2.54cm)
彩色半调技术：
- 每种rgb只有饱和色和黑色
- 实际打印使用的是红绿蓝的补色

视觉过程

锥细胞柱细胞
人眼是跳着看的
- 人的注意力机制
  - 自顶向下
  - 自底向上

空间分辨率和幅度分辨率

真彩色

2

像素的邻域
- 4邻域$N_4$
- 对角邻域$N_D$
- 8邻域$N_8$
邻接和连接
- 4连接：两个像素p,v在V中取值且r在$N_4(p)$中
- 8连接：两个像素p,v在V中取值且r在$N_8(p)$中
- 混合连接（m连接）：满足一项情况之一：
  - 在$N_4(p)$中
  - 在$N_8(p)$中，且$N_4(p)\cup N_4(r)$是空集
图像坐标变换
- 平移
- 旋转
- 缩放
插值
- 前向映射
- 后向映射
  - 放大后图像整数坐标点映射到原始图像
  - 零阶插值（会产生伪边界）
  - 双线性插值
  - 双三次插值

图像间运算的应用

算术运算
- 加法的应用
  - 通过叠加图像取平均值降低噪声
- 减法
  - 视频监控
逻辑运算
- 补
- 与
- 或
- 异或点运算（直接灰度映射）
图像求反
增强对比度
动态范围压缩 -> 调节图像明暗
灰度切分

2.7 直方图变换

2.7.1 直方图均衡化

直方图：1-D的离散函数
- 提供了图像像素的灰度的分布情况
均衡化的基本思想
- 使像素灰度的动态范围最大
映射曲线 $$ f(D_A) = \int \dfrac{H_A(D_A)}{H_B(D_B)} \mathrm{d} D_A $$

直方图规定化

根据像素数量比确定映射函数 $$ H_B(D_B) = \frac{L}{A_0} \int^D_0 H_A(D_A) \mathrm{d} D_A $$
给定需要做均衡化的图像和你期望的均衡化的值就可以求出均衡化的的映射函数（实际上就是累积分布函数）
给定$H_A$和$H_B$,就可以求出映射函数
$H_A$ -> 累积分布函数 -> 映射到灰阶上 -> $H_B$
彩色的用同一个映射函数做映射

4 空域增强技术

改善图像质量、改善视觉效果
空域：指由像素组成的空间
模板操作：
- 与周围的像素进行处理的操作
分类
- 线性/非线性
- 平滑（模糊、消除噪声）/ 锐化（增强被模糊的细节）
模板卷积（利用图像邻域的相关性）

线性平滑滤波器

邻域平均（平滑滤波器）
- 积分图实现快速均值滤波
加权平均（高斯滤波器）
- 邻域平均忽视了平滑过程中各像素的贡献比例
- 距离中心越远的，贡献越小
- 问题：未考虑边缘

非线性平滑滤波器

双边滤波
- 结合图像空间邻近度与像素相似度
- 双边滤波可以在降噪的同时很好的保持边缘
- 缺点：计算复杂度高
- 当$| I(i, j) - I(k, l)|$越大，即当前像素点与邻域像素点的灰度值差异越大，则降低邻域像素权重。
- $\sigma_d$ 控制空间域的标准差，越大越模糊，$\sigma_r$ 控制灰度域的标准差，越小边缘越清晰。
中值滤波
- 既能消除噪声又能保持细节（不模糊）
- 排序选中值。
- 能很好地处理椒盐噪声
- 存在边缘漂移现象
- 缺点：排序导致复杂度高
- 快速中值滤波器
  - 使用直方图加速中值滤波
- 自适应中值滤波
  - 中值滤波器受滤波窗口大小影响较大，用于消除噪声和保护图像细节，两者相互冲突。

非线性锐化滤波器

利用微分可以锐化图像
平坦->低频边缘->高频

边缘提取

prewitt算子
- 水平方向（检测垂直边缘）： $$ G_x = \begin{bmatrix} -1 & 0 & 1 \ -1 & 0 & 1 \ -1 & 0 & 1 \end{bmatrix} $$
- 垂直方向（检测水平边缘）： $$ G_y = \begin{bmatrix} -1 & -1 & -1 \ 0 & 0 & 0 \ 1 & 1 & 1 \end{bmatrix} $$
- 梯度幅值计算（45°）： $$ G = \sqrt{G_x^2 + G_y^2} $$
- 梯度方向计算： $$ \theta = \arctan\left(\frac{G_y}{G_x}\right) $$
Sobel算子
- 水平方向（检测垂直边缘）： $$ G_x = \begin{bmatrix} -1 & 0 & 1 \ -2 & 0 & 2 \ -1 & 0 & 1 \end{bmatrix} $$
- 垂直方向（检测水平边缘）： $$ G_y = \begin{bmatrix} -1 & -2 & -1 \ 0 & 0 & 0 \ 1 & 2 & 1 \end{bmatrix} $$
- 梯度幅值计算： $$ G = \sqrt{G_x^2 + G_y^2} $$
- 梯度方向计算： $$ \theta = \arctan\left(\frac{G_y}{G_x}\right) $$
拉普拉斯算子
- 4邻域形式： $$ \nabla^2 = \begin{bmatrix} 0 & -1 & 0 \ -1 & 4 & -1 \ 0 & -1 & 0 \end{bmatrix} $$
- 8邻域形式： $$ \nabla^2 = \begin{bmatrix} -1 & -1 & -1 \ -1 & 8 & -1 \ -1 & -1 & -1 \end{bmatrix} $$
- 应用公式： $$ g(x,y) = f(x,y) + k \cdot \nabla^2 f(x,y) $$ 其中$k$为锐化系数，通常取正值
一阶非线性锐化滤波器
二阶非线性锐化滤波器 -> 两条线
锐化：增强边缘
Unsharp Masking
拉普拉斯算子（二阶非线性锐化滤波器）的缺点：
- 对噪声敏感，会导致一些不希望的扭曲
- 对灰度突变敏感，图像的边缘会出现增强过头的现象
- 增强后的图像容易产生伪边缘
LoG滤波器（马儿算子）
- 可以通过调节高斯算子的标准差和半径来控制锐化的尺度
DoG滤波器
- 结合高斯滤波器和拉普拉斯滤波器的优点
- 先对图像进行高斯滤波，再对滤波后的图像进行拉普拉斯滤波
- 可以有效抑制噪声，同时保留图像的边缘信息

5 频域增强原理

傅里叶级数

基本思想：任何周期函数都可以表示为不同频率正弦波和余弦波的线性组合
适用条件：满足狄利克雷条件（周期内绝对可积、有限个极值点、有限个间断点）
信号 -> 三角函数频率 -> 频域

三角形式

$$ f(x) = \frac{a_0}{2} + \sum_{n=1}^{\infty} [a_n \cos(n\omega x) + b_n \sin(n\omega x)] $$ 其中：

基频 $\omega = \frac{2\pi}{T}$（T为周期）
系数计算： $$ a_n = \frac{2}{T} \int_{-T/2}^{T/2} f(x)\cos(n\omega x)dx $$ $$ b_n = \frac{2}{T} \int_{-T/2}^{T/2} f(x)\sin(n\omega x)dx $$

指数形式（通过欧拉公式推导）

$$ f(x) = \sum_{n=-\infty}^{\infty} C_n e^{in\omega x} $$ 其中系数： $$ C_n = \frac{1}{T} \int_{-T/2}^{T/2} f(x)e^{-in\omega x}dx $$

傅里叶变换

核心思想：将非周期信号分解为连续频率的正弦波分量
与傅里叶级数的关系：可视为周期无限大的傅里叶级数推广

连续傅里叶变换

正变换： $$ F(\omega) = \int_{-\infty}^{\infty} f(t)e^{-i\omega t}dt $$

反变换： $$ f(t) = \frac{1}{2\pi} \int_{-\infty}^{\infty} F(\omega)e^{i\omega t}d\omega $$

离散傅里叶变换（DFT）

适用于数字信号处理： $$ F(k) = \sum_{n=0}^{N-1} f(n)e^{-i\frac{2\pi}{N}kn} \quad (k=0,1,...,N-1) $$

二维DFT（图像处理核心）： $$ F(u,v) = \sum_{x=0}^{M-1}\sum_{y=0}^{N-1} f(x,y)e^{-i2\pi(\frac{ux}{M}+\frac{vy}{N})} $$

卷积定理

数学表达： $$ \mathcal{F}{f * g} = \mathcal{F}{f} \cdot \mathcal{F}{g} $$ $$ \mathcal{F}{f \cdot g} = \mathcal{F}{f} * \mathcal{F}{g} $$

实践意义：

空域卷积 → 频域乘积（计算加速）
频域乘积 → 空域卷积（滤波实现）
适用于线性时不变系统分析

图像处理特殊性：

二维卷积需处理行列两个维度
需进行频谱中心化（通过fftshift）
复数运算需保持相位信息

抽样定理

奈奎斯特定理：

采样频率 $f_s \geq 2f_{max}$（信号最高频率）
不满足时会出现混叠（Aliasing）现象

图像处理应用：

下采样前必须进行抗混叠滤波
数字传感器中的CFA滤波设计
莫尔条纹消除原理

数学描述：连续信号$f(x)$经采样后： $$ f_s(x) = f(x) \cdot \sum_{n=-\infty}^{\infty} \delta(x-n\Delta x) $$

频域效应： $$ F_s(u) = \frac{1}{\Delta x} \sum_{k=-\infty}^{\infty} F(u - \frac{k}{\Delta x}) $$

混叠示例：

图像中高频纹理产生低频伪影
旋转运动产生虚假条纹
颜色通道间的串扰

关键性质

线性性：满足叠加原理
平移性： $$ f(x-x_0,y-y_0) \Leftrightarrow F(u,v)e^{-i2\pi(\frac{ux_0}{M}+\frac{vy_0}{N})} $$
对称性：实函数的傅里叶变换具有共轭对称性
卷积定理： $$ f(x,y)*h(x,y) \Leftrightarrow F(u,v)H(u,v) $$

频域滤波步骤

对图像进行DFT得到频谱
设计频域滤波器（低通、高通、带通）
频谱与滤波器函数相乘
进行逆DFT返回空域

典型应用

图像频域滤波（去噪、边缘增强）
频域特征分析（纹理识别）
图像压缩（分离高频/低频信息）
快速卷积计算（利用卷积定理）

频域表示

将空域信号转换为频域后，包含两个核心分量：

幅值谱（Magnitude Spectrum）： $$ |F(u,v)| = \sqrt{Re^2(u,v) + Im^2(u,v)} $$
- 反映不同频率分量的强度分布
- 决定图像的对比度特征
- 在图像中表现为亮度变化模式
相位谱（Phase Spectrum）： $$ \phi(u,v) = \arctan\left(\frac{Im(u,v)}{Re(u,v)}\right) $$
- 记录频率分量的空间位置信息
- 决定图像的结构特征
- 对视觉感知更为重要（实验表明：交换两幅图的相位谱，重建图像会呈现原相位谱对应图像的结构）

应用特性

频域滤波时：
- 低通滤波：主要修改幅值谱（抑制高频分量）
- 高通滤波：同时影响幅值和相位
图像重建：
- 仅用幅值谱 → 得到模糊的能量分布
- 仅用相位谱 → 保留边缘结构但丢失对比度

离散傅里叶变换（DFT）

适用于数字信号处理： $$ F(k) = \sum_{n=0}^{N-1} f(n)e^{-i\frac{2\pi}{N}kn} \quad (k=0,1,...,N-1) $$

二维DFT（图像处理核心）： $$ F(u,v) = \sum_{x=0}^{M-1}\sum_{y=0}^{N-1} f(x,y)e^{-i2\pi(\frac{ux}{M}+\frac{vy}{N})} $$

关键性质

线性性：满足叠加原理
平移性： $$ f(x-x_0,y-y_0) \Leftrightarrow F(u,v)e^{-i2\pi(\frac{ux_0}{M}+\frac{vy_0}{N})} $$
对称性：实函数的傅里叶变换具有共轭对称性
卷积定理： $$ f(x,y)*h(x,y) \Leftrightarrow F(u,v)H(u,v) $$

频域滤波步骤

对图像进行DFT得到频谱
设计频域滤波器（低通、高通、带通）
频谱与滤波器函数相乘
进行逆DFT返回空域

典型应用

图像频域滤波（去噪、边缘增强）
频域特征分析（纹理识别）
图像压缩（分离高频/低频信息）
快速卷积计算（利用卷积定理）

频域增强

卷积理论是频域技术的基础
零相移：不破坏相位谱

频域滤波器设计

低通滤波器

作用：保留低频信息，抑制高频信息，实现图像平滑/模糊 数学模型：

理想低通滤波器(ILPF)： $$ H(u,v) = \begin{cases} 1, & \text{if } D(u,v) \leq D_0 \ 0, & \text{if } D(u,v) > D_0 \end{cases} $$ $D_0:$截断频率 $D(u,v):$ 图像频率

振铃效应

振铃效应是由于理想低通滤波器的频率响应在空间域中引入了振荡现象。这种现象通常表现为图像边缘附近的波纹或振荡，影响图像的视觉质量。振铃效应的产生是因为理想滤波器的频率响应在空间域中对应于一个sinc函数，该函数具有无限长的振荡尾部。滤波器的振铃点越远，振铃效应越明显。

解决方法：

使用巴特沃斯或高斯低通滤波器，它们的频率响应更平滑，能够有效减少振铃效应。
调整滤波器的参数以优化频率响应。

巴特沃斯低通滤波器(BLPF)： $$ H(u,v) = \frac{1}{1 + [D(u,v)/D_0]^{2n}} $$ 从1向0衰减，n值越大越接近ILPF
高斯低通滤波器(GLPF)： $$ H(u,v) = e^{-D^2(u,v)/(2D_0^2)} $$

特点比较：

ILPF：最简单但会产生振铃效应
BLPF：n值越大越接近ILPF
GLPF：最平滑的过渡，空域也是高斯函数

高通滤波器

作用：保留高频信息，抑制低频信息，实现边缘增强 数学模型：

理想高通滤波器(IHPF)： $$ H(u,v) = \begin{cases} 0, & \text{if } D(u,v) \leq D_0 \ 1, & \text{if } D(u,v) > D_0 \end{cases} $$
巴特沃斯高通滤波器(BHPF)： $$ H(u,v) = \frac{1}{1 + [D_0/D(u,v)]^{2n}} $$
高通增强滤波器

应用：

边缘检测
图像锐化
细节增强

带通/带阻滤波器

作用：

带通：只保留特定频率范围内的信息
带阻：抑制特定频率范围内的信息

数学模型： $$ H_{BP}(u,v) = \begin{cases} 1, & \text{if } D_1 \leq D(u,v) \leq D_2 \ 0, & \text{otherwise} \end{cases} $$

$$ H_{BS}(u,v) = 1 - H_{BP}(u,v) $$

应用：

纹理分析
周期性噪声去除
特定方向特征提取

同态滤波

特点：能消除乘性噪声，能同时压缩图象的整体动态范围和增加图象中相邻区域间的对比度
基本原理：

将乘性关系转换为加性关系：$f(x,y) = i(x,y) \cdot r(x,y)$
取对数：$\ln f(x,y) = \ln i(x,y) + \ln r(x,y)$
傅里叶变换
高通滤波（压缩照明分量，增强反射分量）
逆变换和指数运算

应用：

动态范围压缩
对比度增强
阴影消除

频域去噪

周期性噪声去除：

傅里叶变换观察噪声特征
设计陷波滤波器（Notch Filter）
滤除噪声频率分量

带宽自适应滤波：

根据局部频谱特性调整滤波器参数
保留图像细节的同时去除噪声

频域与空域滤波对比

| 特性 | 频域滤波 | 空域滤波 | |------|---------|---------| | 计算复杂度 | 大核时更高效 | 小核时更高效 | | 滤波器设计 | 直观，易于理解频率特性 | 需从频率特性推导 | | 全局性 | 全局处理 | 局部处理 | | 特定频率处理 | 容易精确控制 | 较难精确控制 | | 实现难度 | 需FFT/IFFT | 直接卷积运算 |

实际应用案例

医学图像增强：
- MRI图像的频域去噪
- CT图像的对比度增强
遥感图像处理：
- 卫星图像的大气散射校正
- 周期性条纹去除
工业视觉检测：
- 表面缺陷增强
- 纹理分析与分类

5 图像恢复

图像恢复：
- 技术：无约束和有约束
- 策略：自动和交互
- 处理所在域：空域和频域

图像退化

图象退化指由场景得到的图象没能完全反应场景的真实内容，产生了失真等问题
透镜象差/色差
聚焦不准（失焦）
模糊
噪声
抖动

常见噪声

热噪声：
- 白噪声（频率覆盖整个频谱）
- 高斯噪声（幅度符合高斯分布）
闪烁噪声：
- 粉色噪声
发射噪声
高斯噪声
均匀噪声（不存在）
脉冲噪声
退化模型
退化模型的计算
1D退化过程
退化是现行的
轮换矩阵
退化过程 -> 空间滤波
逆滤波
- $$ g(x,y) = f(x,y) * h(x,y) $$
- $$ G(u, v) = c·F(u, v)·H(u,v) $$
- $$ F(u,v) = \frac{G(u,v)}{H(u,v)} $$
维纳滤波器 $$\hat{F}(u,v)=[ \frac{H(u,v)^2}{|H(u,v)|^2+s[S_n(u,v)/S_f(u,v)]}]G(u,v)$$
维纳滤波器不能实现
维纳滤波器的简化表示 $$\hat{F}(u,v)=[ \frac{H(u,v)^2}{|H(u,v)|^2+s}]G(u,v)$$

消除匀速直线运动模糊

幅值谱不变，相位谱发生改变

6

6.1.2 三基色与色匹配

三种基本色
- 红
- 绿
- 蓝
三色混合/匹配

6.1.3 色度图

CIE-RGB系统
CIE-XYZ系统
- 设每种刺激量的比例系数为x,y,z
- 所有颜色向量组成x>0,y>0,z>0的三维空间第一象限椎体。
- $x+y+z=1$
- 该截面与三个坐标平面的交线构成一个等价三角形，每一个颜色分量与该平面都有一个交点，每一个点代表一个颜色，该点的坐标就是该颜色的XYZ坐标。
色度图（舌形图）
- 舌头红蓝底边成为"紫边"
- 蓝绿红弧边为单色光，数值为波长
- 用途：
  - 获得主波长
  - 获得混合色

6.2 彩色模型

6.2.1 面向硬设备的彩色模型

RGB
CMY
色光三原色
物体光三原色

6.2.2 面向视觉感知的彩色模型

HSI模型
- H：色调
- S：饱和度
- I：密度（intensity，对应成象亮度和图像灰度）
- 两个基本特征：
  - I分量与图像的彩色信息无关
  - H和S分量与人感受颜色的方式紧密相连（合成色度）
RGB转HSI
- $$ H = \arccos \frac{1}{2} \left[ \frac{R-G+R-B}{2\sqrt{(R-G)^2+(R-B)(G-B)}} \right] $$
- $$ S = \sqrt{\frac{1}{3} (R-G)^2 + (R-B)(G-B)} $$
- $$ I = \frac{1}{3} (R+G+B) $$
HSI转RGB
- $$ R = I \left( 1 + \frac{S \cos H}{C} \right) $$
- $$ G = I \left( 1 - \frac{S \cos H}{C} \right) $$
- $$ B = 3I - (R+G) $$

伪彩色增强

原理
- 人眼对颜色比对灰度有较大的分辨能力
- 对原本灰度图像中不同和灰度值的区域赋予不同的颜色以更明显地区分它们

7 图像分割

把图像空间分成一些有意义的区域，与图像中各种物体目标相对应。
基于边缘的分割方法
基于阈值的分割方法
基于区域的分割方法
基于图论的分割方法
基于能量泛函的分割方法

7.1 基于边缘的分割方法

7.1.1 检测原理

7.1.3 二阶导数算子

马儿算子

在每个分辨率上进行如下计算
先用高斯模板卷积
在计算卷积后模板的拉普拉斯值
检测拉普拉斯图像中的过零点作为边缘点

7.1.4 Canny算子

处理流程
1. 高斯滤波滤除噪声
2. 计算每个像素点的梯度强度和方向（Sobel算子）
3. 应用非极大值抑制消除边缘检测带来的杂散响应。
4. 应用双阈值检测确定真实和潜在的边缘
5. 通过抑制孤立的弱边缘完成边缘检测
非极大值抑制
- 对于边缘有且只有一个响应
- 算法：
  1. 对每个像素点，将其梯度强度与沿梯度方向的两个像素点的梯度强度进行比较
  2. 如果当前像素点的梯度强度大于其两个邻域像素点的梯度强度，则保留该像素点，否则抑制该像素点
双阈值检测
- 算法：
  1. 如果像素的梯度值高于高阈值，则将其标记为强边缘像素
  2. 如果像素的梯度值低于低阈值，则将其标记为非边缘像素
  3. 如果像素的梯度值在两个阈值之间，则将其标记为弱边缘像素
  4. 对于弱边缘像素，检查其8个邻域像素，如果其中有一个是强边缘像素，则将其标记为边缘像素，否则将其抑制

7.2 基于阈值的分割方法

一般把感兴趣的区域或目标叫做前景，在分割后的图像中常用白色表示；其余部分称为背景，用黑色表示
单阈值分割

7.2.1 基于全局的阈值分割

最小误判概率算法

设前景像素点灰度概率密度函数为p(x)，背景像素点灰度概率密度函数为q(x)
前景像素个数占图像总像素数百分比为$\theta_1$，背景像素个数占图像总像素数百分比为$\theta_2 = 1-\theta_1$
误判概率：
- 前景误判为背景的概率：$P_1(T) = \int_T^{\infty} p(x)dx$
- 背景误判为前景的概率：$P_2(T) = \int_{-\infty}^T q(x)dx$
总误判概率： $$ E(T) = \theta_1 P_1(T) + \theta_2 P_2(T) $$
最优阈值T的求解：
1. 对E(T)求导并令其为0： $$ \frac{dE(T)}{dT} = -\theta_1 p(T) + \theta_2 q(T) = 0 $$
2. 得到最优阈值条件： $$ \frac{p(T)}{q(T)} = \frac{\theta_2}{\theta_1} $$
当前景和背景的灰度分布都服从高斯分布时： $$ p(x) = \frac{1}{\sqrt{2\pi}\sigma_1} e^{-\frac{(x-\mu_1)^2}{2\sigma_1^2}} $$ $$ q(x) = \frac{1}{\sqrt{2\pi}\sigma_2} e^{-\frac{(x-\mu_2)^2}{2\sigma_2^2}} $$ 其中$\mu_1,\sigma_1$和$\mu_2,\sigma_2$分别为前景和背景的均值和标准差
迭代求解过程：
1. 初始化阈值T（可取图像平均灰度值）
2. 根据T将图像分为前景和背景两部分
3. 计算两部分的均值$\mu_1$和$\mu_2$
4. 更新阈值：$T = \frac{\mu_1 + \mu_2}{2}$
5. 重复步骤2-4直到T收敛或达到最大迭代次数

最大类间方差法OTSU

基本思想
- 一个阈值T将图像像素分为前景和北京两点集，每一点集的方差尽可能小，也就是类内方差最小

最大熵阈值分割法

7.3 基于区域的图像分割

阈值分割的缺点：没有或很少考虑空间关系
要点
- 图像中属于某个区域的像素点必须加以标注
- 在同一区域的像素点必须相连
- 区域之间不能重叠
- 在区域R_i中被一个像素点必须遵从某种规则P(R_i)
- 两个不同的区域R_i和R_j具有的规则不同

7.3.1 区域生长法

基本思想：

碎碎念：矩阵并查集？递归算法？

泛洪填充
- 从种子点开始，向周围像素点扩散，直到达到一定条件停止
分水岭算法
- 主要目标是找出分水线
- 自适应的多阈值分割方法

8 基元检测

8.1 基元检测概述

图像中的基元泛指图像中有比较显著特点的基本单元。
边缘是图像中较底层的基元
角点可以看做两个边缘以接近直角的形式相结合而构成的基元。
直线段可看做两个邻近的又互相平行的边缘相结合而构成的基元。
圆是一种常见的几何形状，圆周可以看做将直线段弯曲，头尾相连而得到
孔表示比较小的圆（相对于周围的区域）。
角点检测
- 角点：曲线上曲率最大的点

8.2 Harris算子

Moravec 算子
能够检测出任意角度上的角点
检测滑动窗口向上下左右等八个方向运动的变化值的最小值作为判断角点的依据

SUSAN算子

笔记：大数据处理概述

Wed, 26 Feb 2025 00:00:00 GMT

1. 概述

1.1 大数据概述

并行计算 vs 分布式计算
- 并行计算：计算密集型
  - 资源管理简单，共享内存访问和同步
- 分布式计算：数据密集型
  - 需要考虑网络通信、数据传输和节点间协调

大数据处理系统的目标：拓展性、容错和高可用性、延迟考虑。

1.2 大数据处理概述

主要处理模式
- 批处理/离线处理
  - 针对有界数据
  - 特点: 批量读入、集中处理
- 流处理/实时处理
  - 针对无界数据
  - 特点: 来一个处理一个
常见大数据处理框架
- 仅批处理：Hadoop
- 仅流处理：Storm
- 批流结合：Spark、Flink
窗口
- 固定窗口
- 滑动窗口
- 会话窗口
一致性
- 再流处理中，一致性可以分为4个级别：
  - at-most-once(最多一次)
  - at-least-once(至少一次)
  - exactly-once(精确一次)
  - end-to-end exactly-once(端到端精确一次)

让我详细解释流处理中的四个一致性级别：

1. **At-most-once（最多一次）**：
   - 最基本的一致性级别
   - 消息可能会丢失，但绝不会重复处理
   - 适用场景：对数据完整性要求不高的场景，如日志收集、监控数据等
   - 示例：实时网站访问统计，少量数据丢失可接受

2. **At-least-once（至少一次）**：
   - 确保消息至少被处理一次
   - 消息不会丢失，但可能会重复处理
   - 需要实现消息重传机制
   - 适用场景：对数据完整性要求高，但可以容忍重复的场景
   - 示例：支付通知，宁可重复通知也不能丢失

3. **Exactly-once（精确一次）**：
   - 确保消息只被处理一次
   - 需要实现消息去重和事务机制
   - 系统复杂度较高，性能开销大
   - 适用场景：对数据准确性要求极高的场景
   - 示例：银行转账处理

4. **End-to-end exactly-once（端到端精确一次）**：
   - 在整个处理流程中（从源到目的地）确保消息只被处理一次
   - 需要源系统和目标系统都支持事务
   - 最难实现，需要完善的错误处理机制
   - 适用场景：金融交易、计费系统等
   - 示例：跨行转账系统

这些一致性级别从上到下，实现难度逐渐增加，系统复杂度也随之提高。在实际应用中，需要根据业务需求和系统复杂度来选择合适的一致性级别。

大数据处理系统发展历程

1. MapReduce

Google MapReduce解决了两个问题（可伸缩性和容错性）
- 提供了一套简洁的数据处理API
- 两个核心操作：Map和Reduce
  - Map: 对数据进行拆分和处理
  - Reduce: 对数据进行汇总和处理

2. Hadoop

Hadoop是MapReduce的开源实现，对开源生态系统产生了巨大影响

3. Storm

第一个真正被广泛采用的流式系统
Storm能够产生低延迟但不精确（弱一致性）的结果
因此产生了Lambda架构

4. Spark

是基于内存计算的大数据并行计算框架
Spark Streaming是Spark的流式计算组件
争议
- Spark Streaming不是真正的流式引擎（微批处理）
- 现在使用Structured Streaming做流处理

5. MillWheel

通过将强一致性和精确一次处理与用于推断时间的工具（如水位和计时器）相结合，战胜了对乱序数据进行健壮处理的挑战，解决了事件时间和处理时间不一致的问题
- 事件时间：事件发生的时间
- 处理时间：事件被处理的时间

6. Kafka

提供一个整洁的持久化模型，将批处理系统具有的诸如持久的、可重放的特性打包在流式处理的友好接口中
在生产者和消费者之间提供弹性隔离层

7. Cloud DataFlow

统一的批流编程模型

8. Flink

开源流处理的创新者
高效的快照实现方式，提供了正确性所需的强一致性保证

9.Be

1.3 大数据处理架构概述

联机事务处理（OLTP）
- 特点：日常事务处理，高并发、低延迟
- 问题：当数据规模越来越庞大，性能下降
- 解决办法：数据库重构，成本高，维护困难
联机分析处理
- 特点：定期ETL，多维数据分析
- 问题：规模受限，无法满足实时分析
Lambda架构
- 适用场景‌：需同时满足实时性与历史数据分析的场景（如用户行为分析）
- 缺点：维护成本高，数据一致性难保障
Kappa架构（核心：Kafka）
- 适用场景‌：实时性要求极高且数据规模持续增长的场景（如IoT设备监控）
- 缺点：依赖历史数据流重放，长期存储与计算资源消耗大
流批一体架构
- 将流式处理和批量处理的优势结合在一个统一的框架中进行数据处理
- 有状态的计算

2. HDFS（Hadoop Distributed File System）

2.1 Hadoop简介

2.2 HDFS简介

计算机集群

分布式文件系统的设计需求

透明性
并发控制
文件复制
硬件和操作系统的异构性
可伸缩性
容错
安全在具体实践中，不同产品实现的级别和方式都有不同。

HDFS设计目标

兼容廉价的
流数据读写
- 流式方式访问文件系统数据：从头到底顺序读取
大数据集
- 文件通常可以达到GB甚至TB级规模
简单的文件模型
- 采用"一次写入，多次读取"的简单文件模型
移动计算比移动数据更便宜
强大的跨平台兼容性

局限性

不适合低延迟数据访问
- HDFS延迟高
无法存储大量小文件
- 访问大量小文件严重影响性能 -> 合成大文件访问
不支持多用户写入及修改文件

HDFS相关概念

数据块
NameNode
Secondary NameNode
DataNode

数据块

HDFS将大文件切分成块，这些块可以分布到不同节点上
默认的数据块大小为128MB
分块存储优势：
- 支持大规模文件存储
  - 一个文件的大小不会受单节点的存储容量的限制，可以远远大于网络中任意节点的存储容量
- 简化系统设计
- 适合数据备份
  - 分布式系统最大要求就是容错
  - 每个文件块可以冗余存储在多个节点上，提高容错性和可用性

NameNode

负责管理分布式文件系统的命名空间及客户端对文件的访问
保存了两个重要文件，FsImage和EditLog
- FsImage：用于维护文件系统树以及文件树中所有的文件和文件夹的元数据
- EditLog：记录所有针对文件的创建、删除、重命名等操作
- NameNode记录每个文件中的各个数据块所在的数据节点的位置信息，但是并不持久化这些信息

Secondary NameNode

辅助EditLog文件和FsImage文件的合并操作
作为NameNode的"检查点"；不能起到"热备份"作用

DataNode

DataNode是分布式文件系统HDFS的工作节点
负责数据的存储和读取
根据客户端或是NameNode的调度来进行数据的存储和检索
并且向NameNode定期发送自己所存储的块的列表
数据会被保存在各自节点的本地Linux文件系统中

2.3 HDFS体系结构

HDFS体系结构概述
- HDFS采用"主从"架构
- 一个HDFS集群包括一个NameNode和多个DataNode
- NameNode是主节点
- 一般一个集群中的DataNode运行一个DataNode进程
  - 每个DataNode周期性（默认3s）向NameNode发送"心跳"保持与NameNode的联系，心跳返回结果带有NameNode的指令
    - 没有按时发送"心跳"的DataNode会被标记为"死亡"（默认连续10次没有收到DataNode的心跳，NameNode会主动主动发送一次检查（默认5m，会重试1次）），NameNode不会再给它们发送任何I/O请求
命名空间管理
- 注意从根目录开始操作
通信协议
客户端
HDFS体系结构的局限性：HDFS只有一个NameNode
- 命名空间限制
- 性能的瓶颈
- 隔离问题
- 集群的可用性
HDFS结合ZooKeeper自动故障转移架构
- 解决了单点故障问题

2.4 HDFS存储原理

冗余数据保存

为了保证系统的容错性和可用性，HDFS采用了多副本（默认3个副本）方式对数据进行冗余存储

数据存储策略机架感知策略

数据存放
- 第一个副本：放置在上传文件的DataNode；如果是集群外提交，则随机挑选出一台磁盘不太满、CPU不太忙的节点
  - 速度快，访问多
- 第二个副本：放置在与第一个副本不同的机架的节点上
- 第三个副本：与第一个副本相同机架的其他节点上
- 更多副本：随机节点
  - 每个DataNode不存放超过一个副本
  - 每个机架的副本数量低于上限[$\dfrac{(副本数量-1)}{机架数量}+2$]
数据读取
- HDFS提供了一个API可以确定一个DataNode所属的机架ID，客户端也可以调用API获取自己所属的机架ID；
- 当客户端读取数据时，从NameNode获得数据块不同副本的存放位置列表，列表中包含了副本所在的DataNode，可以调用API来确定客户端和这些DataNode所属的机架ID，当发现某个数据块副本对应的机架ID和客户端对应的机架ID相同时，就优先选择该副本读取数据，如果没有发现，就随机选择一个副本读取数据
- 省流：优先读同机架的副本读取数据
数据错误与恢复
- 它把硬件出错看作是一种常态，而不是异常
- 1.NameNode出错
  - 把核心文件（FsImage和EditLog）同步复制到备份服务器上。当NameNode出错时，就可以根据备份服务器中的FsImage和Editlog数据进行恢复。
  - 非热备份
- 2.DataNode出错
  - 当DataNode发生故障，或者网络发生断网时，NameNode就无法收到来自一些DataNode的心跳信息，这时，这些DataNode就会被标记为"宕机"，节点上面的所有数据都会被标记为"不可读"，NameNode不会再给它们发送任何I/O请求
  - 有可能出现一种情形，即由于一些DataNode的不可用，会导一些数据块的副本数量小于冗余因子
  - NameNode会定期检查这种情况，一旦发现某个数据块的副本数量小于冗余因子，就会启动数据冗余复制，为它生成新的副本
  - HDFS和其它分布式文件系统的最大区别就是可以调整冗余数据的位置
- 3.数据出错
  - 网络传输和磁盘错误等因素，都会造成数据错误
  - 客户端在读取到数据后，会采用md5和sha1对数据块进行校验，以确定读取到正确的数据
  - 在文件被创建时，客户端就会对每一个文件块进行信息摘录（Message Digest），并把这些信息写入到同一个路径的隐藏文件里面
  - 当客户端读取文件的时候，会先读取该信息文件，然后，利用该信息文件对每个读取的数据块进行校验，如果校验出错，客户端就会请求到另外一个DataNode读取该文件块，并且向NameNode报告这个文件块有错误，NameNode会定期检查并且重新复制这个块

2.5 HDFS数据读写

读文件
- 客户端请求读文件，NameNode根据文件路径等信息判断请求是否合法，如果合法则向客户端返回文件中所有数据块的存放地址，对于第1个数据块，客户端从距离最近的存放该数据块的DataNode读取数据，当第1个数据块读取完毕后，客户端从距离最近的存放该数据块的DataNode读取数据，以此类推，客户端读取下一个数据块，直到读取完所有的数据块
写文件
- 流水线复制
  - 客户端请求写文件，NameNode根据相应策略决定存放文件块的DataNode，并将DataNode的位置告知客户端
  - 客户端与第1个DataNode建立连接，第1个DataNode与第2个DataNode建立连接，第2个DataNode与第3个DataNode建立连接，依次类推。客户端将文件块以流水线的方式写入这些DataNode
  - 第3个DataNode写入完毕后向第2个DataNode发送确认消息，第2个DataNode随后向第1个发送确认消息。最后第1个DataNode向客户端发送确认消息，表明该文件块写入成功。

3. 批处理框架MapReduce

3.1 概述

Map、Reduce可以多个同时并行
MapReduce采用"分治策略"
Map、Reduce输入都是<key, value>，按照一定的映射规则将其转换为另一个或一批<key, value>输出
WordCount实例
- 统计大量文本中的每个单词出现的次数

3.2 传统MapReduce架构

采用"Master/Slave"架构
- JobTracer：主节点运行的后台进程，负责整个集群的资源管理和作业管理
  - 资源管理：通过监控TaskTracer管理集群拥有的计算资源
  - 作业管理：将作业Job分解为任务Task，并且进行任务调度以及跟踪任务的运行进度、资源使用情况
- TaskTracer：从节点运行的后台进程，负责管理本节点的资源、执行JobReducer命令并汇报情况
在实际使用中，通常将MapReduce的输入和输出数据均存放在HDFS中
容错机制
- JobTracer进程故障
  - 单点故障，属于MapReduce架构设计的缺陷
传统架构的缺点
- 资源管理和作业紧密耦合
  - JobTracer既负责作业管理和资源调度，又负责管理集群的资源。
- 作业的控制高度集中

3.3 资源管理器Yarn

概述

Yarn将资源管理功能独立出来
- 一个纯粹的资源管理调度框架
采用"Master/Slave"架构

体系结构

ResourceManager
- 在主节点运行，负责整个集群的资源管理和分配，主要由调度器和应用管理器两个组件构成
NodeManager
- 在从节点运行，负责节点的资源管理和任务管理
- 定期向ResouceManager汇报本节点的资源使用情况和Container运行情况
- 接受并处理来自ApplicationMaster
ApplicationMaster
- 通过与ResourceManager调度器协商获取资源（以Container表示）
Container
- 资源的抽象表示，包括CPU、内存等，是一个动态资源划分单位
应用启动流程
容错机制
- ResourceManager故障
- ApplicationMaster以及Container故障
  - 由于任务与具体框架有关，Yarn只会帮助其重新启动

工作原理

单平台多框架
平台资源分配
- ResourceManager
常用调度器
- FIFO调度器
  - 优点：实现简单
  - 缺点：等待时间长
- Capacity调度器
  - 维护层级式的队列
  - 队列内部FIFO
- Fair调度器
  - 维护层级式队列（共享队列）

3.4 MapReduce工作原理

MapReduce工作过程可分为3个阶段：Map、Shuffle、Reduce

数据输入

MapReduce框架定义了输入格式(InputFormat)
- 输入格式将数据在逻辑上划分若干分片（split）
- 分片的数量往往决定了Map任务的数量
常用InputFormat
- TextInputFormat（行在整个文件中的字节偏移量: LongWritable，行的数据内容: Text）
  - 是默认的InputFormat

Map阶段

将输入的多个Split由Map任务以完全并行的方式处理
每个Map任务对输入分片的记录按照一定的规则解析成<key, value>

Shuffle阶段

Shuffle是指Map阶段数据输出到Reduce阶段数据输入这一整个中间过程
Shuffle过程是MapReduce工作流程的核心环节
Shuffle过程分为
- Map端的Shuffle
- Reduce端的Shuffle

Map端的Shuffle

写入缓存
溢写
文件归并

（1）写入缓存

每个Map任务都被分配一个缓存（默认100MB）
Map任务的输出结果首先写入缓存
在写入缓存前，key和value都被序列化成字节数组

（2）溢写（分区、排序、合并）

当缓存空间达到溢写比例（譬如0.8）时，就会启动溢写(spill)操作
分区(Partition)
- 总的分区数量等于Reduce任务的数量
- 分区规则：取<key, value>中对key的hashCode值，然后对Reduce任务数量求余数，余数为分区编号，分区编号相一致的<key, value>则属于同一分区
- (key.hashCode() & Integer.MAX_VALUE) % numReduceTasks
排序(Sort)
- 对每个分区内的键值对，根据key对他们进行内存排序
合并(Combine)
- 合并是一个可选操作
- 将相同key的<key, value>的value累加起来

文件归并(Merge)

归并是指将那些相同key的键值对合并成一个新的键值对
Map任务最终输出一个大文件存储在节点的本地磁盘中

Reduce端的Shuffle

领取数据
归并数据

领取数据

Map任务完成后会通知ApplicationMaster，然后ApplicationMaster通知相关的Reduce任务进行数据的拉取
Reduce任务收到通知后，会到该Map任务所在节点把属于自己分区的数据领取到本地

归并数据

Reduce任务领取的数据先放入缓存，并对来自Map任务的数据先归并、再合并，然后溢写到磁盘，在磁盘生成一个溢写文件。

Reduce阶段

将归并后得到的若干大文件直接输入Reduce任务

数据输出

输出格式（OutoutFormat）

4. NoSQL数据库

4.2 NoSQL三大基石

CAP
BASE
最终一致性

CAP

一致性（Consistency）
可用性（Availability）
分区容忍性（Tolerance of Network Partition）
- 系统中的一部分节点无法与其他节点通信，分离的系统也能正常运行。
CAP理论告诉我们，一个分布式系统不可能同时满足一致性、可用性和分区容忍性这三个特性，最多只能同时满足其中两项。

BASE

基本可用（Basically Available）
- 是指一个分布式系统的一部分发生问题变得不可用时，其他部分仍然可以正常使用
软状态（Soft State）
- "软状态"是指状态可以有一段时间不同步，具有一定的滞后性
最终一致性（Eventually Consistent）
- 一致性的类型包括强一致性和弱一致性，二者主要区别在高并发的数据访问操作下，后续能否获取最新的数据。
- 最终一致性是弱一致性的一种特例，允许后续的访问操作可以暂时读不到更新后的数据，但经过一段时间之后，最终可以读取到更新后的数据。

ACID是传统关系型数据库的事务处理特性，包括原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）、持久性（Durability），强调强一致性和事务的完整性。而BASE理论是为了适应分布式、高并发等场景而提出的，与ACID理论的设计理念不同，它不是ACID的扩展

4.3 HBase概述

高可靠、高性能、可伸缩的分布式数据库
HBase是一个稀疏、多维、排序的映射表

数据模型相关概念

表
行键
列族
列限定符
单元格
时间戳
HBase是列式数据库

4.4 HBase工作原理

概述

Master服务器
- 负责管理和维护HBase表的分区信息
- 维护Region服务器列表
- 负载均衡
Region服务器
- Region服务器是HBase中最核心的模块，负责维护分配给自己的Region，并响应用户的读写请求
客户端
- 获取Region的存储位置后，直接从Region服务器上读取数据
- 客户端并不依赖Master，而是通过ZooKeeper来获取Region的位置信息
表和Region
- 一个HBase中存储了很多表
- 每个Hbase表中的行，根据行键的值对表中的行进行分区，每个行区间构成一个分区，被称为Region
- 初始时，每个表只有一个Region
- 随着数据的不断插入，当一个Region包含的行数量达到一定阈值，就会自动等分为两个新的Region

Region定位

Hbase使用三层结构来保存Region位置信息
客户端访问数据时的"三级寻址"过程
- 访问ZooKeeper，获取-ROOT-表的位置信息
- 访问-ROOT-表，获取.META.表的位置信息
- 访问.META.表，找出所需Region具体位于哪个Region服务器
- 最后到Region服务器读取数据
寻址过程客户端只需要询问Zookeeper服务器，不需要连接Master服务器

HBase系统架构

Region服务器
- Region服务器是HBase中最核心的模块，负责维护分配给自己的Region，并响应用户的读写请求
- Region的存储
- Region服务器内部管理着一系列Region对象和一个HLog文件
  - 每个Region对象由多个Store组成
    - 每个Store对应表中的一个列族
    - 每个Store又包含一个MemStore（放在内存当中）和若干StoreFile（文件）
      - StoreFile通过HDFS的HFile实现， HFile的数据块通常采用压缩方式存储，可以大大减少网络I/O和磁盘I/O
  - HLog是磁盘上的记录文件，记录着所有的更新操作
Region服务器工作原理
- 写数据
  - 用户写入数据时，被分配到相应Region服务器去执行
  - 数据被分别写到HLog和MemStore
- 读数据
  - 当用户读取数据时，Region服务器会首先访问MemStore缓存
  - 如果找不到，再去磁盘上面的StoreFile中寻找

5. 分布式消息系统Kafka

传统架构问题
- 系统耦合度高
- 数据洪流难以应对
- 重复消费
- 容错性差
Kafka
- 异步解耦：订单服务将订单事件写入Kafka，库存、物流、通知服务并行消费
- 高吞吐量
- 数据的持久化与重放
- 容错与冗余

5.1 什么是Kafka

基本概念

服务器节点（Broker）:每一个Kafka程序实例即为一个Broker。
主题（Topic）：Kafka中的消息以主题为单位进行归类，生产者将消息发送到特定主题，消费者从特定主题进行消费
分区（Partition）：每个主题可以分为多个分区，一个分区只属于单个主题，分区均匀分布在集群中。分区是Kafka高吞吐、容灾、负载均衡的保障。
生产者（Producer）：消息发送方
消费者（Consumer）：消息接收方

5.2 Kafka工作原理

Kafka架构

Producer Group
- Web前端产生的页面、服务器日志等
Consumer Group
- Hadpp集群、实时监控程序、数据仓库或其他服务
Broker Group
ZooKeeper Cluster
- 管理和协调Broker
生产者（Producer）使用Push模式
- 主动将消息推送到Broker
- 优点：实时性好，延迟低
- 适合生产者持续产生消息的场景
消费者（Consumer）使用Pull模式
- 主动从Broker拉取消息进行消费
- 优点：
  - 避免Consumer消息堆积
  - 可以设置offset从任何位置开始消费
  - Consumer可以根据自身处理能力控制消费速率
- 缺点：
  - 如果没有消息时，需要轮询等待，增加了延迟
  - 需要维护消费位移（offset）

主题和分区

Broker将消息按主题和分区组织存储
每个分区是一个有序的、不可变的消息序列
消息通过位移（offset）来标识顺序
Kafka为每个主题维护一个分区日志，记录各个分区消息存放情况
消息写入特点：
- 消息以追加的方式写入到每个分区的尾部
- 消息以先入先出（FIFO）的顺序进行读取
- Kafka可以保证单个分区内消息的顺序，但无法在整个主题范围内保证消息的顺序
分区
- 分区中每条记录都被分配了一个偏移量（offset）
  - 偏移量是一个连续递增的整数，唯一标识该记录在分区中的位置
消息保留策略
- 两种策略：
  - 根据时间保留
  - 根据消息大小保留（用的少）
- 每个Topic可以配置自己的保留策略
分区副本
- 为提高数据的可靠性，同一分区可以复制多个副本分配到不同的Broker上
- 副本分为：领导者副本和追随者副本
- 领导者副本
  - 只有一个
  - 所有生产者和消费者都向领导者副本发送请求
- 追随者副本
  - 追随者副本唯一的任务是从领导者副本复制消息，保持与领导者副本数据和状态的一致
- 当领导者副本发生崩溃时，会从追随者副本中选出一个新的领导者副本
- 副本消息复制机制
  - 跟随者为了与领导者同步，会周期性向领导者发起获取数据的请求（Pull） # 类似消费者
  - 请求消息包含了跟随者想要获取消息的偏移量，偏移量随着每次请求进行递增
  - 领导者从跟随者请求的偏移量可以知道消息复制的进度
- 基于ISR动态复制方案
  - 领导者会动态维护一个需要与其保持同步的副本列表（包括领导者自己），该列表称为ISR。
  - 如果在一定时间内跟随者没有向领导者请求新的消息，该跟随者将被认为不同步，领导者会从ISR中将其移除（防止拖慢整体速度）。
  - 当跟随者重新与领导者保持同步时，领导者会将其再次加入到ISR中。
  - 当领导者失效时，也不会选择ISR中不存在的跟随者作为新的领导者。
  - ISR的列表数据保存在ZooKeeper中，每次ISR改变后，领导者都会将最新的ISR同步到ZooKeeper中。
  - 写入消息时，只有当ISR中所有跟随者都复制完毕，领导者才会将信息写入状态置为Commit（写入成功），而只有状态置为Commit的消息才能被消费者读取。 - 从消费者角度看，要想成功读取消息，ISR中的所有副本必须处于同步状态，从而提高了数据的一致性。 - 可以通过设置参数(min.insync.replicas)指定ISR的最小数量，默认值为1。 - 适当增加min.insync.replicas数量，可以提高系统的可用性。
- 生产者通过ZooKeeper向领导者副本所在的Broker发送消息，领导者收到消息后需要向生产者返回消息确认收到的通知。
  - 可以对acks参数进行配置，指定写消息写入成功的界定：
    - acks=1（默认值）：只要领导者副本写入成功。
    - acks=all：需要ISR中的所有副本写入成功。
    - acks=0：消息发送后即认为成功（不等待Broker的响应）。
  - Broker会通过acks来判断何时向生产者返回响应。

5.2.4 消费者组

消费者组模式

同一消费者组内不允许多个消费者消费同一分区的消息，不同的消费者组可以同时消费同一分区的消息。
- 分区与同一消费者组中的消费者是多对一的关系，而不是一对多的关系。
每条消息发送到主题后，只能发送给某个消费者组中的唯一一个消费者实例。
能够同时具备队列和发布订阅两种模式的特点：
- 如果所有消费者实例属于同一分组，则该过程就是传统的队列模式。
- 如果所有的消费者都不属于同一分组，则该过程就是发布订阅模式。

5.2.5 数据存储机制

Kafka的消息由主题进行分类，而主题在物理上又分为多个分区。
- 在Kafka数据存储中，每个分区的消息数据存储于一个独立的文件夹中，分文件夹的命名规则为"主题名-分区编号"，分区编号从0开始，依次递增。
- 一个分区在物理上由多个段（segment）组成。
  - segment是Kafka数据存储的最小单位。
- 每个分区的消息数据会被分配到多个segment文件中。

segment文件

由两部分组成：
- 索引文件（后缀为.index）
  - 存储元数据，采用稀疏索引记录对应数据文件中消息的物理偏移地址。
- 数据文件（后缀为.log）
  - 存储实际消息。
索引文件和数据文件一一对应，且成对出现。
命名由20位数字组成（编号长度不够以0补充）。
- 同一分区中的第一个segment文件的文件编号从0开始，下一个segment文件的编号为上一个segment文件最后一条消息的offset值。

Kafka查找消息（消费者通过offset查找）

通过offset值定位到索引文件。
通过索引文件查询消息物理偏移地址。
通过物理偏移地址定位消息内容。

6. 流处理系统Storm（不需要掌握的很好）

6.3 体系结构

Storm采用主从架构，主要包含Nimbus、Supervisor、Worker以及ZooKeeper。

Nimbus

主节点运行的后台进程
负责在集群范围内分发代码
为Worker分配任务
监控任务的执行状态

Supervisor

从节点运行的后台进程
负责管理本节点的Worker进程
根据Nimbus的指令启动或停止Worker进程

Worker

运行具体处理组件的进程
每个Worker进程中运行一个或多个Executor线程
Executor线程执行具体的任务（Spout或Bolt的实例）

ZooKeeper

负责Nimbus和Supervisor之间的协调工作
保存集群的状态信息（任务分配、心跳等）
Storm依赖ZooKeeper来确保集群的可靠性：
- 当Nimbus或Supervisor死机，它们可以快速重启并继续工作
- 因为任务信息等都持久化在ZooKeeper中

应用程序执行流程

任务配置
- 用户在代码中可以设置Worker的数量，也可以声明组件的并行度（运行该组件的Task数量）
- 默认情况下，系统中Worker启动的Executor线程总和与所有Task任务数量总和相等
  - 一个Executor线程执行一个任务(Task)
Task分配规则
- 一个Spout/Bolt组件的Task数量在整个Topology的生命周期内保持不变
- Topology中Spout/Bolt组件的并行度的动态调整实际上是通过改变Executor的数量来完成

6.4 工作原理

运行机制

Storm在运行过程中，Spout负责数据的输入，Bolt负责数据的转换和输出
一个Spout或Bolt通常由多个任务同时执行
Spout和Bolt之间，或不同Bolt之间的元组传输表现为上游组件任务和下游组件任务之间的元组传输

数据流分发

需要解决两个问题：
1. 对于流数据来说，上游组件的任务发送哪些元组给下游主键的任务？
2. 对于一个元组来说，上游组件的任务如何向下游组件的任务传递？

任务执行

一个Spout/Bolt通常由多个任务同时执行
每个Worker进程中运行一个或多个Executor线程
Executor线程执行Spout或Bolt的一个或多个任务

6.4.1 流分组

流分组定义了两个存在订阅关系的组件之间进行元组传输的方式
组件在物理上通常由若干任务实现
- 对于上游组件来说：
  - 流分组定义了属于该组件的多个任务发送哪些元组给下游组件的任务
- 对于下游组件来说：
  - 流分组定义了下游组件多个任务之间对元组的划分策略

常见的流分组策略

Shuffle grouping
- 随机分组，也是通常情况下最常用的分组
- Stream中的Tuple被随机分布在Bolt中的Task中，以保证同一级Bolt上的每个Task都能得到相同数量的Tuple
- 通过随机分布来保证同一级Bolt上的每个Task都能得到相同数量的Tuple
Fields grouping
- 字段分组
- 通过为Tuple指定一个字段，根据该指定的字段对Stream进行分组，字段值相同的Tuple会被分配到同一个Task
- 如图所示，具有相同user-id的Tuple会被发送到同一个Task中处理
Partial Key grouping
- 与Fields grouping类似，通过对Stream指定字段进行分组
- 不同的是，该分组会在下游Bolt之间进行负载均衡。当发生数据倾斜时提供了更好的资源利用
All grouping
- 所有Tuple会被复制分发到所有的Task中，相当于广播模式
- 该分组需谨慎使用
Global grouping
- 全局分组
- 整个Stream会被分发到同一个Task中
- 实际上会被分发到ID最小的Task
None grouping
- 表示用户不关心Stream是如何被分发的
- 目前，该分组等同于Shuffle Stream
Direct grouping
- 一种特殊的分组
- 以这种方式分组的Stream意味着产生Tuple的Spout或Bolt自己明确指定Tuple被分配到Bolt的哪个Task
- 使用该分组的Stream必须被声明为Direct Stream
- 发送到Direct Stream的Tuple必须使用Output Collector类中的emitDirect()方法进行发送
Local or shuffle grouping
- 如果目标Bolt有一个或多个Task与Stream源（Tuple的发送者）在同一个Worker进程中，则Tuple会被分发到该Worker进程中的Task
- 否则该方式与Shuffle grouping相同

6.4.2 元组传递方式

通常来说，上游任务需要向下游任务发送多条元组
Storm采用一次一元组的消息传递机制
- 一旦上游组件的任务处理完毕一条元组，则立即发送给下游组件的任务
- 这种立即发送的消息传递机制有利于减少处理的延迟，从而满足实时性需求

6.5 容错机制

6.5.1 容错语义

理想情况下，可靠的容错保障应该使得流计算系统正常处理的消息与发生故障重启后处理的消息全完一致
容错语义分3个级别
- at most once：消息可能会丢失
- at least once：消息不丢失，但可能会重复
- exactly once：消息不丢失，也不重复
一旦Worker发生故障
- 进入该节点的消息可能由Executor线程负责的Task处理，也可能未经处理即随故障的发生丢失
- 重启发生故障的Worker容错语义的级别为at most once
在Spout所在线程无故障的前提下，原生Storm的容错策略达到at least once
- Storm系统将Spout发出的每一条元组及其后续衍生得到的元组视为一颗元组树
  - 如果该元组树中的所有元组均由系统成功输出，则表示源元组得到成功处理
- Storm使用ACK机制对元组树中的元组进行确认
  - 一旦元组树中的某一元组因故障无法得到确认，则系统从Spout将源元组进行重放
  - 整个元组树因某一元组没有得到确认而全部重放，因而可能会存在重复元组

7. 大数据处理平台Spark

7.2.1 基本概念

RDD (Resilient Distributed Dataset)：弹性分布式数据集的简称，是分布式内存的一个抽象概念，提供了一种高度受限的共享内存模型。
DAG (Directed Acyclic Graph)：有向无环图的简称，反映RDD之间的依赖关系。
Executor：是运行在工作节点 (Worker Node) 的一个进程，负责运行Task。
应用 (Application)：用户编写的Spark应用程序。
作业 (Job)：一个作业包含多个RDD及作用于相应RDD上的各种操作。
阶段 (Stage)：是作业的基本调度单位，一个作业会分为多组任务，每组任务被称为阶段，或者也被称为任务集合，代表了一组关联的、相互之间没有Shuffle依赖关系的任务组成的任务集。
任务 (Task)：运行在Executor上的工作单元。

7.2.2 运行架构

Spark运行架构包括
- 集群资源管理器（Cluster Manager）
- 工作节点（Worker Node）
- 驱动器（Driver Program）
- 执行器（Executor）
驱动器 (Driver Program)
- 包含运行应用程序的主函数和构建SparkContext实例的程序
- 驱动器可以运行在应用程序的节点上，也可以由应用程序提交给集群管理器，再由集群管理器安排给工作节点运行
SparkContext
- 是Spark应用程序的入口，是应用程序和Spark集群交互的通道
- 主要用于初始化Spark应用程序所需的基础组件，主要包括：
  - DAG调度器：高层调度器，负责DAG层面的调度，主要用于构建DAG、划分Stage以及提交Stage到任务调度器
  - 任务调度器：底层调度器，负责任务层面的调度，主要负责接收DAG调度器发送过来的任务集以及将任务集加载并注册到集群管理器
  - SchedulerBackend：是调度器的通信终端，主要负责运行任务所需要资源的申请
- SparkContext还负责向Spark管理节点注册应用程序等

7.3 Spark RDD

7.3.1 RDD 简介

RDD 是 Spark 中最基本的数据抽象，代表不可变、可分区和可并行计算的集合。
- RDD 是对分布式、只读的内存数据的抽象。
- RDD 支持丰富的操作。
- 基于 RDD 之间的依赖关系可以生成 DAG。
- RDD 可以缓存在内存中，极大提高了 RDD 的读取效率。

7.5 Spark流处理

7.5.1 Spark Streaming

设计思想
- 微批处理

8. Flink

8.1 Flink概述

Flink集群采用Master-Slave架构，运行时由两种类型的进程组成，分别是JobManager和TaskManager
- JobManager是作业管理器，负责管理调度整个集群资源和作业，它是真正意义上的"管理者"。
- TaskManager是任务管理器，负责执行任务。
Flink处理过程
- 用户编写的程序代码（Program code）以程序数据流（Program Dataflow）的形式传输到优化器（Optimizer）和图生成器（Graph Builder）, 随后构建数据流图（Dataflow graph）并将其传给客户端（Client）。
- 客户端将数据流图以作业的形式提交给JobManager。
- JobManager将数据流图转换为可执行的执行图（Execution Graph），并分发给可用的TaskManager。TaskManager负责执行任务，多个TaskManager之间以数据流（Data Streams）的形式进行交互。
作业和任务的关系
- 在Flink中作业和任务是密切相关的概念，一个作业是一个Flink程序的完整实例，通常由一个或多个任务组成，任务是作业的执行单元，每个任务代表一个数据处理操作的实例。这些任务可以并行地执行，从而实现高效的数据处理和计算。
JobManager
- JobMaster
  - JobMaster是作业执行的核心组件，负责协调和管理作业的执行过程。Flink集群中运行的每个作业都对应一个JobMaster
- ResourceManager
  - ResourceManager是资源管理器，负责Flink集群中资源的分配和管理，所谓资源主要是指TaskManager的Task Slot。
- Dispatcher
  - Dispatcher表示分发器，它负责接收来自客户端的作业提交请求，并将作业分配给JobManager执行。除此之外，Dispatcher还提供了接口供用户查询和监控正在执行的作业。
TaskManager
- 每个任务管理器可以配置多个Task Slot，Task Slot的数量取决于任务管理器的可用资源，Flink可以将任务管理器的可用资源平均分配到每个Task Slot。
- Task Slot可以执行特定的子任务（Subtask），子任务是任务的具体执行实例，每个任务基于并行度可以被划分为多个子任务，这些子任务并行地在不同的线程（Threads）上执行，每个子任务都会单独占用任务管理器的一个线程。
- Flink允许来自同一个作业的子任务共享Task Slot，即使它们是不同任务的子任务，因此一个Task Slot可以执行多个子任务，这些子任务共享Task Slot的资源。
数据模型
- Flink将输入数据看做是一个不间断、无界的记录序列，一系列记录构成DataStream
- Flink程序使用DataStream类表示无界数据，其为一个可以包含重复项的不可变数据集合
- DataStream的特点
  - DataStream中的记录可以是无界的
  - DataStream中的记录是不可变的，一旦创建即无法在物理上改变
计算模型
- Flink提供丰富的算子对DataStream进行转换
- DataStream经转换后生成新的DataStream
- 一系列的转换操作构成一张有向无环图，即描述计算过程的DAG
- Flink中的操作算子可以分为
  - 数据源（DataSource）
    - 描述DataStream数据的来源
  - 转换（Transformation）
    - 描述DataStream在系统中的转换逻辑
  - 数据池（DataSink）
    - 描述数据的走向
- Flink中的DataSink标志计算DAG的结束
Flink程序结构
- Flink程序的构建模块包括流和转换，起始于一个或者多个Source，并终止于一个或者多个Sink。

8.2 DataStream API

执行环境在DataStream程序中扮演着至关重要的角色，它负责任务调度、资源分配以及程序的执行。
DataStream API提供了一个StreamExecutionEnvironment类用于创建和配置执行环境。

8.3 时间和窗口

Flink根据时间产生的位置将数据的时间属性分为事件时间和处理时间两种类型。
1. 事件时间
  - 事件时间指的是无界流的数据在对应的数据生成者产生时的时间属性，也就是数据实际生成的时间。
2. 处理时间
  - 处理时间指的是无界流的数据传输到Flink的窗口算子进行处理时产生的时间属性，也就是数据实际被处理的时间
窗口
- 将无界流划分为多个有界流，并针对每个有界流进行处理，此时的处理结果是针对每个有界流内的所有数据，从而减少了输出处理结果的次数，此过程中产生的每个有界流都视为一个单独的窗口，对于有界流的处理就视为窗口操作。
时间窗口
- DataStream程序每运行一段固定的时间便生成一个窗口，每个窗口由起始时间和结束时间组成，Flink通过窗口的起始时间和结束时间之间的时间差来描述窗口大小，每个窗口内数据集的大小是不固定的，不过每个窗口的窗口大小是固定的。

安装 torch-cuda（通过 whl 安装）

Tue, 25 Feb 2025 00:00:00 GMT

**注意！**在使用以下方法之前，请先安装好anaconda，并在环境变量中配置好环境变量（windows）。

知晓conda create -n和conda activate命令的用法。

未掌握者请前往CSDN自行学习相关知识后再阅读此文。

在使用conda时，建议使用Anaconda Prompt，而不是cmd。

在国内安装cuda版本的torch是一个令人头痛的问题，pip安装使用镜像源加速的方法也不尽人意。在此，参考各种方法后认为使用whl文件安装的方法最快。

点击网址，我这里下载的cu118版本的，如果你需要其他的cuda版本，请回到上级目录选择cuda版本。

**注意！**如何知晓自己的cuda版本？如果您的显卡为集显或非NVIDIA显卡，您不能安装cuda版本，请安装cpu版本。

查看自己的cuda版本的命令：nvidia-smi

如果cuda版本 >= 11.8, 您可以选择cu118版本（cuda是向下兼容的）。否则，请安装更低版本。

我的环境是如下：

操作系统：windows10
虚拟环境：anaconda
python版本：python3.10
cuda版本：12.7

所以我选择了torch-2.3.1+cu118-cp310-cp310-win_amd64.whl文件。

**注意！**cu118代表cuda11.8版本，cp310代表python3.10版本，win代表windows平台。请根据自己实际情况选择适合自己的whl文件。

如何查看自己的python版本？在cmd中输入python --version或python -V即可。

点击后会在浏览器下载，如果你的速度是KB级的，那说明这个方法不适用你。MB级是比较令人满意的速度。下载后，使用pip安装。先到文件下载的目录下，激活你的环境，然后安装whl文件:

注意！请一定要在文件下载的目录下安装，或者使用文件的相对地址或绝对地址安装。

pip install torch-2.3.1+cu118-cp310-cp310-win_amd64.whl -i https://pypi.mirrors.ustc.edu.cn/simple/

在安装torch时需要下载其依赖库，如numpy。亲测pip在安装依赖项时科大源最快。看到最后successfully installed后，就说明我们安装成功了。

接下来测试一下：返回True, 说明安装成功。

torchvision等其他包同理

参考网址

python如何安装各种库——pip, whl 和 tar.gz 最全安装方法
使用国内镜像解决torch-cuda太慢问题
https://mirrors.aliyun.com/pytorch-wheels/cu118/

笔记：类脑与认知计算

Mon, 24 Feb 2025 00:00:00 GMT

1. 绪论

| 主体 | 结构 | 功能 | | ----- | ---- | ----| | 计算机 | 硬件 | 软件 | | 脑 | 神经元 | 认知加工 |

类脑（结构）
认知（功能）
类脑 + 计算 -> 类脑智能
认知 + 计算 -> 认知智能

智能
- 心理能力
  - 从经验中学习的能力
  - 理解和处理抽象概念的能力
  - 使用知识操纵环境的能力
  - 适应环境的能力
认知
- 指人们获取知识和应用知识的心理过程
计算
- 广义计算：信息加工系统具有可计算性
- 认知过程是否可计算
  - 心智哲学中的功能主义
    - 功能主义认为人类心智的物质载体时大脑
    - 心智时人脑的一种功能属性
    - 人脑类似于计算机
  - 心智可计算理论
    - 心智不仅包括认知，也包括意识现象以及人的主观感受性等。
  - 认知的可计算理论
    - 认为神经元活动仅仅解释认知
    - CTC认为心智的某些方面具有不可计算性流出可能性
认知计算
- 用信息处理的方法模拟人的各种认知加工过程。
人工智能与认知科学
- 认知科学
  - 非常重视认知模型的可解释性，而不是预测。
  - 如何利用认知模型帮助我们理解人类的认知加工机制。
- 人工智能
  - 关注技术的性能，忽略可解释性。
| 认知研究范式 | 三大学派 | | ----------- | -------- | | 符号范式 | 符号主义 | | 联结主义范式 | 联结主义 | | 具身智能范式 | 行为主义 |
计算神经科学：综合数学建模、理论分析及计算模拟等方法，阐明神经系统发育、生理过程和认知能力产生的基本原理。
- 计算
  - 研究神经系统信息处理中的计算过程
  - 构建计算模型模拟神经系统
认知神经科学：认知+神经
- 旨在阐明认知活动的脑机制
- 宏观和微观两个研究层次
  - 宏观：脑皮层层次，认知加工的脑机制
  - 微观：分子神经细胞层次，认知加工的神经机制

2. 感知觉

感觉

五感：视听味嗅触
感觉是指感官器官（如眼睛、耳朵、皮肤等）接受和检测外界刺激的过程。
把外界的物理能量转化为神经信号，传递到各个感官对应的大脑皮层的过程。
感觉加工过程：以视觉为例
- 光->视网膜->光感受器->双极细胞->节细胞->LGN->大脑皮层
感觉加工过程：感觉器将物理刺激转化为生物电信号，并通过动作电位把外界事件的信号传递到大脑中枢特定区域的过程。
- 第一步：感觉信息的转录（光 ----> 双极细胞）
- 第二步：编码为动作电位（节细胞 ----> 初级视觉皮层）

感受性与感觉阈限

感觉性：感觉器官对刺激的感受能力。
感觉阈限：
- 绝对感觉阈限：是指刚刚能够引起感觉的最小刺激量。

知觉

定义：认知系统对外界世界建构内部表征的过程。
知觉并不是对现实世界的精确表征
知觉加工过程
- 大脑皮层内部发生
- what通路（腹侧通路）：
  - 负责物体识别和形状分析
  - 从初级视觉皮层（V1）经过V2、V4到下颞叶皮层（IT）
  - 处理物体的形状、颜色、纹理等特征
  - 回答"这是什么？"的问题
- where通路（背侧通路）：
  - 负责空间定位和运动分析
  - 从V1经过V2、MT到顶叶皮层
  - 处理物体的位置、运动、空间关系等信息
  - 回答"在哪里？"的问题

知觉的两种加工过程

自下而上：仅仅是环境刺激，不需要复杂的思维推理等
自上而下：个体运用自己已有的经验和概念来加工当前刺激的过程（高级知识的参与）
知觉的特性
- 错觉：人们在观察物体时，由于物体受到形、光、色的干扰，加上人们的生理、心理原因而误认
- 恒常性：当知觉的对象在一定范围内发生变化，知觉的映像仍然保持相对不变

模式识别

模式：由若干元素或特征按一定关系集合而成的某种刺激结构或刺激的组合。
模板匹配、原型匹配、特征匹配
- 原型匹配
  - 原型：一类客观事物的抽象物，是一类客观事物所共有的一组特征
  - 优点：减轻了记忆的负担；主导类别识别，实现快速分类与范畴化。
  - 缺陷：过渡依赖共性，忽略个体差异。
- 特征匹配理论
  - 特征提取
  - 特征整合
  - 模式匹配
  - 优点：
    - 依据刺激的特征和关系进行识别，抗干扰性强
    - 特征复用，只需记住不同模式中特征间关系，减轻了记忆负担
    - 带有学习色彩

注意

注意的定义：注意是对心智的占用。是指对外在或内在环境的某方面选择性指向和集中，同时忽略其他方面的过程。
注意的特性：
- 选择性
- 分配性
- 持续性
选择注意：
- 自下而上注意与自上而下注意
  - 根据注意朝向的方式是内在还是外在的过程区分。
  - 自下而上注意（外源性注意）
    - 由外在视觉刺激的凸显物理属性引起的选择性注意。
    - 由外部刺激所驱动和控制，属于自下而上的加工。
    - 具有本能反应和自动加工的特性，属于自动化加工。
    - 属于反射性注意。
  - 自上而下注意
    - 根据观察者的行为目标和意图控制注意的朝向。

选择注意的三种模型

过滤模型（1958）
- 注意是一种全或无的过滤器。
- 过滤器在早期选择信息进行加工。
- 未被注意的刺激特征完全被滤波器滤除。
- 如何选择注意通道？
  - 可以采用自上而下的有意注意
  - 也可采用自下而上的反射注意
    - 刺激的凸显性
注意的衰减模型
后期选择模型

特征整合模型
- 两个阶段：特征登记阶段、前注意阶段
- 第二阶段：
  - 特征整合（物体知觉）
    - 形成位置地图
    - 选择注意
    - 集中注意
- 全过程：特征提取->形成位置地图->选择注意->模式匹配
导向搜索模型
- 特征整合模型没有考虑注意选择的方式，如何选择特定的位置。
- 在特征整合理论基础上，增加了注意选择的方式。
- 两个加工过程：
  - 特征加工过程
  - 生成激活映射图。
    - 自下而上：奇异刺激（具有搞得凸显性）
    - 自上而下：受特定的搜寻任务所指导
- 全过程：特征提取->生成激活映射图->形成位置地图->选择注意->模式匹配

3. 记忆

记忆是个体保持和提取过去经验，并在当下应用这些信息的一种能力。
记忆的信息加工阶段
- 信息编码、信息存储、信息提取

短时记忆与工作记忆

短时记忆
- 在短时间内将少量信息保持在一种活跃的，容易获取的状态
工作记忆
- 对信息短时间的存储
- 操纵信息的能力
比较
- 短时记忆仅有存贮功能
- 工作记忆除了具备存贮能力之外，还具备操作功能
- 工作记忆在语言推理和问题解决等高级认知过程中起着重要作用。
组块

长时记忆

在人脑中存储一分钟以上，乃至终身的记忆。
尝试记忆中所存储的信息是过去经历的经验和获取的知识。
短时记忆使个体应对当前的事物或时间，长时记忆使个体生活在过去与现在的世界中。
长时记忆系统
- 陈述性记忆（信息提取方式：外显）
  - 对事实和事件的记忆
  - 语义记忆（关于事实的记忆）
  - 情景记忆（关于事件的记忆）
    - 与个人自身体验有关
    - 在特定时间与空间发生的情景或事件。
    - 发展较晚，退化较早
    - 记忆特性
      - 对时间的主观感觉
      - 以视觉图像的形式呈现
- 程序性记忆（信息提取方式：内隐）
  - 是以技巧性动作为基础的记忆。
  - 程序性记忆通常不能用语言加以描述，需要多次尝试和练习才能逐渐获得，不容易讲述。
  - 记忆的提取是无意识的。
长时记忆中信息存储的检索
- 回忆和再认是检索长时记忆中刺激信息存储的两种方法
- 回忆：是过去经历过的事物的形象或概念在头脑中重新再现的过程
  1. 自由回忆
  2. 线索回忆
- 再认：是指对感知过的事物、思考过的问题、体验过的情绪、联系过的动作，再度出现时仍能认出来的过程。
- 再认与回忆的区别：
  - 再认比回忆简单
  - 再认发展更早

记忆的存储————知识表征

符号取向、联结取向
符号取向
- 命题表征
  - 命题是对事实的表达，可以判断真假
  - 同一命题可以用不同句子表达。
  - 同一在不同语境中可能表达不同命题。
  - 命题是句子中所表达的抽象意义，即能够判断真假的陈述性内容。
- 语义网络
  - 一种用图形结构表示知识的方法
  - 复杂逻辑表达能力有限，推理能力弱。
  - 层次语义网络
    - 通过层级路径搜索和属性继承规则实现推理
  - 激活扩散网络
    - 节点表示概念，便表示概念之间的语义关联程度。
    - 放弃层级结构，允许任意概念间直接关联
- 图式
  - 物质客体的图式（静态）称为框架
  - 核(不变的特征)、槽(变化的特征)
  - 作用：加速认知处理（通过预存模板快速分类信息）
- 脚本
  - 人所从事的某些典型活动，按先后次序所作的有组织的认知称为脚本
  - 用来解释生活中出现的典型事件的序列，以及人类行为的某些固定的模式。
- 程序性知识表征
  - 程序性知识通常与动作有关。
  - 程序性知识在人脑中以产生式规则存储。
  - $条件\longrightarrow 行动$
联结取向

4. 符号主义认知计算

知识的来源

经验论与唯理论（哲学）
- 经验论：
  - 一切只是归根到底都来源于感觉经验。
- 唯理论：
  - 强调理性在知识构建中核心地位。
  - 科学知识具有普遍必然性
  - 天赋观念：某些真理是心灵与生俱来的，无需依赖经验。
符号主义和联结主义
- 符号主义 - 理性推理
- 联结主义 - 经验学习

符号主义认知计算

唯理论：从不证自明的天赋理念（先验理性）出发，遵循理性演绎逻辑推理法。

符号主义认知计算架构包括以下两关键组成部分：
- 手工构造的知识库
  - 知识库是符号主义系统的静态知识存储模块，通过人工定义的符号、规则和逻辑关系对领域知识进行结构化表征。
  - 这一设计源于符号主义对"知识需由理性先验（天赋观念）构建"的哲学立场，强调知识的可解释性与确定性。
- 基于逻辑的推理引擎
  - 推理引擎是符号主义系统的动态计算模块。
  - 通过形式化逻辑（如谓词逻辑、产生式规则）对知识库中的符号进行操作，实现问题求解与决策推理。
  - 推理引擎的运作依赖于符号间的逻辑约束关系，体现**唯理论"理性演绎逻辑推理"**的方法论。
是一种自顶向下的设计模式
逻辑推理：确定性推理和不确定性推理
符号主义确定性推理基于的是演绎逻辑推理
演绎推理
- 如果前提为真且推理形式正确，则结论必然为真
- 演绎推理的演变：古典演绎逻辑->数理逻辑
数理逻辑
- 命题逻辑
  - 使用逻辑连接词（如 ¬（非）、∧（与）、∨（或）、→（蕴含）、↔（等价））连接命题变量。
  - 例子： (P ∧ Q) → R
- 谓词逻辑
  - 在命题逻辑的基础上，增加了谓词符号、变量、常量和量词。
  - 例子： ∀x (P(x) → Q(x))
  - ∃y (R(y) ∧ S(y, z))

认知架构

ACT-R 认知架构

认知架构通用模型和ACT-R认知架构的关系
来源于人类联想记忆
符号主义认知计算的两个核心部分
- 知识库，存储在陈述性记忆中
- 规则推理引擎，存储在程序性记忆中
输入：感觉模块
输出：运动模块
目标模块存储当前任务目标及子目标的层级化状态，为产生式规则提供匹配条件，从而间接驱动任务流程。
工作记忆：4个Buffer
知识表征：
- 陈述性知识与程序性知识
陈述性知识
- 由组块构成
- 组块：组块类型和若干槽组成
- 陈述性知识创建
  - 首先创建组块类型（Chunk-Type）
    - 定义组块的基本结构：(CHUNK-TYPE NAME SLOT1 SLOT2 SLOTN)
  - 再创建具体组块
    - 使用add-dm命令将组块添加到陈述性记忆(declarative memory, dm)中
    - 组块格式：
```
(chunk-name
    isa Name     ; 指定组块类型
    SLOT1 value1 ; 槽位及其值
    SLOT2 value2
    ...
    SLOTN valueN
)
```
程序性知识
- 产生式结构
  - 每个产生式(Production)必须有唯一的命名(name)
  - 产生式条件：用于产生系统的匹配和选择两个操作
    - 如果某产生式指定的所有条件与现有缓冲器内容匹配，该产生式则被选中
  - 产生式行动：当产生式被选中时，执行该产生式的行为(action)
- 产生式格式：
```
(p name    ; p表示production，name为产生式名称
    ; 条件部分：指定Buffer测试
    condition part
    ==>     ; 分隔符
    ; 动作部分：指定Buffer转换
    action part
)
```
- 产生式系统工作流程：
  1. 匹配(Matching)：检查哪些产生式的条件与当前缓冲器内容匹配
  2. 选择(Selection)：从匹配的产生式中选择一个执行
  3. 执行(Execution)：执行被选中产生式的动作部分

Soar认知架构

5. 概率推理

概率推理是一种处理不确定性的推理方法，基于贝叶斯理论，用于在不完全信息的情况下进行决策和预测。

5.1 贝叶斯推理的基本概念

先验概率

先验概率(Prior Probability)是指在获得新证据之前，对某一事件发生可能性的初始估计。
它代表了我们对事件的先验知识或信念，通常基于历史数据、领域知识或主观判断。
表示为P(H)，其中H表示假设。
例如：在医学诊断中，某种疾病在人群中的发病率(如1%)就是该疾病存在的先验概率。

似然概率

似然概率(Likelihood)表示在假设H成立的条件下，观察到特定证据E的概率。
它衡量了证据与假设之间的一致性程度。
表示为P(E|H)，读作"在H条件下E的概率"。
例如：如果患有某种疾病(H)，检测结果呈阳性(E)的概率是95%，则P(E|H)=0.95。

后验概率

后验概率(Posterior Probability)是指在获得新证据后，对假设成立可能性的更新估计。
它结合了先验知识和新证据，形成更新后的信念。
表示为P(H|E)，读作"在观察到E的条件下H的概率"。
例如：在观察到检测结果呈阳性后，患者实际患病的概率。

贝叶斯定理

贝叶斯定理提供了计算后验概率的数学公式： $$P(H|E) = \frac{P(E|H) \times P(H)}{P(E)}$$
其中：
- P(H|E)是后验概率
- P(E|H)是似然概率
- P(H)是先验概率
- P(E)是证据的边际概率，可以通过全概率公式计算： $$P(E) = P(E|H) \times P(H) + P(E|\neg H) \times P(\neg H)$$
调节因子

知觉的贝叶斯推理

知觉也是一种贝叶斯推理
贝叶斯脑假说：认为大脑通过贝叶斯推理机制处理信息，以预测和解释感官输入。
机制：
- 预测与误差修正
  - 大脑基于先验经验生成对未来的预测（先验概率），并将实际感官输入（似然概率）与预测进行对比。当两者存在差异时，通过贝叶斯定理更新内部模型（后验概率），以最小化预测误差。这一过程被称为预测编码，是大脑主动适应环境的核心机制
  - 该假说强调先验知识在信息处理的重要性。
贝叶斯推理与知觉的心理理论的关系
知觉加工
- 知觉不仅仅是一个把一个把感官输入转换为内部表征的自下而上的过程。 --> 似然概率
- 知觉是一个推理过程，将自上而下的先验信息与自下而上的感觉信息相结合。
- 自上而下：编码基于先验信息的预测（先验概率）
- 自下而上：编码器官接收到的信息（似然概率）

5.2 不确定知识

贝叶斯网络表征不确定知识

利用变量间的独立性和条件独立关系减少完全联合概率分布所需指定的概率数目
用于表示变量之间的依赖关系
贝叶斯网络可以本质上表示任何完全联合概率分布
问题：
- 随着变量数目增加计算量呈指数增长
变量X和Y之间独立即：
- $P(X,Y) = P(X)P(Y)$
- $P(X|Y) = P(X)$
- $P(Y|X) = P(Y)$
条件独立性
- 无条件时的关联：
  - X和Y可能存在相关性，即$P(X,Y) \neq P(X)P(Y)$
  - 例如：下雨(X)和地面湿润(Y)这两个事件之间存在相关性
- 条件独立：
  - 给定第三个随机变量Z后，如果X和Y之间的关联被切断，则称X与Y在给定Z的条件下独立
  - 记作：$P(X,Y|Z) = P(X|Z)P(Y|Z)$
  - 例如：
    - 如果我们知道有人浇水(Z)，那么下雨(X)和地面湿润(Y)这两个事件就变得条件独立
    - 因为地面湿润的原因已经确定是浇水，此时下雨与否就不会影响地面湿润的概率了
条件独立性特点：
- 条件独立分布允许将完全联合分布分解成更小的分布
  - 完全联合分布P(X,Y,Z)需要计算所有可能组合的概率
  - 通过条件独立性，可以将其分解为更简单的形式
- 利用条件独立对联合概率分解
  - 一般形式：P(X, Y, Z) = P(X, Y|Z)P(Z)
  - 当X和Y在给定Z时条件独立，可进一步分解为：
    - P(X, Y, Z) = P(X|Z)P(Y|Z)P(Z)
- 优点：
  - 大大减少了需要存储和计算的概率数量
  - 例如：对于二值变量，完全联合分布需要8个概率值
  - 分解后只需要5个概率值（P(Z)和各条件下的P(X|Z)、P(Y|Z)）
贝叶斯网络是一种用概率图表示变量间依赖关系的统计模型。
他结合了概率论和图论的思想，用于表示复杂系统中变量之间的依赖关系。
贝叶斯网络是一个有向图，由节点和有向边组成。
- 节点代表随机变量
- 有向边表示变量之间的依赖关系
如何判断贝叶斯网络中的变量是否条件独立？
- 贝叶斯网络通过**有向分离（d-separation）**规则，判断变量是否条件独立：
  - 如果两个变量在给定一组其他变量的条件下，在贝叶斯网络中不通过任何有向边连接，则称这两个变量在给定这些条件下条件独立。
  - 方法：检查所有从X到Y的无向路径是否被Z阻塞，若所有路径均备足，则X和Y在给定Z时条件独立。
贝叶斯网络的三要素：
1. **变量。**变量用节点表示。
2. 因果关系。
3. 条件概率表。
全连接贝叶斯网络

贝叶斯网络推理

变分贝叶斯推断

变分贝叶斯推断是一种使用KL散度度量来评估概率分布之间相似程度的方法。它通过计算KL散度来比较近似分布Q与后验概率P之间的差异。公式如下：

KL散度公式： $$D_{KL}(Q(x)||P(x|y)) = \sum_x Q(x) \ln \frac{Q(x)}{P(x|y)}$$
后验概率公式： $$P(x|y) = \frac{P(x,y)}{P(y)}$$
KL散度展开： $$D_{KL}(Q(x)||P(x|y)) = \sum_x Q(x) \left( \ln Q(x) - \ln P(x|y) \right)$$

进一步展开为： $$= \sum_x Q(x) \left( \ln Q(x) - \ln P(x,y) + \ln P(y) \right)$$

其中，P(y)相对于x为常数。变分贝叶斯推断通过最小化KL散度来优化近似分布Q，使其尽可能接近真实的后验分布P。这种方法在机器学习和统计推断中广泛应用，用于处理复杂模型中的不确定性

6. 神经元特性

神经元的生理特性

对所通透的例子的选择性很高。
离子通道的显著特征：
- 例子沿着顺离子浓度梯度转运
- 传输速率非常高
钠离子通道和钾离子通道
钾漏通道
- 速率慢
- 比较稳定，对外界刺激不敏感，钾漏通道一直开放
离子泵
- 主动消耗能量
- 逆离子浓度梯度转运
- 离子传输效率不高
钠-钾离子泵
膜电位
- 细胞内外电位差
- 负值
静息电位
- -70mV
动作电位
- 超极化和去极化
- 去极化：动作电位上升
  - 去极化阈值（-55mV）
  - 膜电位去极化到阈值水平
  - 钠离子爆发式内流（大量钠离子通道打开）
  - 钾离子通道关闭
- 复极化：动作电位下降
- 过极化：
  - 复极化导致细胞膜电位出现过度下降，膜电位低于静息电位
  - 钠离子通道未关闭，钠离子外流
- 恢复静息态：
  - 关闭所有离子通道和钠钾-离子泵，重新恢复到静息电位
- 不应期：很难产生动作电位

9. 神经元计算模型

一个神经元等价于一个电容
神经元编码
- 发放率
- 神经响应的时间结构
  - 时间编码
    - 第一个脉冲发放时间
      - 发放时间越早，与刺激关系越强

10. 脉冲神经网络（SNN）

第三代神经网络
ANN与真正的人脑信息处理过程的差异
- 信息载体
  - ANN使用高精度的浮点数进行运算
  - 人脑中，信息会以动作电位或电脉冲的形式传递、接受和处理
- 神经元计算模型
  - ANN忽略动态特性
  - 人脑神经元神经元输入电流与膜电位均随时间动态变化。
- 神经元突触学习
  - ANN通常需要大量的标签数据集驱动网络的拟合（给予梯度现将的反向传播算法）。
  - 人类在很多情况下的感知和学习过程都是非监督式的。
- 能耗的不同
SNN神经元的三个S特性
- Spike 脉冲特性
- Sparse 稀疏特性
- Static suppression 静态压缩特性
神经元编码
- 发放率编码、时间编码、Delta编码、直接编码 -> (与SNN网络分离)
- 直接编码 -> 作为SNN网络的输入编码层（直接输入浮点型数据）

笔记：自然语言处理

Mon, 24 Feb 2025 00:00:00 GMT

1. 绪论

自然语言处理

- 能够理解自然语言的意义（NLU）
- 能够生成自然语言（NLG）

符号学派和随机学派

ACL: CCF A

Sequence-to-Sequence 方法

自然语言处理中的S2S（Sequence-to-Sequence）方法是一种用于处理序列数据的深度学习技术，特别适用于自然语言处理任务，如机器翻译、文本摘要和对话生成。

基本概念：

S2S方法由两个主要部分组成：编码器（Encoder）和解码器（Decoder）。

编码器将输入序列转换为一个固定长度的上下文向量。

解码器从该上下文向量生成输出序列。

工作流程：

编码阶段：输入序列通过编码器，通常由RNN、LSTM或GRU组成，将信息压缩到上下文向量中。

解码阶段：解码器接收上下文向量，并逐步生成输出序列。

注意力机制：

注意力机制允许解码器在生成每个输出时，动态地关注输入序列的不同部分。

应用场景：

机器翻译、文本摘要、对话生成等。

优势与挑战：

优势：处理变长输入和输出，适应性强。

挑战：需要大量数据和计算资源，长序列处理具有挑战性。

自然语言处理的主要难点

语音歧义
词语切分歧义
语义歧义
语用歧义
结构歧义
指代歧义
省略歧义

人工反馈式强化学习RLHF

困惑度

困惑度（Perplexity）是衡量语言模型性能的一个重要指标，反映了模型对文本数据的预测能力。困惑度越低，表示模型对数据的预测越准确。

概念

困惑度是语言模型对测试集的平均不确定性的一种度量。
它是测试集上交叉熵的指数形式，表示模型在预测下一个词时的平均选择数。

计算过程

对于一个给定的语言模型，困惑度可以通过计算模型在测试集上的平均对数似然来得到。
公式为： $$ \text{Perplexity} = 2^{-\frac{1}{N} \sum_{i=1}^{N} \log_2 P(w_i | w_1, w_2, ..., w_{i-1})} $$ 其中，$ N $ 是测试集中词的总数，$ P(w_i | w_1, w_2, ..., w_{i-1}) $ 是模型预测词 $ w_i $ 的概率。

检索增强RAG

2. 词汇分析

不在课堂小测和作业的内容不会以计算形式出现

词是形式和意义相结合的单位，也是语言中能够独立运用的最小单位。
掌握一个词汇意味着知道其读音和语义
自然语言处理算法中词通常是基本单元

llm中token是基础单位

词通常是由语素构成。
- 语素是语言中意义的最小单元。
- 简单词、复杂词
- 实义词（表达具体的意义）、功能词（为了满足语法功能需求，也称闭类词）
词性（POS）也称词类
- 名词
  - 专有名词是我们自然语言处理中需要特别关注的词汇。
- 动词
  - 句子这一类分析重点关注的词汇。
- 形容词
  - 情感分析重点关注的词汇。
- 副词
  - 阅读理解比较关注。作用不大。
- 数词
  - 自然语言中最难的一类词。
- 代词
  - 代词消解->人称代词、物主代词
- 冠词
  - 语法改错，没人做了，打不过大模型。
- 介词
  - 句法分析。
- 连词
  - but
词语规范化：将单词或词形转化为标准形式，针对由多种形式的单词使用一种单一的形式进行表示。
词形（Token）指的是在一个特定文档中的某个能够表达语义含义的字符序列。
词形还原：将一个词的多种形式还原为它们的基本形式。
词形分析：将一个词分解成为语素的过程。
词干提取

中文分词

困难：
- 分词规范
- 歧义切分
  - 固有歧义
  - 真歧义
  - 交集歧义
- 未登录词识别

基于最大匹配的中文分词

前向最大匹配
后向最大匹配
根据给定的字典，利用贪心搜索策略找到分词方案。

def forward_max_match(sentence, dictionary, max_len=5):
    """
    前向最大匹配算法
    Args:
        sentence: 待分词的句子
        dictionary: 词典（set类型）
        max_len: 最大词长
    Returns:
        分词结果列表
    """
    words = []
    start = 0
    while start < len(sentence):
        word_len = min(max_len, len(sentence) - start)
        # 从最大长度开始尝试匹配
        while word_len > 0:
            word = sentence[start:start + word_len]
            if word in dictionary or word_len == 1:
                words.append(word)
                break
            word_len -= 1
        start += word_len
    return words

def backward_max_match(sentence, dictionary, max_len=5):
    """
    后向最大匹配算法
    Args:
        sentence: 待分词的句子
        dictionary: 词典（set类型）
        max_len: 最大词长
    Returns:
        分词结果列表
    """
    words = []
    end = len(sentence)
    while end > 0:
        word_len = min(max_len, end)
        # 从最大长度开始尝试匹配
        while word_len > 0:
            word = sentence[end - word_len:end]
            if word in dictionary or word_len == 1:
                words.insert(0, word)
                break
            word_len -= 1
        end -= word_len
    return words

# 示例使用
if __name__ == "__main__":
    # 示例词典
    dictionary = {"我们", "在", "学习", "自然", "语言", "处理", "自然语言", "自然语言处理"}

    # 测试句子
    sentence = "我们在学习自然语言处理"

    # 前向最大匹配
    forward_result = forward_max_match(sentence, dictionary)
    print("前向最大匹配结果:", "/".join(forward_result))

    # 后向最大匹配
    backward_result = backward_max_match(sentence, dictionary)
    print("后向最大匹配结果:", "/".join(backward_result))

基于线性链条件随机场的中文分词

将分词过程转化为对字分类的问题。
- 对于输入橘子的每一个字，根据他在分词结果中的位置腹语不同的标签
- BIES标注法：
  - 开始B，中间I，结尾E和单独成次S

他是研究生物科学的一位科学家他|是|研究|生物科学|的|一位|科学家他/S 是/S 研/B究/E 生/B物/I科/I学/E 的/S 一/B位/E 科/B学/I家/E

条件随机场(不要求掌握)
- 对于给定的观测序列，概率，势函数，马尔科夫状态转移

BPE算法（Byte Pair Encoding）

基本原理：迭代地合并最频繁出现的字符对
具体步骤：
1. 准备语料库，将所有单词拆分为字符序列，在每个单词末尾添加特殊符号
2. 统计所有相邻字符对的频率
3. 合并最频繁出现的字符对，形成新的子词
4. 重复步骤2-3直到达到预设的词表大小或合并次数
优点：
- 可以处理未登录词
- 压缩效率高
- 适应性强
示例：

"lower" -> "l o w e r </w>" 多次合并后可能变成 "low er </w>"

WordPiece算法

基本原理：基于概率最大化的子词分割算法
与BPE的主要区别：
- 使用语言模型计算合并的收益
- 选择合并后能最大化训练数据概率的字符对
具体步骤：
1. 初始化词表为基本字符集
2. 对每个可能的合并计算概率增益
3. 选择增益最大的字符对合并
4. 重复2-3直到达到预设条件
特点：
- 常用词保持完整
- 生僻词会被分解为更小的子词
- 使用"##"标记词中间的子词
应用：
- BERT等预训练模型的分词算法

中文分词的评价

评价指标
- 准确率（Precision）：
  - 正确分词的词数 / 系统分词结果的总词数
  - P = 正确分词数 / 系统分词总数
- 召回率（Recall）：
  - 正确分词的词数 / 标准答案的总词数
  - R = 正确分词数 / 标准答案总数
- F1值：
  - 准确率和召回率的调和平均
  - F1 = 2 × P × R / (P + R)
评价难点
- 分词标准不统一
- 歧义切分的判定
- 未登录词的处理
评价工具
- SIGHAN分词评测工具
- NLPIR分词评测系统

词性标注（不要求掌握具体怎么做）

词性标注的主要难点在于歧义性
还没有一个被广泛认可的统一词性划分标准
基于规则的词性标注
- 利用词典和搭配规则针对词语和上下文进行分析，从而得到句子中每个词语词性
基于隐马尔科夫模型的词性标注
- 长句子和未登录词问题实际应用中需要解决问题
基于卷积神经网络的词性标注
评价指标：宏F1

3. 句法分析

句法：研究自然语言中不同成分组成句子的方式以及支配句子结构决定句子是否成立的规则。
语法：指自然语言中句子、短语以及词等语法单位的语法结构和语法意义的规律。
基于成分关系，基于依存关系
成分语法理论
- 成分又称短语结构，是指一个句子内部的结构成分。
- 某一类短语属于一个句法范畴。
  - 句法范畴之间不是完全对等的，而是具有层级关系。
- 短语结构规则
- 成分语法就是由语法范畴以及短语结构规则定义的语法。
依存语法理论
- 句子的每个成分对应语法结构中的唯一一个节点。
- 投射性原则
- 两种搜索方式：
  - 自顶向下
  - 自顶向上

CYK算法，基于动态规划思想和自底向上语法分析算法

要求所使用的语法必须符合乔姆斯基范式，期语法规则被限制为**只具有A->BC或A->w这种形式。
步骤：
- 对于一个长度为n的句子，构造一个（n+1）×（n+1）的二维矩阵T
- 矩阵主对角线一下全部为0，主对角线上的元素由输入橘子的终结符号（单词）构成。

class CYKParser:
    def __init__(self, grammar):
        """
        初始化CYK解析器
        grammar: 字典形式的CNF文法规则
        """
        self.grammar = grammar

    def parse(self, sentence):
        """
        CYK算法实现
        sentence: 输入句子（词序列）
        """
        n = len(sentence)
        # 初始化表格
        table = [[set() for j in range(n)] for i in range(n)]

        # 填充对角线（长度为1的子串）
        for i in range(n):
            word = sentence[i]
            for rule in self.grammar:
                if word in self.grammar[rule]:
                    table[i][i].add(rule)

        # 填充其他单元格
        for length in range(2, n + 1):  # 子串长度
            for i in range(n - length + 1):  # 起始位置
                j = i + length - 1  # 结束位置
                for k in range(i, j):  # 分割点
                    for rule in self.grammar:
                        for production in self.grammar[rule]:
                            if isinstance(production, tuple) and len(production) == 2:
                                B, C = production
                                if B in table[i][k] and C in table[k+1][j]:
                                    table[i][j].add(rule)

        return table

if __name__ == "__main__":
    # 示例语法规则
    grammar = {
        'S': {('NP', 'VP')},
        'NP': {('DET', 'N'), 'N'},
        'VP': {('V', 'NP')},
        'DET': {'the'},
        'N': {'cat', 'dog'},
        'V': {'chased'}
    }

    # 创建解析器
    parser = CYKParser(grammar)

    # 测试句子
    sentence = ['the', 'cat', 'chased', 'the', 'dog']
    result = parser.parse(sentence)

实验结果：

开始解析句子: the cat chased the dog
句子长度: 5

步骤1: 初始化解析表格

步骤2: 填充对角线（处理单个词）

处理词: the
  找到规则: DET -> the
  位置[0,0]的非终结符: {'DET'}

处理词: cat
  找到规则: N -> cat
  位置[1,1]的非终结符: {'N'}

处理词: chased
  找到规则: V -> chased
  位置[2,2]的非终结符: {'V'}

处理词: the
  找到规则: DET -> the
  位置[3,3]的非终结符: {'DET'}

处理词: dog
  找到规则: N -> dog
  位置[4,4]的非终结符: {'N'}

步骤3: 填充其他单元格（处理短语）

处理长度为 2 的子串:

  子串: the cat
    分割点 k=0:
    左半部分: the -> {'DET'}
    右半部分: cat -> {'N'}
      应用规则: NP -> DET N
    位置[0,1]的非终结符: {'NP'}

  子串: cat chased
    分割点 k=1:
    左半部分: cat -> {'N'}
    右半部分: chased -> {'V'}
    位置[1,2]的非终结符: set()

  子串: chased the
    分割点 k=2:
    左半部分: chased -> {'V'}
    右半部分: the -> {'DET'}
    位置[2,3]的非终结符: set()

  子串: the dog
    分割点 k=3:
    左半部分: the -> {'DET'}
    右半部分: dog -> {'N'}
      应用规则: NP -> DET N
    位置[3,4]的非终结符: {'NP'}

处理长度为 3 的子串:

  子串: the cat chased
    分割点 k=0:
    左半部分: the -> {'DET'}
    右半部分: cat chased -> set()
    分割点 k=1:
    左半部分: the cat -> {'NP'}
    右半部分: chased -> {'V'}
    位置[0,2]的非终结符: set()

  子串: cat chased the
    分割点 k=1:
    左半部分: cat -> {'N'}
    右半部分: chased the -> set()
    分割点 k=2:
    左半部分: cat chased -> set()
    右半部分: the -> {'DET'}
    位置[1,3]的非终结符: set()

  子串: chased the dog
    分割点 k=2:
    左半部分: chased -> {'V'}
    右半部分: the dog -> {'NP'}
      应用规则: VP -> V NP
    分割点 k=3:
    左半部分: chased the -> set()
    右半部分: dog -> {'N'}
    位置[2,4]的非终结符: {'VP'}

处理长度为 4 的子串:

  子串: the cat chased the
    分割点 k=0:
    左半部分: the -> {'DET'}
    右半部分: cat chased the -> set()
    分割点 k=1:
    左半部分: the cat -> {'NP'}
    右半部分: chased the -> set()
    分割点 k=2:
    左半部分: the cat chased -> set()
    右半部分: the -> {'DET'}
    位置[0,3]的非终结符: set()

  子串: cat chased the dog
    分割点 k=1:
    左半部分: cat -> {'N'}
    右半部分: chased the dog -> {'VP'}
    分割点 k=2:
    左半部分: cat chased -> set()
    右半部分: the dog -> {'NP'}
    分割点 k=3:
    左半部分: cat chased the -> set()
    右半部分: dog -> {'N'}
    位置[1,4]的非终结符: set()

处理长度为 5 的子串:

  子串: the cat chased the dog
    分割点 k=0:
    左半部分: the -> {'DET'}
    右半部分: cat chased the dog -> set()
    分割点 k=1:
    左半部分: the cat -> {'NP'}
    右半部分: chased the dog -> {'VP'}
      应用规则: S -> NP VP
    分割点 k=2:
    左半部分: the cat chased -> set()
    右半部分: the dog -> {'NP'}
    分割点 k=3:
    左半部分: the cat chased the -> set()
    右半部分: dog -> {'N'}
    位置[0,4]的非终结符: {'S'}

解析完成！
句子符合语法规则！

PCFG算法（概率上下文无关文法）

实验课内容

关键字提取

TF-IDF（词频-逆文档频率）

基本原理：结合词频（TF）和逆文档频率（IDF）来评估词语对于文档集合的重要程度
计算公式：
- TF（词频）：词语在文档中出现的频率
```
TF = 词语在文档中的出现次数 / 文档的总词数
```
- IDF（逆文档频率）：衡量词语的普遍重要性 $$ IDF(t, D) = log(文档总数N / 包含该词t的文档数) + 1 $$
- TF-IDF分数：
```
TF-IDF = TF × IDF
```
特点：
- 词语在文档中出现次数越多，TF值越高
- 词语在越少的文档中出现，IDF值越高
- 能够过滤掉常见词，突出重要词语
应用：
- 文本关键词提取
- 文本相似度计算
- 文本分类
- 搜索引擎结果排序

TextRank 算法

TextRank是一种基于图的无监督关键词提取和文本摘要算法

文本预处理：

分词
去除停用词
词性过滤（可选）

构建共现图

节点：图中的节点代表文本中的词语
变：如果两个词语在一定窗口大小内贡献，则在他们之间建立边。边的权重通常基于共现频率或其他相关度量。

计算节点权重：

使用迭代算法计算每个节点的权重。
初始化每个节点的权重为相同值
迭代更新节点权重，直到收敛或达到最大迭代次数
更新公式类似于PageRank： $$ Score(A) = (1-d)+d\times \sum_{B\in In(A)} \dfact{Score(B)}{Out(B)} $$ 其中，d是阻尼系数(通常为0.85)，In(A)是指向节点A的所有节点，Out(B)是B指向的所有节点

4. 语义分析

语义学概述

研究语言意义的科学成为语义学
语义的形式化结构表示成为语义表示

词汇语义学

词汇语义学：主要研究单个词汇的意义以及词汇之间的相互关系

词汇语义理论

语义场理论：词汇的意义是相互联系的，构成一个完整的系统和网络，具有某些相同语义特征的一组词聚而成场
语义成分分析：词义可以由最小的语义成分组合而成。最小的语义成分称为语义特征。
义元理论：自然语言中包含非常少部分的词汇，这些词语可以用于解释绝大部分的意义
- Hownet
框架语义学：词义只能在相应的知识框架背景中才能得到理解。

词汇之间的关系

形体关系：研究词汇的声音形体和拼写之间的关系
意义关系：主要关注词汇意义之间的关联性、相似性、对立性等关系。
实体关系：主要研究词汇之间的客观关系。

句子语义学

真值条件语义学
格语法：
- 语义格：最小的句子语义成分
句子间关系：
- 同义关系
- 反义关系
- 蕴含关系
- 预设关系

语义表示

语义表示：将语义信息转化为计算机能够处理的形式
数理逻辑表示法
框架表示法
- 每个框架由若干槽组成，描述框架所讨论对象的某一方面的属性。
语义网络：
- 是一种用实体及其语义关系来表达知识和语义的网格图。语义网络由节点和弧组成：节点表示各种事件、事物、概念、属性、动作等，也可以是一个子网络；弧表示节点之间的语义关系，并且有方向。

分布式表示

将文本教师为低维空间下稠密向量，并在低维表示空间中利用表示向量之间的计算关系，体现文本间的语义关联。
向量空间模型（VSM）
独热表示

单词分布式表示

通过将单词表视为定长的低维稠密向量
在向量空间构建单词之间的语义关系。
使含义相近的单词具有相似的向量表示
- 频繁出现在相同上下文的词语之间赋予较高的表示相似度。
单词向量式表示--基于上下文单词预测词向量模型
- 共现矩阵
- 连续词袋模型(CBOW)
- 跳字模型（SG）
- 全局向量模型（GloVe）
未登录词 -> 用"[UNK]表示

分布式表示的评价

内部评价、外部评价

句子分布式表示

句子分布式表示：将句子转化为低维稠密向量
句子分布式表示的方法
- 句子向量表示
  - 句子向量表示的方法：
    - 句子平均词向量

篇章分布式表示

TF-IDF

词义消歧

语义角色标注

XLNet

自回归模型与自编码模型

自回归模型（如GPT）通过预测序列中的下一个词来进行训练。
自编码模型（如BERT）通过掩盖输入序列中的某些词并预测这些词来进行训练。

XLNet模型

排序语言模型
通过随机打乱句子中词的顺序，让模型在预测某个词时，能同时看到这个词的"前后"上下文信息。
不改变输入顺序
引入Mask矩阵模拟排列，通过掩码控制每个词能"看到"哪些词。
双流自注意机制
- 内容流
- 查询流

6. 语言模型

语言模型的发展历程

ELMo为代表的动态词向量模型开启了语言模型预训练的大门
此后以GPT和BERT为代表的基于Transformer的大规模预训练语言模型的出现，使得自然语言处理全面进入了预训练微调范式新时代。

单标签分类

NLLLoss
- $$ \sum y\log \hat{y} $$
CrossEntropyLoss
- softmax + NLLLoss

多标签分类

对每一个标签分别作二分类判断
使用BCEWithLogitsLoss(Binary Cross Entropy With Logits)
BCEWithLogitsLoss = Sigmoid + BCELoss

多任务学习

多任务学习是指同时学习多个相关任务的方法，旨在提高模型的性能和泛化能力。
多任务学习的目标是在多个任务之间共享模型的参数，从而提高模型在多个任务上的性能。
分类：
- 硬共享（Hard Parameter Sharing）
  - 不同任务共享相同的隐藏层，只在输出层使用任务特定的参数
  - 最常用的多任务学习方法
  - 优点：大大减少过拟合风险
  - 适用于相关性较强的任务
- 软共享（Soft Parameter Sharing）
  - 每个任务有自己的模型和参数
  - 通过正则化使不同任务的参数相似
  - 常用L2距离等约束参数差异
  - 适用于相关性较弱的任务
- 层次共享（Hierarchical Sharing）
  - 在不同层次上进行参数共享
  - 底层共享基础特征提取
  - 高层保持任务特定表示
  - 适合具有层次性的任务
- 共享-私有（Shared-Private）
  - 同时包含共享网络和任务私有网络
  - 共享网络学习通用特征
  - 私有网络学习任务特定特征
  - 通过对抗训练等方式保证特征分离

信息抽取

命名实体识别

命名实体识别一般包含两个步骤，分别是实体边界判断和实体类别判断。
命名实体从表现形式还可以进一步分为两种类型：非嵌套命名实体（Non-nested Named Entities）和嵌套命名实体（Nested Named Entities）。

非嵌套命名实体识别-基于Transformer的命名实体识别

由于Transformer结构可以很好的并行化，并且具有较好的建模长文本的能力，因此基于Transformer结构的深度神经网络被广泛地应用于很多自然语言处理任务，如机器翻译，语言建模，预训练模型等.
直接在命名实体识别任务上使用Transformer模型往往表现不佳
- 位置编码无法捕捉方向信息：原始Transformer结构使用正弦位置编码，这种编码可以捕捉距离信息,但是不能捕捉方向信息。
- 平滑的注意力分布：Transformer模型在计算注意力时会对注意力分数进行缩放，得到一个较为平滑的注意力分布
  - 对命名实体识别任务来说，上下文中少数的词就足够用来判断它的标签，平滑的注意力分布反而可能会引入更多的噪声。

关系抽取

旨在从无结构文本中识别两个或多个实体之间的语义关系
二元关系抽取
实体间的关系可以用 HEAD, RELATION, TAIL 三元组进行表示
关系抽取任务目标是识别实体间语义关系，因此依据是否已经在无结构文本中标记了实体类型，关系抽取方法可分为联合式抽取和流水线式抽取
关系抽取算法可以分为
- 预定义关系抽取
  - 有监督和远程监督
- 开放关系抽取

有监督

有监督的关系抽取方法将关系抽取问题转换为多分类问题
复杂！

远程监督

远程监督方法假设知识库中两个实体存在某种关系，那么所有提及了这两个实体的句子都表达了这种关系。

远程监督方法错误标注的根本原因

远程监督方法的核心假设是：若知识库中两个实体存在某种关系，则所有提及这两个实体的句子均表达该关系。这一假设虽然能快速生成大量训练样本，但存在以下关键缺陷：

1. 共现≠关系

问题本质：实体在文本中的共现（Co-occurrence）并不必然表达知识库中预定义的关系。
- 示例：
  - 正确标注： "Steve Jobs 是 Apple 的联合创始人。" → 符合知识库关系 /business/company/founders。
  - 错误标注： "Steve Jobs 去世当天，Apple 发布了 iPhone 4S。" → 仅共现实体，但未表达创始人关系。
后果：模型会将无关上下文误判为正样本，学习到错误的关联模式。

2. 语义歧义性

挑战：自然语言中实体关系的表达具有复杂性和歧义性。
- 示例： "Apple 任命 Tim Cook 接替 Steve Jobs。"
  - 知识库中可能存在关系 /business/company/ceo（Tim Cook 是 Apple CEO）。
  - 但远程监督会错误地将此句标注为 founders 关系，因包含 Apple 和 Steve Jobs。
后果：模型无法区分关系的具体类型，导致泛化能力下降。

3. 数据稀疏性与长尾分布

问题：知识库通常覆盖高频关系，但低频或长尾关系难以通过远程监督有效捕捉。
- 示例：
  - 若知识库未收录 Apple 与 Tim Cook 的 CEO 关系，则相关句子不会被标注。
  - 反之，高频关系（如 founders）的噪声样本会淹没低频关系的学习。
后果：模型对低频关系的学习效果差，且噪声数据加剧过拟合风险。

4. 上下文独立性假设不成立

核心漏洞：远程监督假设"实体共现的上下文无关"，但实际关系表达高度依赖上下文。
- 示例： "Steve Jobs 的创新精神推动了 Apple 的发展。" → 隐含 founders 关系。 "Apple 的新 CEO Tim Cook 面临挑战。" → 隐含 CEO 关系。
  - 远程监督无法区分这两类上下文，统一标注为 founders。
后果：模型无法捕捉细粒度的语义差异，导致预测结果粗糙。

5. 对知识库覆盖范围的依赖

局限性：远程监督的效果高度依赖知识库的覆盖范围和标注质量。
- 示例：
  - 若知识库遗漏了 Apple 与 Steve Jobs 的 co-founder 关系，则相关句子不会被标注。
  - 若知识库错误地将 Apple 与 Tim Cook 标注为 founders，则会引入系统性错误。
后果：知识库的噪声会直接传递到训练数据中，形成"错误放大效应"。

总结

远程监督方法的错误标注源于其过度简化的假设，即"实体共现等同于关系存在"。这种假设忽略了自然语言的复杂性、语义歧义性及上下文依赖性，导致模型学习到大量噪声模式。尽管该方法能快速生成数据，但需结合以下改进措施以提升性能：

置信度筛选：为生成样本分配置信度分数，过滤低置信度样本。
后处理规则：通过句法分析或规则引擎剔除明显矛盾的标注。
混合训练：结合少量高质量人工标注数据与远程监督数据，平衡噪声与信号。
关系类型细化：对知识库中的关系进行多维度定义（如时间、方式等），减少歧义性。

只有通过多维度优化，才能缓解远程监督的固有缺陷，提升关系抽取模型的鲁棒性。

多实例学习

多示例学习是指对具有某种特征的数据样本集合进行标注，这样的样本集合称为包（Bag），模型在包级别上进行训练与推断。

注意力机制

多实例学习在远程监督的关系抽取方面有了很大的改进，但模型只取置信度最高的一个句子进行训练的方法会造成大量丰富信息的丢失
实例选择注意力使用句子级别注意力去选择表达了相应关系的句子
- 相关->给学习的机会
- 不相关 -> 不学习

开放关系抽取

开放关系抽取（Open Relation Extraction，ORE）目标是在不需要预先关系定义的情况下，从非结构化文本中提取关系元组，并且不受语料库领域的限制。

时间抽取

从文本中发现特定类型事件，并抽取该事件所涉及的时间、地点、人物等元素
事件由事件触发词（Trigger）以及事件论元（Argument，也称事件元素）组成
限定域事件抽取
- 事件类型
- 事件触发词
- 事件论元
- 论元角色
将事件抽取任务分解成一系列的分类子任务的方法
- 触发词识别
- 论元识别
- 属性分配
- 事件共指
文献[368]采用流水线处理框架，其中触发词识别独立于其他任务，论元识别和属性分配任务依赖于触发词识别的结果，在这三个子任务都处理完成后，进行事件共指判断。
开放域事件提取
- 其目标是在没有任何预定义域假设的情况下，从非结构化文本中挖掘提取有意义的事件信息。
- 基于聚类的开放域事件抽取目标是从无结构文本中抽取若干主题的相关内容组成一系列事件，可以分为两个主要类型：
  - 回顾事件抽取（Retrospective Event Extraction）
  - 在线事件抽取（Online Event Extraction）

槽位填充（文本序列任务）

8. 机器翻译

9. 情感分析

9.1.1 观点模型

常规、比较
显式观点、隐式观点
理性情感、感性情感

9.1.2 情感分析主要任务

情感分类任务
- 主客观分类
- 极性分类
- 情绪分类
- 情感强度判别
情感抽取任务
- 情感信息抽取
- 观点持有者抽取
- 评价词抽取
- 评价对象抽取
- 评价搭配极性判别
- 评价搭配抽取

seq2seq

11. 文本摘要

文本摘要（Text Summarization）是一种利用算法自动实现文本分析、内容提炼并生成摘要的技术。
由于互联网的快速发展，当前时代的信息量出现了指数级的增长，并远超于人类的对信息地处理和利用能力，从而导致我们无法快速地挑选和有效地运用信息，这种现象称为信息过载（Information Overloading）。

抽取式摘要

基于排序
给予序列标注

cursor AI 编程

Mon, 17 Feb 2025 00:00:00 GMT

未来的每一个程序员都应该是一名优秀的产品经理。

默认读者会安装cursor和使用vscode、markdown。

核心功能：Chat和Composer

@功能菜单 / 拖拽使用

如何向AI提问？

让AI复述需求指令(确认AI明白我的需求)
明确需求辐射范围（在Cursor输入框内明确辐射范围）
需求拆解(把需求一条条描述用列表发送)
把AI当成一个小孩子，尽可能逻辑清晰，将自己的解决思路提供给AI，可以给一些示例参考

Cursor整体使用思路

明确需求。现在Chat模式中，先向AI描述需求，想做什么事情，让AI对你的需求有一个基础了解，然后去问AI如果想要完成自己的需求，可以选择哪些方案，并且可以让AI阐述一下各个方案的优缺点。
选择对应的方案之后，可以在Composer中重新编辑需求，在AI在你的需求和方案框架内生成代码。

合理使用Notepad

维护更新旧的项目

让cursor检索整个项目，帮你生成一个.cursorignore文件；在.cursorignore中编辑，添加你想要索引忽略掉的文件；打开设置，点击Feature，去Codebase indexing下面点击Resync Index
把项目相关的一些需求文档、接口文档、开发相关的一些技术文档，全部录入到Docs里以作备用
在项目根目录中，新建一个.cursorrules文件，并且去设置你的项目规则（Markdown格式为由）（不会写可以让AI检索Docs后自己生成一个.cursorrules文件，之后自行修改即可）
新的需求到来时，先与Chat沟通将需求理解透彻，然后创建一个Notepad，在Composer中@这个Notepad生成代码

如需了解更多内容请观看参考视频如下（墙裂推荐！） 参考视频：普通人也可以看的 AI 编程指南 | Cursor 教程 | Cursor 使用技巧和思路 | 如何免费使用 Cursor | AI 编程

docker 私人仓库搭建方案指南

Sun, 26 Jan 2025 00:00:00 GMT

Docker仓库之Registry私有镜像仓库的搭建与使用可能遇到网络问题，加入代理：【云原生Docker | 报错01】大力出奇迹，解决docker_Error response from daemon_Get "https://registry-1.docker.io/v2/"

并行下载镜像： Linux:

echo "ubuntu:20.04 alpine:latest nginx:latest redis:latest mysql:5.7 postgres:13 python:3.9 node:14 openjdk:11" | xargs -n 1 -P 4 docker pull

mac 中 command not found 解决方案 (go install 为例子)

Wed, 22 Jan 2025 00:00:00 GMT

在mac中使用go install下载工具后，使用cil使用工具会出现command not found提示。使用网上各种方案后，总结可能的通用方案。

使用命令

go env

查看go环境，找到GOPATH一栏（go install的内容会放在该目录下） 2. 为了更具体到了解到GOPATH里存的是什么，我们cd看一下可以看到bin目录下有我们下载的命令（如果下载成功） 3. 将bin目录写到我们的PATH中，我这里使用的是zsh的配置文件：

vim ~/.zshrc

然后写入

PATH=$PATH:/Users/mac/go/bin

之后重新载入.zshrc，就可以全局使用命令了

source ~/.zshrc

卷积核中的计算

Wed, 18 Dec 2024 00:00:00 GMT

补充知识 1x1卷积核的作用 1x1卷积核的作用是将输入的特征图中的每个像素点都与一个固定的权重相乘，然后将结果相加得到一个新的特征图。（线性组合）

参考资料

invalid character '-' in numeric literal错误

Tue, 26 Nov 2024 00:00:00 GMT

笔者在做软件工程大作业时遇到了这样一个问题：

invalid character '-' in numeric literal错误

经笔者检查，错误原因为：前端向后端发送的是from-data格式，后端写的逻辑是把前端发过来的信息当做JSON格式解析，所以就一直错，格式不匹配。

只需要把这个'Content-Type'从'application/form-data'改成'application/json'.

参考文献

https://blog.csdn.net/csde12/article/details/121764104

python进阶

Thu, 16 May 2024 00:00:00 GMT

9. 面向对象编程

面向对象编程（OOP）是一种编程范式，使用"对象"来组织代码。对象是类的实例，类定义了对象的属性和方法。

类和对象

类是对象的蓝图或模板，定义了对象的属性和行为。

# 定义一个类
class Dog: # 相当于Dog(object)
    # 初始化方法
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # 实例方法
    def bark(self):
        print(f"{self.name} is barking")

# 创建对象（实例）
my_dog = Dog("Buddy", 3)

# 访问对象属性
print(my_dog.name)  # 输出 "Buddy"
print(my_dog.age)   # 输出 3

# 调用对象方法
my_dog.bark()  # 输出 "Buddy is barking"

继承

继承是面向对象编程的一个重要特性，允许一个类继承另一个类的属性和方法。基类（父类）和派生类（子类）之间存在继承关系。

# 定义基类
class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print(f"{self.name} is making a sound")

# 定义派生类
class Cat(Animal):
    def __init__(self, name, color):
        super().__init__(name)
        self.color = color

    def speak(self):
        print(f"{self.name} is meowing")

# 创建派生类对象
my_cat = Cat("Whiskers", "white")

# 访问派生类对象属性和方法
print(my_cat.name)   # 输出 "Whiskers"
print(my_cat.color)  # 输出 "white"
my_cat.speak()       # 输出 "Whiskers is meowing"

多态

多态是指不同类的对象可以通过相同的接口调用方法，产生不同的行为。通常通过方法重载实现。

# 示例代码
class Bird(Animal):
    def speak(self):
        print(f"{self.name} is chirping")

# 定义一个函数，接受一个动物对象
def animal_speak(animal):
    animal.speak()

# 创建不同的动物对象
dog = Dog("Buddy", 3)
cat = Cat("Whiskers", "white")
bird = Bird("Tweety")

# 调用函数
animal_speak(dog)   # 输出 "Buddy is barking"
animal_speak(cat)   # 输出 "Whiskers is meowing"
animal_speak(bird)  # 输出 "Tweety is chirping"

封装

封装是指将对象的属性和方法私有化，保护对象的内部状态不被外部直接访问和修改。通过定义公有和私有方法和属性实现封装。

# 示例代码
class BankAccount:
    def __init__(self, owner, balance):
        self.owner = owner
        self.__balance = balance  # 私有属性

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
        else:
            print("存款金额必须大于零")

    def withdraw(self, amount):
        if amount <= self.__balance:
            self.__balance -= amount
        else:
            print("余额不足")

    def get_balance(self):
        return self.__balance

# 创建对象
account = BankAccount("Alice", 1000)

# 访问公有属性和方法
print(account.owner)  # 输出 "Alice"
account.deposit(500)
account.withdraw(200)
print(account.get_balance())  # 输出 1300

# 试图访问私有属性（会报错）
# print(account.__balance)

通过掌握面向对象编程的基本概念和技巧，你可以编写更具结构化、可扩展性和可维护性的代码。

私有属性

在面向对象编程中，让类属性能够被直接访问是危险的。使用私有属性可以保证属性不能被直接访问修改，增强安全性。私有属性用__(双下划线)前缀进行标识。

#-- coding:UTF-8 --
# 定义一个类
class Dog:
    # 初始化方法
    def __init__(self, name, age):
        self.name = name
        self.__age = age # __age为私有属性


# 创建对象（实例）
my_dog = Dog("Buddy", 3)

# 访问对象属性
print(my_dog.name)  # 输出 "Buddy"
#print(my_dog.__age)   # 无法访问

# 强制访问私有属性
print(my_dog._Dog__age)

10. 高级主题

装饰器

装饰器是一种用于修改或增强函数行为的高级技术。它本质上是一个函数，接受一个函数作为参数，并返回一个新的函数。

# 定义装饰器
def my_decorator(func):
    def wrapper():
        print("在函数执行之前")
        func()
        print("在函数执行之后")
    return wrapper

# 使用装饰器
@my_decorator
def say_hello():
    print("Hello!")

say_hello()

在这个示例中，my_decorator 装饰器在 say_hello 函数的执行前后添加了额外的打印语句。
装饰器可以接受参数，以提供更灵活的功能。

# 定义带参数的装饰器
def repeat(num_times):
    def decorator_repeat(func):
        def wrapper(*args, **kwargs):
            for _ in range(num_times):
                func(*args, **kwargs)
        return wrapper
    return decorator_repeat

@repeat(num_times=3)
def say_hello(name):
    print(f"Hello, {name}!")

say_hello("Alice")

在这个示例中，repeat 装饰器接受参数 num_times，并重复执行 say_hello 函数指定的次数。

生成器

生成器是一种特殊的迭代器，使用 yield 关键字生成值。与普通函数不同，生成器在每次生成值后暂停，并在下次调用时继续执行。

# 定义生成器
def count_up_to(max):
    count = 1
    while count <= max:
        yield count
        count += 1

# 使用生成器
counter = count_up_to(5)
for num in counter:
    print(num)

在这个示例中，count_up_to 生成器每次生成一个数值，并在达到 max 值时停止。

高阶生成器

生成器可以与其他生成器组合使用，以创建复杂的数据处理管道。

def generator1():
    yield from range(3)

def generator2():
    yield from range(3, 6)

# 组合生成器
def combined_generator():
    yield from generator1()
    yield from generator2()

for value in combined_generator():
    print(value)

Lambda函数

Lambda函数是一种简洁的匿名函数，用于定义简单的函数。常用于需要一个短期函数的场景。

# 示例代码
add = lambda x, y: x + y
print(add(3, 5))  # 输出 8

列表推导式

列表推导式是一种创建列表的简洁方法，可以在一行代码中生成列表。

# 示例代码
squares = [x**2 for x in range(10)]
print(squares)  # 输出 [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

面向对象编程的高级特性

包括类方法、静态方法和属性装饰器等。

# 示例代码
class MyClass:
    class_variable = "I am a class variable"

    def __init__(self, instance_variable):
        self.instance_variable = instance_variable

    @classmethod # 类方法
    def class_method(cls):
        return cls.class_variable

    @staticmethod # 静态方法
    def static_method():
        return "I am a static method"

    @property # 属性装饰器
    def instance_property(self):
        return self.instance_variable

obj = MyClass("I am an instance variable")
print(MyClass.class_method())      # 输出 "I am a class variable"
print(MyClass.static_method())     # 输出 "I am a static method"
print(obj.instance_property)       # 输出 "I am an instance variable"

1. 类方法（Class Method）

类方法使用 @classmethod 装饰器定义，第一个参数是类本身，通常命名为 cls。类方法可以访问类变量和修改类状态。

class MyClass:
    class_variable = "I am a class variable"

    def __init__(self, instance_variable):
        self.instance_variable = instance_variable

    @classmethod
    def class_method(cls):
        return cls.class_variable

# 使用类方法
print(MyClass.class_method())  # 输出 "I am a class variable"

在这个示例中，class_method 是一个类方法，它返回类变量 class_variable 的值。

2. 静态方法（Static Method）

静态方法使用 @staticmethod 装饰器定义，不需要传入类或实例作为参数。静态方法通常用于执行一些逻辑操作，这些操作与类和实例无关。

class MyClass:

    @staticmethod
    def static_method():
        return "I am a static method"

# 使用静态方法
print(MyClass.static_method())  # 输出 "I am a static method"

在这个示例中，static_method 是一个静态方法，它不访问类或实例的数据，仅执行独立的逻辑。

3. 属性装饰器（Property Decorator）

属性装饰器 @property 允许你将类的方法转换为只读属性，使得你可以像访问属性一样访问方法。这使得类的设计更直观和易于使用。

1. 基本用法

使用 @property 可以定义一个只读属性。

class Circle:
    def __init__(self, radius):
        self._radius = radius

    @property  # 将方法转换为属性
    def radius(self):
        return self._radius

# 创建对象并访问属性
c = Circle(5)
print(c.radius)  # 输出 5

在这个示例中，radius 方法被转换为一个只读属性，因此你可以像访问属性一样访问它，而不需要调用方法。

2. 设置器（Setter）

除了只读属性，属性装饰器还可以定义属性的设置器，允许你在设置属性值时执行一些额外的逻辑。使用 @{<property_name>.setter} 装饰器来定义设置器。

class Circle:
    def __init__(self, radius):
        self._radius = radius

    @property
    def radius(self):
        return self._radius

    @radius.setter  # 定义设置器
    def radius(self, value):
        if value < 0:
            raise ValueError("半径不能为负数")
        self._radius = value

# 创建对象并设置属性
c = Circle(5)
print(c.radius)  # 输出 5
c.radius = 10
print(c.radius)  # 输出 10
# c.radius = -1  # 会引发 ValueError: 半径不能为负数

在这个示例中，radius 属性有一个设置器，当尝试设置负值时会引发异常。

3. 删除器（Deleter）

同样地，你还可以定义属性的删除器，使用 @{<property_name>.deleter} 装饰器来定义删除器。

class Circle:
    def __init__(self, radius):
        self._radius = radius

    @property
    def radius(self):
        return self._radius

    @radius.setter
    def radius(self, value):
        if value < 0:
            raise ValueError("半径不能为负数")
        self._radius = value

    @radius.deleter  # 定义删除器
    def radius(self):
        print("删除半径属性")
        del self._radius

# 创建对象并删除属性
c = Circle(5)
print(c.radius)  # 输出 5
del c.radius
# print(c.radius)  # 会引发 AttributeError: 'Circle' object has no attribute '_radius'

在这个示例中，radius 属性有一个删除器，当属性被删除时会执行特定的逻辑。

4. 完整示例

一个包含所有三种方法的完整示例如下：

class Circle:
    def __init__(self, radius):
        self._radius = radius

    @property
    def radius(self):
        return self._radius

    @radius.setter
    def radius(self, value):
        if value < 0:
            raise ValueError("半径不能为负数")
        self._radius = value

    @radius.deleter
    def radius(self):
        print("删除半径属性")
        del self._radius

# 使用属性装饰器
c = Circle(5)
print(c.radius)  # 输出 5
c.radius = 10
print(c.radius)  # 输出 10
del c.radius

通过使用属性装饰器，你可以使类的接口更加直观和易于使用，同时能够控制属性的访问和修改。

11. 数据科学与机器学习库

1. NumPy

NumPy 是一个用于科学计算的库，支持多维数组和矩阵运算，提供了大量的数学函数。

import numpy as np

# 创建数组
array = np.array([1, 2, 3, 4, 5])
print(array)

# 数组运算
print(array + 10)
print(array * 2)

2. pandas

pandas 是一个数据分析和处理库，提供了高性能的数据结构和数据分析工具。

import pandas as pd

# 创建数据框
data = {'Name': ['Alice', 'Bob', 'Charlie'], 'Age': [25, 30, 35]}
df = pd.DataFrame(data)
print(df)

# 数据框操作
print(df['Name'])
print(df.describe())

3. matplotlib

matplotlib 是一个绘图库，用于创建静态、动态和交互式的图表。

import matplotlib.pyplot as plt

# 创建数据
x = [1, 2, 3, 4, 5]
y = [2, 3, 5, 7, 11]

# 绘制折线图
plt.plot(x, y)
plt.xlabel('x轴')
plt.ylabel('y轴')
plt.title('折线图示例')
plt.show()

4. scikit-learn

scikit-learn 是一个用于机器学习的库，提供了简单高效的数据挖掘和数据分析工具。

from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score

# 加载数据集
iris = datasets.load_iris()
X = iris.data
y = iris.target

# 划分数据集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 创建并训练模型
model = LogisticRegression()
model.fit(X_train, y_train)

# 预测并评估模型
y_pred = model.predict(X_test)
print(f"准确率: {accuracy_score(y_test, y_pred)}")

python入门（上）

Wed, 15 May 2024 00:00:00 GMT

1. python介绍

高级编程语言（解释型）

C/C++语言、Java等都是编译型语言
解释型语言没有编译器，一条一条地解释，动态语言，边解释边分配内存
Python使用缩进控制域
Python的所有数据类型都是"对象"

简介、易读、更接近自然语言

Python的数据类型

不同于C语言，Python不需要显式声明数据类型
Python的''(单引号)和""(双引号)一般认为没有区别
Python的强制类型转换格式为: int() float() str()

类

Python的类采用的思想是鸭子类型，即"如果看起来像鸭子，叫起来像鸭子，那么它就是鸭子"

2. 控制结构

条件语句

if、else、elif

# 示例代码
x = 10
if x > 5:
    print("x 大于 5")
elif x == 5:
    print("x 等于 5")
else:
    print("x 小于 5")

循环语句

for循环用于遍历序列（如列表、元组、字符串等）

# 示例代码1
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

# 示例代码1
for num in range(3):
	print(num)
# 0
# 1
# 2

while

while循环在条件为真时反复执行代码块。

# 示例代码
count = 0
while count < 5:
    print(count)
    count += 1

控制流

break

break语句用于提前退出循环。

# 示例代码
for i in range(10):
    if i == 5:
        break
    print(i)

# 1
# 2
# 3
# 4

continue

continue语句用于跳过当前迭代并继续下一次迭代。

# 示例代码
for i in range(10):
    if i % 2 == 0:
        continue
    print(i)
# 1
# 3
# 5
# 7
# 9

pass

pass语句用于占位，表示什么都不做。

# 示例代码
for i in range(10):
    pass

类似于C语言中的空语句

if (condition)
    ;

3. 函数

函数是组织代码的重要方式，它们可以让代码更加模块化和易于维护。函数可以执行特定的任务并返回结果。

定义函数

在Python中，可以使用def关键字来定义函数。函数名后跟一对圆括号和一个冒号，函数体缩进。

# 示例代码
# 无返回值 相当于C语言void函数
def greet(name):
    print(f"Hello, {name}!") # print("Hello, {}!".format(name))

# 调用函数
greet("Alice")

返回值

函数可以使用return语句返回一个值。

# 示例代码
def add(a, b):
    return a + b

# 调用函数并存储返回值
result = add(3, 5)
print(result)  # 输出 8

默认参数值

可以为函数参数指定默认值，如果调用函数时未提供该参数，则使用默认值。

# 示例代码
def greet(name="Guest"):
    print(f"Hello, {name}!")

# 调用函数
greet()          # 输出 Hello, Guest!
greet("Alice")   # 输出 Hello, Alice!

可变参数

可以使用*args和**kwargs来定义可变参数的函数，*args用于接收任意数量的位置参数，**kwargs用于接收任意数量的关键字参数。

# 示例代码
def print_args(*args):
    for arg in args:
        print(arg)

print_args(1, 2, 3)

def print_kwargs(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_kwargs(name="Alice", age=30)

嵌套函数和闭包

可以在函数内部定义函数，这种函数称为嵌套函数。闭包是指内部函数引用了外部函数的变量，并且外部函数已经返回。

# 示例代码
def outer_function(msg):
    def inner_function():
        print(msg)
    return inner_function

closure = outer_function("Hello")
closure()  # 输出 Hello

闭包是一个非常有用的编程概念，它可以在许多情况下提升代码的可读性、可维护性和灵活性。以下是闭包的几个主要用途：

1. 数据封装

闭包可以用来封装数据，提供一种实现数据隐藏和保护的方式。这类似于面向对象编程中的私有属性。

def make_counter():
    count = 0

    def counter():
        nonlocal count
        count += 1
        return count

    return counter

# 创建一个计数器实例
my_counter = make_counter()
print(my_counter())  # 输出 1
print(my_counter())  # 输出 2

在这个示例中，count变量被封装在make_counter函数中，只有内部的counter函数可以访问和修改它。

2. 回调函数

闭包常用于回调函数中，尤其是在异步编程和事件驱动编程中。

def create_callback(message):
    def callback():
        print(message)
    return callback

callback_hello = create_callback("Hello, World!")
callback_hello()  # 输出 Hello, World!

在这个示例中，callback函数作为一个回调函数，能够记住并使用create_callback函数的参数message。

3. 高阶函数

闭包可以用于创建高阶函数，即返回另一个函数的函数。这在函数式编程中非常常见。

def multiplier(factor):
    def multiply(number):
        return number * factor
    return multiply

times_two = multiplier(2)
times_three = multiplier(3)

print(times_two(5))  # 输出 10
print(times_three(5))  # 输出 15

在这个示例中，multiplier函数返回一个新的函数multiply，该函数将输入的数字乘以一个特定的因子。

4. 延迟求值

闭包可以用于延迟求值，即在需要时才计算结果，而不是在定义时就计算。这在某些性能优化中非常有用。

def make_lazy_add(a, b):
    def lazy_add():
        return a + b
    return lazy_add

lazy_add_function = make_lazy_add(2, 3)
print(lazy_add_function())  # 输出 5

在这个示例中，lazy_add函数只有在被调用时才计算a + b的值。

5. 状态持久化

闭包可以用来持久化某些状态，而不需要使用全局变量。这对于构建状态机或管理复杂的状态非常有用。

def create_accumulator():
    total = 0

    def add(value):
        nonlocal total
        total += value
        return total

    return add

accumulator = create_accumulator()
print(accumulator(10))  # 输出 10
print(accumulator(5))   # 输出 15

在这个示例中，total变量的状态在多次调用add函数之间得以持久化。

匿名函数

匿名函数是一种没有名字的函数，通常用于简单的操作。

# 示例代码
add = lambda a, b: a + b
print(add(3, 5))  # 输出 8

匿名函数在c语言中不存在，是python的特色。原因是python的函数是对象，可以赋值给变量，而匿名函数就是没有名字的函数对象。而c语言的函数是语句，不能赋值给变量。

4. 数据结构

Python 提供了多种内置的数据结构，用于存储和组织数据。我们将详细介绍以下几种常见的数据结构：列表、元组、字典和集合。

列表

列表是一种有序的可变序列，可以存储任意类型的元素。

# 创建列表
fruits = ["apple", "banana", "cherry"]

# 访问元素
print(fruits[0])  # 输出 "apple"

# 修改元素
fruits[1] = "blueberry"

# 添加元素
fruits.append("date")

# 删除元素
fruits.remove("apple")

# 遍历列表
for fruit in fruits:
    print(fruit)

元组

元组是一种有序的不可变序列，一旦创建就不能修改。

# 创建元组
coordinates = (10.0, 20.0)

# 访问元素
print(coordinates[0])  # 输出 10.0

# 遍历元组
for coordinate in coordinates:
    print(coordinate)

元组通常用于存储不需要修改的数据，例如地理坐标或数据库记录。

字典

字典是一种无序的可变映射，使用键-值对来存储数据。

# 创建字典
student = {"name": "Alice", "age": 25, "major": "Computer Science"}

# 访问值
print(student["name"])  # 输出 "Alice"

# 修改值
student["age"] = 26

# 添加键-值对
student["grade"] = "A"

# 删除键-值对
del student["major"]

# 遍历字典
for key, value in student.items():
    print(f"{key}: {value}")

集合

集合是一种无序的可变集合，不允许重复元素。

# 创建集合
numbers = {1, 2, 3, 4}

# 添加元素
numbers.add(5)

# 删除元素
numbers.remove(3)

# 集合运算
odds = {1, 3, 5, 7}
evens = {2, 4, 6, 8}
union = odds | evens      # 并集
intersection = odds & evens  # 交集

# 遍历集合
for number in numbers:
    print(number)

集合的声明类似C语言数组的声明，请不要混淆

Python中数组的声明需要import array包，使用较少，通常在数值运算中使用类似的np.array

c语言中没有集合的概念，c++中使用set和unordered_set来表示集合，c++11中引入了unordered_map和unordered_set，可以用来表示集合。c++中的集合运算。

python入门（下）

Wed, 15 May 2024 00:00:00 GMT

5. 异常处理

在编写代码时，可能会遇到各种错误和异常。为了确保程序能够优雅地处理这些错误，Python 提供了异常处理机制。我们将详细介绍如何使用 try、except、else 和 finally 块来处理异常。

基本的异常处理

使用 try 和 except 块可以捕获和处理异常。

# 示例代码
try:
    x = int(input("请输入一个数字: "))
    y = 10 / x
    print(f"10 除以 {x} 的结果是 {y}")
except ZeroDivisionError:
    print("除零错误！不能用零作为除数。")
except ValueError:
    print("输入错误！请输入一个有效的数字。")

在这个示例中，try 块包含可能引发异常的代码。如果发生 ZeroDivisionError 或 ValueError，相应的 except 块将捕获并处理异常。

`else` 和 `finally` 块

else 块在没有发生异常时执行，finally 块无论是否发生异常都会执行。

# 示例代码
try:
    x = int(input("请输入一个数字: "))
    y = 10 / x
except ZeroDivisionError:
    print("除零错误！不能用零作为除数。")
except ValueError:
    print("输入错误！请输入一个有效的数字。")
else:
    print(f"10 除以 {x} 的结果是 {y}")
finally:
    print("执行结束。")

在这个示例中，如果没有发生异常，else 块中的代码将执行。不论是否发生异常，finally 块中的代码都会执行。

自定义异常

可以定义自己的异常类，以便更好地描述特定错误。

# 自定义异常类
class NegativeNumberError(Exception):
    pass

def check_positive(number):
    if number < 0:
        raise NegativeNumberError("数字不能为负数！")

# 使用自定义异常
try:
    num = int(input("请输入一个正数: "))
    check_positive(num)
except NegativeNumberError as e:
    print(e)

在这个示例中，定义了一个自定义异常 NegativeNumberError，并在 check_positive 函数中使用。

捕获所有异常

可以使用通用的 except 块来捕获所有异常。

# 示例代码
try:
    x = int(input("请输入一个数字: "))
    y = 10 / x
except Exception as e:
    print(f"发生异常: {e}")

在这个示例中，except Exception 捕获所有类型的异常，并输出异常信息。

通过异常处理机制，我们可以确保程序在遇到错误时能够优雅地处理，而不会导致崩溃。掌握异常处理是编写健壮和可靠代码的重要技能。

抛出异常

assert

assert语句用于断言，如果断言失败，程序会抛出AssertionError异常。

# 示例代码
def divide_numbers(a, b):
    assert b != 0, "除数不能为零"
    return a / b

# 使用示例
try:
    result = divide_numbers(10, 0)
except AssertionError as e:
    print(f"断言错误：{e}")

raise

使用raise语句可以主动抛出异常

# 基本用法
def check_age(age):
    if age < 0:
        raise ValueError("年龄不能为负数")
    if age > 150:
        raise ValueError("年龄不能超过150岁")
    return True

# 重新抛出异常
def process_age():
    try:
        age = int(input("请输入年龄："))
        check_age(age)
    except ValueError as e:
        print("处理异常...")
        raise  # 重新抛出当前异常

异常链

使用raise from可以在抛出新异常时保留原始异常信息

def convert_to_int(text):
    try:
        return int(text)
    except ValueError as e:
        raise ValueError("输入必须是数字") from e

# 使用示例
try:
    number = convert_to_int("abc")
except ValueError as e:
    print(f"错误：{e}")
    print(f"原始错误：{e.__cause__}")

这些抛出异常的方法让我们能够：

使用assert进行调试和验证
使用raise主动抛出异常
通过异常链追踪异常的来源和传播过程

6. 模块和包

在编写较大程序时，将代码组织成模块和包有助于提高代码的可维护性和重用性。Python 提供了强大的模块和包机制。我们将详细介绍以下内容：

模块

模块是一个包含 Python 代码的文件，可以包含变量、函数和类。通过 import 语句可以在其他代码中使用模块。

创建和使用模块：

假设有一个名为 mymodule.py 的文件，内容如下：

# mymodule.py
def greet(name):
    return f"Hello, {name}!"

可以在另一个 Python 文件中导入并使用这个模块：

# main.py
import mymodule

print(mymodule.greet("Alice"))  # 输出 "Hello, Alice!"

也可以使用 from ... import ... 语句导入模块中的特定部分：

# main.py
from mymodule import greet

print(greet("Bob"))  # 输出 "Hello, Bob!"

注意 (不推荐)我们也可以使用from whichmodule import来导入模块中的所有内容，但是这样导入存在风险。倘若该模块中定义的对象与其他模块或python标准包存在冲突，可能导致不可预估的错误！

包

包是一个包含多个模块的目录，其中包含一个特殊的 __init__.py 文件，该文件可以是空的，也可以包含包的初始化代码。

创建和使用包：

假设有一个名为 mypackage 的目录，结构如下：

mypackage/
    __init__.py
    module1.py
    module2.py

module1.py 的内容如下：

# module1.py
def add(a, b):
    return a + b

module2.py 的内容如下：

# module2.py
def subtract(a, b):
    return a - b

可以在另一个 Python 文件中导入并使用这个包：

# main.py
from mypackage import module1, module2

print(module1.add(5, 3))        # 输出 8
print(module2.subtract(5, 3))   # 输出 2

使用标准库

Python 附带了一个丰富的标准库，提供了大量有用的模块，可以直接导入和使用。例如，使用 math 模块进行数学运算：

import math

print(math.sqrt(16))  # 输出 4.0

安装第三方包

可以使用 pip 安装第三方包。例如，安装和使用 requests 包来发送 HTTP 请求：

pip install requests

安装后，可以在代码中导入并使用 requests 包：

import requests

response = requests.get("https://api.github.com")
print(response.status_code)  # 输出 200

模块和包使得代码更加模块化和可重用，有助于组织和管理大型项目。

wheel

尽管我们可以通过pip安装第三方包，但有些包并不在pypi上，这时候就需要使用wheel文件来安装。

wheel文件是python的二进制包格式，通常用于分发和安装Python包。与源代码包不同，wheel包已经编译为二进制形式，可以直接在目标系统上安装，而无需编译源代码。

wheel文件通常以.whl为扩展名，例如requests-2.28.2-py3-none-any.whl。

使用wheel安装第三方包的方法如下:

从镜像平台其他途径获取wheel包
使用pip在自己环境中安装wheel包

pip install requests-2.28.2-py3-none-any.whl

镜像

由于某些神秘力量，国内访问pypi的速度很慢，这时候就需要使用镜像来加速下载。常用的镜像源有：

清华：https://pypi.tuna.tsinghua.edu.cn/simple
阿里云：http://mirrors.aliyun.com/pypi/simple/
ustc: https://pypi.mirrors.ustc.edu.cn/simple/
hust：http://pypi.hustunique.com/
sdut：http://pypi.sdutlinux.org/
豆瓣：http://pypi.douban.com/simple/

如何配置镜像源？

1. 永久配置镜像源

pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple/
pip config set install.trusted-host pypi.tuna.tsinghua.edu.cn

2. 临时使用镜像源

使用-i

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

参考资料

7. 字符串处理

字符串是Python中最常用的数据类型之一。理解和掌握字符串处理方法是编写高效Python代码的基础。

1. 字符串创建与基本操作

字符串可以使用单引号、双引号或三引号创建。

# 创建字符串
str1 = 'Hello'
str2 = "World"
str3 = '''This is
a multiline
string'''

print(str1)  # 输出 Hello
print(str2)  # 输出 World
print(str3)  # 输出 This is\n a multiline\n string

2. 字符串拼接

可以使用加号（+）拼接字符串，使用乘号（*）重复字符串。

# 字符串拼接
greeting = str1 + ' ' + str2
print(greeting)  # 输出 Hello World

# 字符串重复
repeat_str = str1 * 3
print(repeat_str)  # 输出 HelloHelloHello

注意使用*重复数据的操作在其他数据类型同样可以使用。但是请注意，* 在Python中的逻辑是引用复制，即重复使用同一对象。这可能会导致用户在数值计算等可能出现引用类型套引用类型的情况下出现容易忽视的灾难性错误：

>>> array = []
>>> array.append([[1,1,1,1]]*2)
>>> print(array)
[[[1, 1, 1, 1], [1, 1, 1, 1]]]
>>> array[0][0][0]
1
>>> array[0][0][0] *= 2 # 使用 array[0][0][0] = array[0][0][0] * 2 结果相同
>>> array
[[[2, 1, 1, 1], [2, 1, 1, 1]]]

明明只修改了array[0][0][0], 但array[0][1][0]的值也被修改了！这提醒我们在使用*时，应当注意不要对存在引用共享的数据进行操作。

3. 字符串格式化

Python提供了多种字符串格式化方法，包括百分号格式化、str.format()方法和f字符串（格式化字符串字面量）。

name = "Alice"
age = 25

# 百分号格式化
print("Hello, %s. You are %d years old." % (name, age))

# str.format()方法
print("Hello, {}. You are {} years old.".format(name, age))

# f字符串（Python 3.6及以上）
print(f"Hello, {name}. You are {age} years old.")

Python中，字符串格式化不仅可以将变量嵌入字符串中，还可以通过在格式化占位符中指定格式来控制显示效果。对于str.format()方法和f字符串f"..."，你可以指定显示的精度、对齐方式、填充字符、宽度等。下面是一个简单的表格，用于展示不同字符串格式化方法的对比和一些常见用法：

| 格式化方法 | 语法 | 说明 | 示例 | |----------------------|------------------------------------------------------|-----------------------------------------------------|------------------------------------------------------------------------| | 百分号格式化 | "Hello, %s. You are %d years old." % (name, age) | 使用 % 占位符格式化，类似 C 语言中的 printf | print("Hello, %s. You are %d years old." % ("Alice", 25)) | | str.format() | "Hello, {}. You are {} years old.".format(name, age) | 使用 {} 占位符并通过 format() 方法传递参数 | print("Hello, {}. You are {} years old.".format("Alice", 25)) | | f字符串（Python 3.6+） | f"Hello, {name}. You are {age} years old." | 在字符串前加 f，直接在 {} 中插入变量或表达式 | print(f"Hello, {name}. You are {age} years old.") | | 对齐与宽度控制 | "{:<10}".format(name), "{:>10}".format(name) | 设置最小宽度并指定对齐方式（< 左对齐，> 右对齐） | print("{:<10} is {} years old.".format("Alice", 25)) | | 填充字符 | "{:*^10}".format("hello") | 使用填充字符进行对齐（例如 * 填充） | print("{:*^10}".format("hello")) | | 浮动点精度控制 | "{:.2f}".format(pi) | 设置小数位数精度 | print("{:.2f}".format(3.141592653589793)) | | 科学计数法 | "{:.2e}".format(pi) | 使用科学计数法表示数字 | print("{:.2e}".format(3.141592653589793)) | | 列表和字典格式化 | "{name}, {age}".format(name="Alice", age=25) | 可以通过命名字段来传递字典中的值 | print("{name} is {age} years old.".format(name="Alice", age=25)) | | 表达式计算 | f"2 + 2 = {2 + 2}" | f字符串支持嵌入表达式并计算 | print(f"2 + 2 = {2 + 2}") |

4. 字符串索引&切片

可以使用索引访问字符串中的单个字符，使用切片获取子字符串。

# 字符串索引
s = "Python"
print(s[0])  # 输出 P
print(s[-1])  # 输出 n

# 字符串切片
print(s[1:4])  # 输出 yth
print(s[:3])  # 输出 Pyt
print(s[3:])  # 输出 hon

5. 常用字符串方法

Python提供了许多内置的字符串方法，用于各种字符串操作。

s = "hello, world"

# 大小写转换
print(s.upper())  # 输出 HELLO, WORLD
print(s.lower())  # 输出 hello, world
print(s.capitalize())  # 输出 Hello, world
print(s.title())  # 输出 Hello, World

# 去除空白字符
s2 = "  hello  "
print(s2.strip())  # 输出 hello
print(s2.lstrip())  # 输出 hello
print(s2.rstrip())  # 输出   hello

# 查找和替换
print(s.find("world"))  # 输出 7
print(s.replace("world", "Python"))  # 输出 hello, Python

# 拆分和连接
words = s.split(", ")
print(words)  # 输出 ['hello', 'world']
print(", ".join(words))  # 输出 hello, world

6. 字符串的不可变性

字符串在Python中是不可变的，一旦创建，就不能修改其内容。任何对字符串的操作都会创建一个新字符串。

s = "hello"
# s[0] = 'y' 错误！
s = s.replace("h", "y")
print(s)  # 输出 yello

7. 字符串的编码和解码

可以使用encode()方法将字符串编码为字节，使用decode()方法将字节解码为字符串。

# 编码
s = "hello"
b = s.encode("utf-8")
print(b)  # 输出 b'hello'

# 解码
s2 = b.decode("utf-8")
print(s2)  # 输出 hello

8. 多行字符串和转义字符

多行字符串可以使用三引号创建，转义字符用于表示特殊字符。

# 多行字符串
multi_line_str = """This is a
multiline
string"""
print(multi_line_str)

# 转义字符
escaped_str = "He said, \"Hello!\""
print(escaped_str)  # 输出 He said, "Hello!"

8. 文件处理

在实际编程中，经常需要读取和写入文件。Python 提供了强大的文件处理功能，允许我们轻松地操作文件。

打开和关闭文件

可以使用 open 函数打开文件，使用 close 方法关闭文件。

# 打开文件
file = open("example.txt", "r")

# 读取文件内容
content = file.read()
print(content)

# 关闭文件
file.close()

使用 `with` 语句

with 语句可以自动处理文件的打开和关闭，确保文件在使用完后正确关闭。

# 使用 with 语句打开文件
with open("example.txt", "r") as file:
    content = file.read()
    print(content)

读取文件

可以使用 read、readline 和 readlines 方法读取文件内容。

# 读取整个文件
with open("example.txt", "r") as file:
    content = file.read()
    print(content)

# 逐行读取文件
with open("example.txt", "r") as file:
    for line in file:
        print(line.strip())

# 读取一行
with open("example.txt", "r") as file:
    line = file.readline()
    print(line)

# 读取所有行并返回列表
with open("example.txt", "r") as file:
    lines = file.readlines()
    print(lines)

写入文件

可以使用 write 和 writelines 方法写入文件内容。

# 写入文件
with open("example.txt", "w") as file:
    file.write("Hello, World!\n")
    file.write("This is a new line.\n")

# 写入多行
lines = ["First line.\n", "Second line.\n", "Third line.\n"]
with open("example.txt", "w") as file:
    file.writelines(lines)

文件模式

可以使用不同的模式打开文件：

'r'：读取（默认模式）
'w'：写入（会覆盖文件）
'a'：追加（在文件末尾添加内容）
'b'：二进制模式（用于非文本文件）

# 以追加模式打开文件
with open("example.txt", "a") as file:
    file.write("This line is appended.\n")

# 以二进制模式读取文件
with open("example.jpg", "rb") as file:
    content = file.read()
    print(content)

文件和目录操作

使用 os 模块可以进行文件和目录操作。

import os

# 检查文件是否存在
print(os.path.exists("example.txt"))

# 获取文件大小
print(os.path.getsize("example.txt"))

# 重命名文件
os.rename("example.txt", "new_example.txt")

# 删除文件
os.remove("new_example.txt")

# 创建目录
os.mkdir("example_dir")

# 删除目录
os.rmdir("example_dir")

第一篇Github Blog

Thu, 21 Mar 2024 00:00:00 GMT

放在开始的话

2024年3月21日，这是我创建Github Blog的辉煌时刻。希望我能够在这个Blog网站中创造有价值的文章，帮助其他同学学到更多有用的知识。

为什么我们选择最小平方损失？

Thu, 21 Mar 2024 00:00:00 GMT

"Why least square?" --吴恩达

对于训练集$X$，标签集$Y$,"error set"$E$, $x\in X, y\in Y, \epsilon \in E$:

我们假定(Assume):

$$ y^{(i)}=\theta^Tx^{(i)}+\epsilon^{(i)} $$

* $\epsilon$: Unmeasured effects/random noise/etc.

在我们朴素的认知中，所有其他因素和噪音的合成是遵循高斯分布的：

$$ \epsilon^{(i)}\sim \mathcal N(0,\sigma^2) $$

那么：

$$ P(\epsilon^{(i)})=\frac{1}{\sqrt{2\pi}\sigma}\exp\Big( -\frac{(\epsilon^{(i)})^2}{2\sigma^2} \Big) $$

同时，我们朴素地认为训练集个各个特征之间遵循独立同分布(I.I.D.)

尽管I.I.D"not a true assumption", 但是在机器学习中"无伤大雅"（是很普遍且很有用的假设）

$$ P(y^{(i)}\mid x^{(i)};\theta) = \frac{1}{\sqrt{2\pi}\sigma}\exp\Big( -\frac{(y^{(i)}-\theta^Tx^{(i)})^2}{2\sigma^2} \Big) $$

根据Assume移项得到的。

$P(y^{(i)}\mid x^{(i)};\theta)$：the prob of $y^{(i)}$ given $x^{(i)}$.$\theta$是参数而不是随机变量。

我们可以得到：

$$ (y^{(i)}|x^{(i)};\theta)\sim \mathcal N(\theta^Tx^{(i)},\sigma^2) $$

$$ \mathcal{L}(\theta) = \qquad P(\vec{y}|x;\theta) \qquad * \ \ \qquad=\prod^{m}{i=1} P(y^{(i)}|x^{(i)}; \theta) \ ** \ \ \ \qquad\qquad \qquad\qquad=\prod^{m}{i=1}\frac{1}{\sqrt{2\pi}\sigma}\exp\Big( -\frac{(y^{(i)}-\theta^Tx^{(i)})^2}{2\sigma^2} \Big) $$

$"\mathcal L":$ likelyhood

$*\rightarrow **:$ $I.I.D$

$$ \begin{array}{ll} \mathcal l(\theta) &= \log \mathcal L(\theta)\ \ &=\log\prod\limits^{m}{i=1}\dfrac{1}{\sqrt{2\pi}\sigma}\exp\Big( -\dfrac{(y^{(i)}-\theta^Tx^{(i)})^2}{2\sigma^2} \Big)\ \ &=\sum\limits^{m}{i=1}\Big[\log\dfrac{1}{\sqrt{2\pi}\sigma}+\log \exp\Big( -\dfrac{(y^{(i)}-\theta^Tx^{(i)})^2}{2\sigma^2} \Big)\Big]\ \ &=m\log\dfrac{1}{\sqrt{2\pi}\sigma}+\sum\limits^{m}_{i=1}-\dfrac{(y^{(i)}-\theta^Tx^{(i)})^2}{2\sigma^2} \end{array} $$

我们可以发现最后的结果成为了常数+$f(y^{(i)}-\theta^Tx^{(i)})$

因为我们要MLE(Maximize likelyhood estimation),即：

$$ choose\ \theta \ to\quad \text {maximize} \quad\mathcal L(\theta) $$

所以我们的目标变成了：

$$ choose\ \theta \ to\quad \text {minimize} \quad\sum\limits^{m}_{i=1}\dfrac{(y^{(i)}-\theta^Tx^{(i)})^2}{2\sigma^2} $$

也就是：

$$ choose\ \theta \ to\quad \text {minimize} \quad\dfrac{1}{2}\sum\limits^{m}_{i=1}{(y^{(i)}-\theta^Tx^{(i)})^2}=\mathcal J(\theta) $$

$\mathcal J(\theta):$即损失函数，这里为我们常用的平方损失函数

我们可以发现这就是我们在回归问题中常用的$\mathcal J(\theta)$.

在这一刻，概率与直觉达到了统一。

KIOSHIROI's CS-learning Road

笔记-CSAPP 第12章 并发编程

笔记-DDIA

笔记-CSAPP 第6章 存储器层次结构

笔记-CSAPP 第8章 异常控制流

笔记-CUDA入门

笔记-Lecture 05: Deployment

笔记-Lecture 04: Data Management

笔记-Lecture 03: Troubleshooting & Testing

笔记-Lecture 02: Development Infrastructure & Tooling

笔记-Lecture 01: When to Use ML and Course Vision

MXFP——为量化而生的浮点数们

智能边缘系统搭建常用教程链接（自用）

近期状态与计划

k8s 重置 kagent 默认 OPENAI_API_KEY secret

1. 修改 Secret 中的 API 密钥

步骤 1：编辑 Secret

步骤 2：修改 OPENAI_API_KEY 的值

步骤 3：保存并退出

2. 验证 Secret 更新

3. 触发 Operator 重新同步

4. 验证 ModelConfig 状态

常见问题

替代方案：直接更新 ModelConfig 的 Secret 引用

笔记：计算机视觉

1

图像显示打印

视觉过程

空间分辨率和幅度分辨率

2

2.7 直方图变换

2.7.1 直方图均衡化

4 空域增强技术

线性平滑滤波器

非线性平滑滤波器

非线性锐化滤波器

边缘提取

5 频域增强原理

傅里叶级数

三角形式

指数形式（通过欧拉公式推导）

傅里叶变换

连续傅里叶变换

离散傅里叶变换（DFT）

卷积定理

抽样定理

关键性质

频域滤波步骤

典型应用

频域表示

应用特性

离散傅里叶变换（DFT）

关键性质

频域滤波步骤

典型应用

频域增强

频域滤波器设计

低通滤波器

振铃效应

高通滤波器

带通/带阻滤波器

同态滤波

频域去噪

频域与空域滤波对比

实际应用案例

5 图像恢复

图像退化

常见噪声

消除匀速直线运动模糊

6

6.1.2 三基色与色匹配

6.1.3 色度图

6.2 彩色模型

6.2.1 面向硬设备的彩色模型

6.2.2 面向视觉感知的彩色模型

伪彩色增强

7 图像分割

7.1 基于边缘的分割方法

7.1.1 检测原理

7.1.3 二阶导数算子

笔记-CSAPP 第12章并发编程

笔记-CSAPP 第6章存储器层次结构

笔记-CSAPP 第8章异常控制流

步骤 2：修改 `OPENAI_API_KEY` 的值