做题技巧

逻辑公式解答题，代入特殊值求解,

机器学习算法原理

格式化算法模板

#标准化输入 把前后没有空格的输入到一个列表里史称 lines

lines = [line.strip() for line in sys.stdin if line.strip()]

#分配输入到变量 split
n, m, p,k = lines[ptr].split(' ')

kmeans 聚类推理

KMeans 聚类核心规则
每次加样本迭代：样本划分到欧式距离最近的簇中心，再更新簇中心。
标签在前K个近邻中的出现次数

你需要为一个简单的多分类识别器补上“K 近邻”判别模块。做法是：先度量待测样本与训练样本的距离，挑选出距离最近的 K 个样本，再用多数票决定最终类别。
操作要点（按流程执行）：
先计算待测点到每个样本点的距离（为了效率，可直接用“平方欧氏距离”参与排序，结果等价）。
将样本按距离升序排列，截取前 K 个作为近邻。
统计这 K 个近邻的标签出现次数，频数最高的标签即为预测值。
如出现“最高频数并列”，只在并列标签对应的近邻里，按由近到远的顺序挑第一个的标签。
约束与假设：
数据集已做归一化处理（不同维度量纲一致），特征保留两位小数。
每个类别在数据集中都至少有一个样本。
距离采用欧氏距离：
​

时间限制：C/C++ 1秒，其他语言2秒
空间限制：C/C++ 256M，其他语言512M
输入描述：
第 1 行：k m n s
k 为最近邻个数（≤20），m 为样本数（≤200），n 为特征维度（不含标签，≤5），s 为类别个数（≤5）。
第 2 行：待分类样本的 n 维特征。
第 3 行至第 m+2 行：每行 n+1 列，前 n 列为特征，最后 1 列为类别标签（整数，以浮点给出）。
输出描述：
输出两项：预测标签 与 该标签在前 K 个近邻中的出现次数
格式：label count

from collections import defaultdict
 
 
# 样本用list存储，多样本特征
#=====读取data========
# 读取kmns
k, m, n, s = map(int,input().split())
# 读取待测样本值的N维特征，用list
query = list(map(float,input().split()))
#读取已知样本值[特征＋标签]
samples = [] #这应该也是列表
for _ in range(m): #总共有m个样本，所以有这些个循环
    #读取一行 都用map
    parts = list(map(float, input().split()))
    #截取标签维度
    feat = parts[:n]
    lable = int(parts[-1])
    samples.append((feat,lable))
#======compute distance=======先计算待测点到每个样本点的距离 
dist_list = []
for feat,lable in samples:
    dist_sq = 0.0
    for qv,sv in zip(query,feat):
        dist_sq += (qv-sv)**2
    dist_list.append((dist_sq,lable))
#====sort&Statistics======= 将样本按距离升序排列，截取前 K 个作为近邻。
dist_list.sort()
top_k = dist_list[:k]

cnt = defaultdict(int)
for dist, lable in top_k:
    cnt [lable] +=1
#=====items cnt========== 由于已经是排序后计数，所以并列情况下，找到最先出现的标签，即距离更近的那个标签
relable=0
renumber = 0
for lable , number in cnt.items():
    if number >renumber :
        relable = lable
        renumber = number
# print 输出，多元素自动加‘ ’，空格
print ( relable ,renumber)
 

决策树 基本概念

一、基本概念
树形模型，由根节点、内部节点、叶子节点、分支组成
内部节点：按特征阈值划分样本，对应判断条件
叶子节点：输出最终分类 / 回归结果
分支：判断后的走向# 决策树 核心基础知识

分裂依据
选择最优特征与阈值划分样本，常用评判指标

• 信息熵：衡量样本混乱程度，熵越小纯度越高
  $$H=-\sum _{i=1}^n{p}_i{\log }_2{p}_i$$

• 信息增益：分裂后熵减少量，增益越大划分效果越好

• 基尼系数：数值越小样本纯度越高

  生长过程
  递归选取最优特征分裂，不断划分子集，直到满足停止条件：

• 节点样本同属一类

• 无可用划分特征

• 达到设定最大深度、最小样本数等限制

决策树剪枝

 import sys
 

#构建树节点
class Node:
    def __init__(self,l,r,f,th,lable):
        self.l = l #存储的节点序号，不是对象，真正的对象在主函数的tree列表里
        self.r = r
        self.f = f
        self.th = th
        self.lable = lable
        self.isleaf = (l==0 and r==0)
        
#推理预测函数
def predict(feat,nodeid):
    node = tree[nodeid]
    if nodeid in prune_set or node.isleaf:
        return node.lable
    if feat[node.f-1] <= node.th:
        return predict(feat, node.l)
    else:
        return predict(feat ,node.r)

        
def cal_f1(pred):
    tp = fp = fn = 0
    for t,p in zip(pred,val_lable):
        if t==1 and p==1:
            tp+=1
        if t==1 and p==0:
            fp+=1
        if t==0 and p==1:
            fn+=1
    res = 2*tp/(2*tp +  fp + fn)

    return res
    

#剪枝最大深度搜索算法
def dfs(u):
    global max_f1#使用全局变量
    node = tree[u] #取当前节点
    #如果剪枝
    prune_set.add(u)
    #推理验证结果，首先预测标签
    pred = [predict(x,1)for x in val_feat]
    F1 = cal_f1(pred)
    if F1 >  max_f1:
        #print("剪枝",u,"更新F1",max_f1,"  - ",F1)
        max_f1 =F1
    prune_set.remove(u)
    if not node.isleaf:
        dfs(node.l)
        dfs(node.r)

    




# 100+100 80+140 +120 = 540 两把
if __name__ == "__main__":
    sys.setrecursionlimit(10000)
    #read data
    N, M, K = map(int,sys.stdin.readline().split())
    tree = []  # 不要写 [None]！直接空列表就不会报类型错误
    tree.append(None)  # 第 0 位占位（1基编号）
    for _ in range(N):
        l,r,f,th,lable = map(int,sys.stdin.readline().split())
        tree.append(Node(l, r, f, th, lable))
    #read validationset
    val_feat = []
    val_lable = []
    for _ in range (M):
        line = list(map(int, sys.stdin.readline().split()))
        val_feat.append(line[:-1])
        val_lable.append(line[-1])
    #dfs to find the prune node
    max_f1 = 0.0
    prune_set = set()
    dfs(1)
    print("{0:.6}".format(round(max_f1,6)))

逻辑回归 设备故障预测程序

 
import sys
import math

# ------------------------------
# 工具函数1：把字符串转成数字，是NaN就返回None
# ------------------------------
def parse_num(s):
    s = s.strip().lower()
    if s == "nan":
        return None  # 代表缺失
    return float(s)

# ------------------------------
# 工具函数2：sigmoid函数（逻辑回归必须用）
# ------------------------------
def sigmoid(z):
    if z > 20:
        return 1.0
    if z < -20:
        return 0.0
    return 1.0 / (1.0 + math.exp(-z))

# ------------------------------
# 5个特征的名字（固定顺序）
# ------------------------------
features = ["writes", "reads", "avg_write_ms", "avg_read_ms", "years"]

# ------------------------------
# 读取所有输入（一次性读完，避免索引越界）
# ------------------------------
lines = [line.strip() for line in sys.stdin if line.strip()]
ptr = 0

# ------------------------------
# 【第一步】读取训练集 N
# ------------------------------
N = int(lines[ptr])
ptr += 1

train_data = []  # 存清洗前的合法训练数据

for _ in range(N):
    parts = lines[ptr].split(",")
    ptr += 1

    # 必须有7个字段：设备ID,5个特征,状态
    if len(parts) < 7:
        continue

    # 取出5个特征 + 标签
    f_values = parts[1:6]
    state_str = parts[6]

    # 标签必须是0或1，否则丢弃这一行
    try:
        label = int(state_str)
        if label not in (0, 1):
            continue
    except:
        continue

    # 保留合法样本
    train_data.append((f_values, label))

# ------------------------------
# 【第二步】统计每一列的 有效数值 → 算均值、中位数
# ------------------------------
# 先收集每一列的有效数字（不是NaN + 不越界）
valid_values = {f: [] for f in features}

for f_values, label in train_data:
    for i in range(5):
        val = parse_num(f_values[i])
        if val is None:
            continue

        # 判断是否越界（异常）
        if i in [0, 1]:  # 写次数、读次数：必须 >=0
            ok = (val >= 0)
        elif i in [2, 3]:  # 写延迟、读延迟：0~1000
            ok = (0 <= val <= 1000)
        else:  # 使用年限：0~20
            ok = (0 <= val <= 20)

        if ok:
            valid_values[features[i]].append(val)

# 计算每列：均值(填NaN)、中位数(填异常)
stat = {}
for f in features:
    vs = sorted(valid_values[f])
    n = len(vs)

    if n == 0:
        mean_val = 0.0
        median_val = 0.0
    else:
        mean_val = sum(vs) / n
        mid = n // 2
        if n % 2 == 1:
            median_val = vs[mid]
        else:
            median_val = (vs[mid-1] + vs[mid]) / 2

    stat[f] = (mean_val, median_val)

# ------------------------------
# 【第三步】清洗函数（NaN→均值，异常→中位数，正常保留）
# ------------------------------
def clean_row(f_values):
    clean = []
    for i in range(5):
        s = f_values[i]
        val = parse_num(s)
        mean_val, median_val = stat[features[i]]

        # 1. 缺失值 → 均值
        if val is None:
            clean.append(mean_val)
            continue

        # 2. 判断是否异常
        if i in [0, 1]:
            ok = (val >= 0)
        elif i in [2, 3]:
            ok = (0 <= val <= 1000)
        else:
            ok = (0 <= val <= 20)

        # 3. 异常 → 中位数
        if not ok:
            clean.append(median_val)
        else:
            clean.append(val)
    return clean

# 清洗所有训练数据
train_clean = []
for f_values, label in train_data:
    cleaned = clean_row(f_values)
    train_clean.append((cleaned, label))

# ------------------------------
# 【第四步】训练逻辑回归（批量梯度下降）
# ------------------------------
weights = [0.0] * 6  # w0 + 5个特征权重，全部初始化为0
lr = 0.01            # 学习率
epochs = 100         # 迭代100次
m = len(train_clean)

for _ in range(epochs):
    dw = [0.0] * 6  # 梯度清零

    for x, y in train_clean:
        # 计算 z = w0 + w1x1 + w2x2 + ... +w5x5
        z = weights[0]
        for j in range(5):
            z += weights[j+1] * x[j]

        # 预测值 - 真实值
        err = sigmoid(z) - y

        # 累加梯度
        dw[0] += err
        for j in range(5):
            dw[j+1] += err * x[j]

    # 更新权重
    for j in range(6):
        weights[j] -= lr * dw[j] / m

# ------------------------------
# 【第五步】读取预测集并输出结果
# ------------------------------
M = int(lines[ptr])
ptr += 1

for _ in range(M):
    parts = lines[ptr].split(",")
    ptr += 1

    # 取出5个特征并清洗
    f_values = parts[1:6]
    x = clean_row(f_values)

    # 计算预测概率
    z = weights[0]
    for j in range(5):
        z += weights[j+1] * x[j]
    prob = sigmoid(z)

    # 输出 0 或 1
    print(1 if prob >= 0.5 else 0)

22.MOE Top‑k 路由

在一个稀疏 MOE 模型中，有 n 个专家顺序编号为 0…n-1，这些专家被平均分布到 m 张 NPU 卡上，每张卡上一组，且同组专家编号连续。为降低跨卡通信，现将路由目标限制在最多 p 张 NPU 上：

1. 先对每组求组内概率最大值及其专家编号，作为该组的代表值；
2. 把所有组按“代表概率”从高到低排序，若概率相同则组号小的在前，取前 p 个组；
3. 仅在上述 p 个组包含的所有专家里，按“概率降序、编号升序”挑选前 k 位的专家编号作为最终路由目标。

约束与异常

• 若 n 不能被 m 整除，则无法平均分组，输出 error。
• 若 p>m，输出 error。
• 设每组大小 g=n/m，若可选专家总数 p·g<k，无法选够 k 人，输出 error。
  时间限制：C/C++ 1秒，其他语言2秒
  空间限制：C/C++ 256M，其他语言512M
  输入描述：
  第一行：四个整数 n m p k（1≤n,m,p,k≤10000）
  第二行：n 个浮点数，依次为专家 0…n-1 的概率，均在 (0,1) 内
  输出描述：
  若发生异常，输出 error
  否则输出 k 个专家编号，升序，空格分隔（行尾无空格）
  补充说明：
  本题由牛友@Charles 整理上传
  示例1
  输入例子：
  6 3 2 2
  0.3 0.1 0.05 0.6 0.4 0.2
  输出例子：
  3 4
  例子说明：
  分组：g=6/3=2。组0=[0,1]→代表(0.3,idx0)，组1=[2,3]→代表(0.6,idx3)，组2=[4,5]→代表(0.4,idx4)。
  选组：按代表概率降序取前 p=2 个，得到组1与组2。
  选专家：在{2,3,4,5}中按概率降序取前 k=2，依次为 idx3(0.6)、idx4(0.4)；最后升序输出 3 4。

import sys
 

# 读取输入
lines = [line.strip() for line in sys.stdin if line.strip()]
ptr = 0
n, m, p, k = map(int, lines[ptr].split())
ptr += 1
probs = list(map(float, lines[ptr].split()))

# 异常判断
g = n // m
if n % m != 0 or p > m or p * g < k:
    print("error")
    exit()

# 分组（每组 g 个专家，不是固定 2 个！）
groups = []
for group_id in range(m):
    start = group_id * g
    members = list(range(start, start + g))
    max_p = max(probs[i] for i in members)
    groups.append((-max_p, group_id, members))  # 负号=降序，加组号保证正确排序

# 选前 p 组
groups.sort()
candidates = []
for i in range(p):
    candidates.extend(groups[i][2])

# 按概率降序、编号升序排序
candidates.sort(key=lambda x: (-probs[x], x))

# 取前 k，再升序输出
topk = sorted(candidates[:k])
print(' '.join(map(str, topk)))

深度学习核心层关键代码逻辑 完整梳理

一、全连接层（Linear / Dense）

最基础、最万能的神经网络层

$$y=Wx+b$$
对输入做线性变换。

伪代码

function linear(x, W, b):
    return W @ x + b

PyTorch 真实代码

import torch
import torch.nn as nn

# 定义：输入10维，输出20维
fc = nn.Linear(in_features=10, out_features=20)

# 使用
x = torch.randn(32, 10)  # 32个样本，每个10维
out = fc(x)               # 输出 shape: (32,20)

用途
所有模型必备：特征变换、映射、输出logits。

---

二、Softmax 激活层（你题目考的）

把输出变成概率分布，总和=1
$$Softmax(z_i)=\frac{e^{z_i}}{\sum e^{z_j}}$$

伪代码

function softmax(logits):
    exp_vals = exp(logits)
    return exp_vals / sum(exp_vals)

PyTorch代码

softmax = nn.Softmax(dim=-1)
probs = softmax(logits)  # 输出概率

用途
分类任务、大模型生成下一个词的最后一层。

---

三、Sigmoid 激活（二分类专用）

原理
$$\sigma (x)=\frac{1}{1+e^{-x}}$$
输出 0~1

代码

sigmoid = nn.Sigmoid()
out = sigmoid(x)

---

四、ReLU 激活（最常用）

原理
$$ReLU(x)=max(0,x)$$

代码

relu = nn.ReLU()
out = relu(x)

用途
解决梯度消失，90%模型必用。

---

五、卷积层 CNN（图像必备）

原理
提取图像边缘、纹理、特征

代码

conv = nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3)

---

六、池化层（降维）

最大池化

max_pool = nn.MaxPool2d(kernel_size=2)

平均池化

avg_pool = nn.AvgPool2d(kernel_size=2)

---

七、LayerNorm（大模型必备！Transformer 核心）

代码

ln = nn.LayerNorm(embedding_dim)
out = ln(x)

用途
稳定训练，所有大模型（GPT、LLaMA）都用。

---

八、多头注意力 Multi-Head Attention（Transformer 核心）

大模型最关键层！

代码

attention = nn.MultiheadAttention(embed_dim=512, num_heads=8)
out, _ = attention(query, key, value)

用途
让模型理解词语之间的关系。

---

九、Embedding 层（词向量层）

代码

embedding = nn.Embedding(num_embeddings=10000, embedding_dim=512)
x = torch.randint(0,10000,(32,10))
out = embedding(x)

用途
把单词 → 向量，大模型输入层。

---

十、F1值，精确值，召回率

F1 值 极简讲解（结合本题二分类场景）
一、先分清4个基础统计量（二分类，标签0/1）
设：1=正类，0=负类

• TP（真正例）：真实=1，预测=1
• FP（假正例）：真实=0，预测=1
• FN（假反例）：真实=1，预测=0
• TN（真反例）：真实=0，预测=0

二、两个前置指标

1. 精确率 P（查准率）
   预测为正的样本里，真正是正类的比例：
   $$P=\frac{TP}{TP+FP}$$

2. 召回率 R（查全率）
   所有真实正类里，被成功预测为正的比例：
   $$R=\frac{TP}{TP+FN}$$

三、F1 公式
F1 是 P 和 R 的调和平均数，用来综合评价模型，取值范围 $[0,1]$，越接近1效果越好：
$$F1=\frac{2\times P\times R}{P+R}$$

代入展开（做题常用）：
$$F1=\frac{2TP}{2TP+FP+FN}$$

特殊情况：$TP=0$ 时，$F1=0$

---

常见深度学习模型极简总结

按传统网络、循环类、注意力类、卷积类、经典分类/树模型分类，每款只讲核心+适用场景。

一、卷积神经网络 CNN

1. CNN
   • 是什么：靠卷积、池化提取局部空间特征，权重共享、降参。
   • 任务：图像分类、目标检测、图像分割、人脸识别。
2. 经典变体
   • LeNet：早期手写数字识别；
   • AlexNet：深度CNN开山之作，图像分类；
   • VGG：结构规整，堆叠小卷积核；
   • ResNet（残差网络）：解决深层网络退化，通用图像任务。

二、循环类网络（处理序列/时序**）**

1. 标准RNN
   • 是什么：循环传递隐藏状态，建模前后依赖。
   • 任务：短序列建模；缺陷：长序列梯度消失。
2. LSTM
   • 是什么：RNN升级版，增设细胞状态+三门控，保留长期记忆。
   • 任务：机器翻译、文本生成、时序预测、语音识别。
3. GRU
   • 是什么：LSTM简化版，仅两个门，参数更少、训练更快。
   • 任务：和LSTM一致，算力有限时优先使用。
4. Bi-LSTM/Bi-GRU
   • 是什么：双向循环，同时利用过去、未来信息。
   • 任务：分词、命名实体识别、句法分析。

三、注意力&Transformer系列（当前NLP主流）

1. Transformer
   • 是什么：基于自注意力，可并行计算，建模长距离依赖。
   • 任务：几乎所有NLP任务、长时序、多模态。
2. BERT
   • 是什么：基于Transformer编码器，双向预训练模型。
   • 任务：文本分类、情感分析、问答、语义理解。
3. GPT
   • 是什么：基于Transformer解码器，单向自回归。
   • 任务：文本续写、对话、生成类任务。

四、经典机器学习模型（非深度学习）

1. 逻辑回归
   • 是什么：线性模型+sigmod，输出概率。
   • 任务：二分类、风险预测、打分模型。
2. 决策树
   • 是什么：树形判断规则，可解释性强。
   • 任务：分类、回归，小规模数据分析。
3. 随机森林
   • 是什么：多棵决策树集成，投票输出结果。
   • 任务：分类、回归，抗过拟合。
4. XGBoost/LightGBM
   • 是什么：梯度提升树，树模型进阶，精度高、速度快。
   • 任务：表格数据分类/回归，竞赛、工业数据分析常用。
5. SVM支持向量机
   • 是什么：找最优分隔超平面，可搭配核函数处理非线性。
   • 任务：中小样本分类。

五、混合/专用模型

1. CNN+LSTM
   • 是什么：CNN提空间特征，LSTM建模时序。
   • 任务：视频行为识别、图文描述。
2. ConvLSTM
   • 是什么：卷积+LSTM，时空特征一起建模。
   • 任务：气象预测、雷达图像序列。

---

一句话总览（速记）

• 看图片、图像 → CNN系列
• 文字、语音、时序数据 → LSTM/GRU（传统序列）、Transformer/BERT/GPT（主流NLP）
• 表格数据、结构化数据 → 逻辑回归、树模型（随机森林、XGBoost）
• 生成文本、对话 → GPT、自回归模型
• 理解语义、分类文本 → BERT

PCA选择主成分的依据

1、选择依据

1. PCA求出协方差矩阵特征值${\lambda }_1\ge {\lambda }_2\ge \cdots \ge {\lambda }_n$
2. 方差贡献率：${\eta }_i=\frac{{\lambda }_i}{\sum {\lambda }_j}$，代表该主成分保留原始数据信息量
3. 累计贡献率$\sum _{i=1}^k{\eta }_i\ge 85\%$（常用阈值），取前$k$个主成分。
   保留特征值大的主成分，累计方差贡献率达标即停止选取。

SVM支持向量机监督分类

一种二分类有监督模型，核心是在特征空间中找到一个最优分离超平面，让两类样本间隔最大
RBF 核（高斯径向基核函数）
定义：最常用的非线性核函数，把低维线性不可分数据映射到高维空间，实现可分。
惩罚参数 C （正则化系数）
含义：控制分类间隔和允许错分样本的权衡系数。
C 越大：
对错分惩罚越重，尽量不允许出错，容易过拟合，决策边界复杂；
C 越小：
对错分宽容，允许部分样本错分，追求间隔更大，容易欠拟合，泛化更好。
核系数 gamma（RBF 核独有）
含义：控制高斯核的作用范围，决定单个样本的影响辐射距离。
gamma 越大：
每个样本影响范围极小，只贴近自己，决策边界细碎扭曲，极易过拟合；
gamma 越小：
样本影响范围大，辐射全局，决策边界平滑简单，容易欠拟合。

朴素贝叶斯 垃圾邮件过滤

核心原理

1. 用贝叶斯公式：
   $$P(\text{垃圾邮件}|\text{邮件内容})=\frac{P(\text{邮件内容}|\text{垃圾邮件})\cdot P(\text{垃圾邮件})}{P(\text{邮件内容})}$$

2. 朴素的含义：
   假设邮件里每个单词互相独立（条件独立假设），简化计算。

3. 训练阶段

• 收集大量已标注邮件：垃圾邮件、正常邮件
• 统计：
  垃圾邮件里各单词出现概率、正常邮件里各单词出现概率
  还有垃圾邮件、正常邮件的先验概率

2. 预测阶段
   新来一封邮件，拆成单词；
   用朴素贝叶斯分别算出：

• 它是垃圾邮件的后验概率
• 它是正常邮件的后验概率
  谁概率大，就判给哪一类。

正则化(泛化）

正则化越强，模型越泛化，越简单

优化器

数学知识梳理

一、jacobi迭代

线性方程组：{ 4x + y = 6, x + 3y = 3 }
初始解 (x0, y0) = (0, 0)，进行一次 Jacobi 迭代后，(x1, y1) 是：
步骤1：方程组变形
方程组：
$$\{\begin{array}{l}4x+y=6\\ x+3y=3\end{array}$$
Jacobi迭代规则：用旧迭代值代入，逐个解新值，互不干扰。
变形解出 $x,y$：
$$

\begin{cases}
x = \dfrac{6 - y}{4}\[6pt]
y = \dfrac{3 - x}{3}
\end{cases}
$$

步骤2：代入初始值 $(x_0,y_0)=(0,0)$
$$

x_1 = \dfrac{6 - y_0}{4} = \dfrac{6-0}{4} = 1.5\[6pt]
y_1 = \dfrac{3 - x_0}{3} = \dfrac{3-0}{3} = 1
$$

---

延伸知识点

1. Jacobi迭代核心特点
   用上一轮全部旧值一次性算出本轮所有新值，更新互不影响。

2. 对比高斯-赛德尔 Gauss-Seidel
   GS算出一个新值立刻用新值代入下一个变量，收敛比Jacobi快。

3. 迭代收敛条件
   系数矩阵严格对角占优，Jacobi、GS都一定收敛。
   本题：$|4|>|1|,|3|>|1|$，严格对角占优，迭代收敛。

---

牛顿法迭代

1. 牛顿迭代公式（核心）
   $${\mathbf{x}}_{\mathbf{k}+1}={\mathbf{x}}_{\mathbf{k}}-\frac{\mathbf{f}({\mathbf{x}}_{\mathbf{k}})}{{\mathbf{f}}^{\prime }({\mathbf{x}}_{\mathbf{k}})}$$
   $x_k$：本轮值；$x_{k+1}$：下一轮值；$f^{\prime }$：一阶导数

2. 收敛速记

• 单根：二次收敛
• 重根：线性收敛

二、特征向量线性组合

同一特征值的特征向量，非零线性组合仍是该特征值的特征向量。
不同特征值的特征向量相加，一定不是特征向量。
一个特征值 $\lambda$，线性无关的特征向量个数 = 基础解系向量个数 = 几何重数

三、实对称矩阵

定义
实对称矩阵满足两个条件：

1. 矩阵里所有元素都是实数（不是复数）；
2. 矩阵等于自己的转置：
   $${\mathbf{A}}^T=A$$
   沿着主对角线（左上到右下）两边对称。
   位置 ((i,j)) 的元素 = 位置 ((j,i)) 的元素。

例子：
$$A=\left[\begin{array}{ccc}1& 2& 3\\ 2& 5& 6\\ 3& 6& 9\end{array}\right]$$
看：第1行第2列 = 第2行第1列 都是2；
第1行第3列 = 第3行第1列 都是3，完全对称。

简单判断方法

• 对角线元素随便；
• 对角线上下镜像相等；
• 全是实数。

---

延伸必背性质

1. 实对称矩阵特征值全是实数；
2. 不同特征值对应的特征向量互相正交；
3. 实对称矩阵一定可以正交对角化；
4. 实对称矩阵的秩 = 非零特征值个数；
5. 大模型、机器学习里的协方差矩阵都是实对称矩阵。

---

四、正交矩阵

n阶实方阵 (Q)，满足：
$$Q^{T}Q=Q{Q}^T=E$$
就叫正交矩阵。

1. 逆矩阵等于转置：
   $$Q^{-1}=Q^T$$
   不用算繁琐的逆，直接转置就是逆，这是最大特点。
2. 矩阵的列向量（行向量）：
   两两互相正交，且长度为1（标准正交基）。

简单例子
$$Q=\left(\begin{array}{cc}1& 0\\ 0& -1\end{array}\right)$$
转置等于自身，(Q^TQ=E)，是正交矩阵。

---

核心性质

1. 行列式：(|Q|=\boldsymbol{\pm 1})
2. 任意两行/两列内积为0（正交）；自身内积为1（单位长度）。
3. 正交矩阵相乘，结果还是正交矩阵。
4. 实对称矩阵正交对角化，用的就是正交矩阵。
5. 向量乘正交矩阵，只旋转、不拉伸、不改变长度。

---

五、奇异值分解

基本定义
任意一个 $m\times n$ 实矩阵 $A$，都可以做奇异值分解：
$$A=U\Sigma V^T$$

• $U$：$m\times m$ 正交矩阵（左奇异向量）
• $\Sigma$：$m\times n$ 对角矩阵，对角线上是奇异值 ${\sigma }_1\ge {\sigma }_2\ge \cdots >0$
• $V$：$n\times n$ 正交矩阵（右奇异向量）

通俗理解
SVD 就是把任意矩阵，拆解成：旋转 + 拉伸 + 再旋转。
不像特征值分解只能方阵、还要可对角化；
SVD 任意矩阵都能分解，这是最大优势。

奇异值和特征值的关系（必考）
对任意矩阵 $A$：

1. 算 $A^{T}A$ 或 $A{A}^T$，都是实对称方阵
2. $A^{T}A$ 的特征值开平方，就是 $A$ 的奇异值
   $$\sigma =\sqrt{{\lambda }_{A^{T}A}}$$
   ** SVD 有什么用（延伸知识）**
3. 数据降维 PCA
   PCA 本质就是 SVD；用前几个大奇异值，保留主要信息。
4. 图像压缩
   只保留前 k 个奇异值，就能用少量数据还原图片。
5. 推荐系统、协同过滤
   用户-物品评分矩阵用 SVD 分解做推荐。
6. 最小二乘、伪逆求解
   解线性方程组、机器学习拟合底层全靠 SVD。
7. 大模型词向量降维、矩阵近似

六 QR分解和LU分解

LU 分解
. 定义
方阵 (A) 拆成：
[A = LU]

• (L)：下三角矩阵（对角线全1，左下有数、右上全0）

• (U)：上三角矩阵（左上到右下有数、左下全0）

  作用
  解线性方程组 (Ax=b)：

1. 拆 (A=LU)
2. 先解 (Ly=b)
3. 再解 (Ux=y)
   比直接高斯消元更快，适合多次解同系数矩阵、不同右端项。

适用条件
方阵、顺序主子式都不为0；
需要行交换时叫 PLU分解（P是置换矩阵）。

特点

• 只是三角拆分，无正交性
• 只能方阵
• 数值稳定性一般

---

QR 分解

任意 矩阵 (A)都可以做 分解：
[A = QR]

• (Q)：正交矩阵 / 标准正交列
• (R)：上三角矩阵
  (Q^TQ=E)，正交矩阵自带性质：逆=转置。

作用

1. 最小二乘拟合
2. 特征值求解（QR迭代）
3. 线性方程组求解，数值稳定性远强于LU
4. 大模型、机器学习矩阵计算常用

适用范围
方阵、长方形矩阵都可以，比LU适用更广。

---

延伸知识点

对比项	LU分解	QR分解
分解形式	下三角 × 上三角	正交矩阵 × 上三角
适用矩阵	一般仅限方阵	任何矩阵都可
正交性	无	Q是正交阵
数值稳定性	一般	很好
主要用途	解线性方程组、行列式	最小二乘、特征值、数值计算
大模型/机器学习	用得少	用得多

---

七、最大似然估计

已知样本，反推参数：找一组参数，让当前这批样本出现的概率最大。

---

步骤1：写出单个样本的概率 / 概率密度
离散分布：分布律 (P(X=x_i;\theta))
连续分布：概率密度 (f(x_i;\theta))
(\theta) 是待估参数（如 (\lambda,\mu,\sigma^2,p)）

步骤2：构造似然函数 (L(\theta))
样本独立同分布，联合概率=乘积：
$$L(\theta )=\prod _{i=1}^{n}f(x_i;\theta )$$

步骤3：取对数，得对数似然 (\ln L(\theta))
乘积变求和，求导方便：
$$\ln L(\theta )=\sum _{i=1}^n\ln f(x_i;\theta )$$

步骤4：对参数 (\theta) 求导，令导数=0
$$\frac{d\ln L(\theta )}{d\theta }=0$$

步骤5：解方程，解出 $\hat{\theta }$
就是最大似然估计量。

---

八、概率统计：常见分布识别 判定方法

离散型概率分布（结果：整数、个数、次数）

1. 0-1分布（两点分布 / 伯努利分布）
   核心特征

• 只做1次独立试验

• 结果只有两种：成功(1) / 失败(0)

• 单次成功概率为 $p$，失败概率 $1-p$

  概率公式
  $$P(X=1)=p,P(X=0)=1-p$$

典型例子

1. 抛1枚硬币，正面记1、反面记0，$X$ 为结果。
2. 抽检1件产品，合格记1、不合格记0。
3. 一次投篮，投中/未投中。

二项分布 $X\sim B(n,p)$
核心特征

• 重复做 $n$ 次独立同分布 的伯努利试验
• 每次试验只有两种结果（成功/失败）
• $n$：总试验次数（固定）；$p$：单次成功概率
• 随机变量 $X$：$n$ 次试验里总共成功的次数

概率公式
$$P(X=k)=C_n^k{p}^k(1-p{)}^{n-k},k=0,1,\dots ,n$$

典型例子

1. 连续抛硬币10次，$X$ 是正面朝上的次数。

2. 射击20次，$X$ 是命中靶心的次数。

3. 抽取50名学生，$X$ 是及格人数。

4. 泊松分布 $X\sim P(\lambda )$
   核心特征

• 描述单位时间/单位区域内，稀有事件发生的次数
• 试验次数极多、单次概率极小，二项分布的近似分布
• $\lambda$：单位区间内事件平均发生次数

概率公式
$$P(X=k)=\frac{{\lambda }^k{e}^{-\lambda }}{k!},k=0,1,2,\dots$$

典型例子

1. 某路口一小时内通过的车辆数。

2. 一本书每页出现的错别字个数。

3. 某客服一天内接到的投诉电话数。

4. 放射性物质单位时间内放射粒子数。

5. 几何分布
   核心特征

• 独立重复伯努利试验，直到第一次成功为止
• 随机变量 $X$：首次成功时，一共做了多少次试验
• 无固定总次数，试验一直做到成功为止

典型例子

1. 不断抛硬币，直到第一次出现正面，$X$ 为抛掷总次数。

2. 不断投篮，直到投中为止，总投篮次数。

3. 超几何分布
   核心特征

• 不放回抽样（样本之间不独立）

• 总体分两类（正品/次品、A类/B类）

• 从总体抽 $n$ 个，$X$ 为其中某一类的数量

  典型例子

1. 一箱共20个产品，其中5个次品，不放回抽8个，$X$ 是次品数量。
2. 班级30人，男生12人，不放回抽10人，男生人数。

三、连续型概率分布（结果：连续实数，长度、时间、温度等）

1. 均匀分布 $X\sim U(a,b)$
   核心特征

• 随机变量落在区间 $[a,b]$ 内任意等长小区间的概率相等
• 区间外概率为0

概率密度
$$f(x)=\{\begin{array}{ll}\frac{1}{b-a},& a\le x\le b\\ 0,& \text{其他}\end{array}$$

典型例子

1. 班车每隔10分钟发一辆，乘客随机到站，候车时间 $X$。

2. 随机产生 $[0,1]$ 之间的随机数。

3. 一根细棒随机截断，截断点位置。

4. 正态分布（高斯分布）$X\sim N(\mu ,{\sigma }^2)$
   核心特征

• 自然界最常见的分布，曲线呈钟形、对称、中间高两边低
• $\mu$：均值（对称轴位置）；${\sigma }^2$：方差（离散程度）
• 大量微小独立因素共同影响的变量，基本都服从正态分布

标准正态分布：$\mathbf{\mu }=0,{\mathbf{\sigma }}^2=1$，记 $N(0,1)$

典型例子

1. 同龄人的身高、体重、智商。

2. 多次测量同一个物体，测量误差。

3. 学生考试成绩、工厂零件尺寸。

4. 指数分布
   核心特征

• 描述等待时间、寿命
• 具有「无记忆性」：过去等待多久，不影响后续等待概率

典型例子

1. 电子元件、灯泡的使用寿命。
2. 顾客排队等待服务的时间。
3. 两次相邻事故之间的间隔时间。

四、易混淆分布对比（做题高频区分）

1. 二项分布 vs 超几何分布

• 有放回抽样 / 独立重复试验 → 二项分布
• 不放回抽样 → 超几何分布
• 总体容量极大时，不放回近似等同于有放回，超几何可近似为二项。

二项分布 vs 泊松分布

• 固定$n$次试验，求成功次数 → 二项
• 单位时间/区域内事件个数 → 泊松
• 二项满足 $n$ 很大、$p$ 很小时，可用泊松近似。

3. 二项分布 vs 几何分布

• 二项：总次数固定，求成功次数
• 几何：成功为止，求总试验次数

4. 均匀 vs 正态

• 均匀：区间内概率完全相等
• 正态：中间概率大，两端概率小

---

六、速查表（背诵版）

分布	核心场景	类型
0-1分布	1次试验，二选一	离散
二项分布	固定$n$次独立试验，求成功次数	离散
几何分布	试验到首次成功，求总次数	离散
超几何分布	不放回抽样，求某类样本数量	离散
泊松分布	单位时间/区域，事件发生个数	离散
均匀分布	有限区间，概率均等	连续
正态分布	身高、成绩、测量误差（钟形曲线）	连续
指数分布	寿命、等待时间	连续

九 插值与真实值

1. 插值：用少数已知点构造多项式 $P_n(t)$ 去近似原函数；
2. 绝对误差 = |真值 − 插值近似值|；
3. 本题两个式子展开其实一样：
   $P_2(t)=100+20t+5t^2-5t=100+15t+5t^2$
   $\sigma (t)=100+20t+5t^2$，常数项、二次项相同，一次项不同，所以存在误差。

答案：$7.5$

十 向量左乘右乘区别

左乘： 几何：对单个向量做变换，基准是原坐标系不动，向量变形。把原向量(\boldsymbol v)做空间变换
右乘 ：向量不动，坐标系本身做变换

python知识点

数值处理 **int（）**可以转整形字符串，带小数点的字符串会报错，但是能转小数数字型，截取整数部分
float可以转整形1和小数字符串都可以

map函数（function，input）
对象如果是多数组需要map前指定类型

---

Python 里只有 **2 表示平方，^2 不是平方运算。符号区别

：幂运算
x2 → (x^2) 平方
x**3 → 立方

^：按位异或运算
属于二进制位运算，不能算数学平方

items（），把不可迭代类型变成可以迭代的类型