华为AI机试备考计划（完整版）

华为AI机试备考计划

学长寄语：大家好！我是刚通过华为AI机试的学长。这份备考计划凝聚了我和几十位考友的经验，相信能帮你少走弯路。记住：180分及格真的不难，关键是策略正确+心态稳定。加油！

考试概览

题型：20道选择题（150分）+ 2道编程题（150分+300分）
总分：450分，及格线约180分（有时会浮动到160-200分）
时长：120-150分钟（不同场次略有差异）
平台：牛客网/华为自研平台（ACM模式，需要自己处理输入输出）
监考：双机位AI监考，禁止切屏，可用本地IDE
考试形式：在线笔试，摄像头全程监控，屏幕录制
编程语言：Python、Java、C++均可（推荐Python，代码量少）
考试时间：一般在工作日晚上19:00-21:30或周末下午

考试难度分析

选择题：理论为主，涵盖机器学习、深度学习、NLP、CV基础，难度中等
编程题第一题：基础算法实现，难度类似LeetCode Medium，必须拿下
编程题第二题：综合应用题，难度较高，但一般有部分分可拿

通过率情况（仅供参考）

有准备的考生通过率约60-70%
零准备裸考通过率不到20%
认真准备1-2周基本能过

不同基础的备考建议

零基础（几乎没接触过AI）

建议备考时间：至少2周，推荐1个月

学习路径：

先花3天恶补Python基础（列表、字典、NumPy基本操作）
看1-2个小时机器学习入门视频（吴恩达课程前几节）
重点攻克编程题模板，选择题靠刷题+背答案
目标：180分及格即可

心态建议：别慌！很多人都是零基础过的，关键是把ACM输入输出练熟，编程题第一题拿下。

有基础（学过ML课程或做过相关项目）

建议备考时间：1-2周

学习路径：

快速过一遍知识点（1-2天）
重点刷题，尤其是编程题
查漏补缺，重点突破Transformer等新技术
目标：250分以上

强化冲刺（基础扎实，想拿高分）

建议备考时间：3-7天

学习路径：

直接刷真题和模拟题
重点攻克编程题第二题
选择题追求90%以上正确率
目标：300分以上

备考计划（多版本）

📅 1个月完美版（推荐零基础或想拿高分）

Week 1：基础理论+基本算法

第1天（周一）：机器学习入门

上午 9:00-12:00

9:00-10:30：机器学习概述、监督学习vs非监督学习
10:30-12:00：线性回归原理、最小二乘法、梯度下降

下午 14:00-18:00

14:00-15:30：逻辑回归原理、Sigmoid函数
15:30-17:00：手写线性回归代码（NumPy实现）
17:00-18:00：练习ACM输入输出格式

晚上 19:00-22:00

19:00-20:30：刷选择题30道（机器学习基础部分）
20:30-22:00：复习今日内容，整理笔记

练习题清单：

手写线性回归（梯度下降法）
手写逻辑回归（二分类）
ACM输入输出练习5题

复习要点：

线性回归的损失函数是什么？
梯度下降的更新公式
Sigmoid函数的取值范围

第2天（周二）：损失函数+优化器

上午 9:00-12:00

9:00-10:30：损失函数（MSE、交叉熵、Hinge Loss）
10:30-12:00：优化器（SGD、Momentum、Adam）

下午 14:00-18:00

14:00-16:00：手写梯度下降优化器
16:00-18:00：不同损失函数的应用场景

晚上 19:00-22:00

19:00-20:30：刷选择题30道（损失函数、优化器）
20:30-22:00：整理对比表格（损失函数对比、优化器对比）

练习题清单：

实现SGD优化器
实现带Momentum的SGD
对比不同学习率的效果

复习要点：

交叉熵损失函数公式
Adam优化器的特点
学习率衰减策略

第3天（周三）：激活函数专题

上午 9:00-12:00

9:00-11:00：激活函数全解析（Sigmoid、Tanh、ReLU、LeakyReLU、GELU、Swish）
11:00-12:00：激活函数的梯度消失/爆炸问题

下午 14:00-18:00

14:00-16:00：手写各种激活函数及其导数
16:00-18:00：Dead ReLU问题及解决方案

晚上 19:00-22:00

19:00-20:30：刷选择题30道（激活函数专题）
20:30-22:00：画出各激活函数曲线，加深记忆

练习题清单：

实现6种激活函数
实现激活函数的导数
分析不同激活函数的优缺点

复习要点：

ReLU的优点和Dead ReLU问题
GELU在Transformer中的应用
Sigmoid用于输出层的原因

第4天（周四）：神经网络基础

上午 9:00-12:00

9:00-11:00：神经网络结构、前向传播、反向传播
11:00-12:00：链式法则、梯度计算

下午 14:00-18:00

14:00-17:00：手写双层MLP（Multi-Layer Perceptron）
17:00-18:00：调试代码，确保梯度正确

晚上 19:00-22:00

19:00-20:30：刷选择题30道（神经网络基础）
20:30-22:00：复习反向传播推导过程

练习题清单：

手写双层神经网络前向传播
手写反向传播梯度计算
在简单数据集上训练MLP

复习要点：

反向传播的链式法则
权重更新公式
偏置项的作用

第5天（周五）：正则化技术

上午 9:00-12:00

9:00-10:30：过拟合与欠拟合、Bias-Variance Tradeoff
10:30-12:00：正则化技术（L1、L2、Dropout、Early Stopping）

下午 14:00-18:00

14:00-16:00：实现L1/L2正则化
16:00-18:00：实现Dropout层

晚上 19:00-22:00

19:00-20:30：刷选择题30道（正则化、过拟合）
20:30-22:00：总结本周学习内容

练习题清单：

在损失函数中添加L2正则项
实现Dropout（训练和测试模式）
对比有无正则化的效果

复习要点：

L1和L2正则化的区别
Dropout的原理和实现
BatchNorm vs LayerNorm

第6-7天（周末）：第一周总复习+刷题

周六

上午：回顾本周所有笔记
下午：完成2套编程题模拟练习
晚上：整理错题本

周日

上午：刷选择题100道（本周范围）
下午：重新手写本周所有算法
晚上：准备下周学习内容

Week 2：深度学习+Transformer

第8天（周一）：卷积神经网络（CNN）

上午 9:00-12:00

9:00-10:30：卷积层原理、卷积核、特征图
10:30-12:00：池化层、感受野

下午 14:00-18:00

14:00-16:00：计算卷积输出尺寸
16:00-18:00：经典CNN架构（LeNet、AlexNet、VGG、ResNet）

晚上 19:00-22:00

19:00-20:30：刷选择题30道（CNN专题）
20:30-22:00：手写卷积层前向传播

练习题清单：

计算卷积输出尺寸（10道练习）
实现简单的卷积操作
理解ResNet的残差连接

第9天（周二）：循环神经网络（RNN）

上午 9:00-12:00

9:00-10:30：RNN原理、LSTM、GRU
10:30-12:00：梯度消失/爆炸问题

下午 14:00-18:00

14:00-16:00：手写简单RNN
16:00-18:00：LSTM的门控机制

晚上 19:00-22:00

19:00-20:30：刷选择题30道（RNN、LSTM）
20:30-22:00：理解双向RNN

练习题清单：

实现简单RNN前向传播
画出LSTM结构图
对比RNN、LSTM、GRU

第10天（周三）：Attention机制

上午 9:00-12:00

9:00-11:00：注意力机制原理、Query/Key/Value
11:00-12:00：Self-Attention vs Cross-Attention

下午 14:00-18:00

14:00-17:00：手写Self-Attention
17:00-18:00：计算Attention的时间复杂度

晚上 19:00-22:00

19:00-20:30：刷选择题30道（Attention专题）
20:30-22:00：理解Scaled Dot-Product Attention

练习题清单：

实现Self-Attention（NumPy）
计算Attention矩阵
理解为什么要除以sqrt(d_k)

第11天（周四）：Transformer架构（重点）

上午 9:00-12:00

9:00-10:30：Transformer整体架构、Encoder-Decoder
10:30-12:00：Multi-Head Attention

下午 14:00-18:00

14:00-16:00：位置编码（Positional Encoding）
16:00-18:00：Feed-Forward Network、残差连接、LayerNorm

晚上 19:00-22:00

19:00-20:30：刷选择题40道（Transformer专题）
20:30-22:00：手写Multi-Head Attention

练习题清单：

实现Multi-Head Attention
实现位置编码
计算Transformer的参数量

复习要点：

Multi-Head Attention的计算流程
为什么需要位置编码
Transformer的优势

第12天（周五）：大模型优化技术（重点）

上午 9:00-12:00

9:00-10:30：KV Cache原理及优化
10:30-12:00：量化技术（INT8、FP16、4-bit量化）

下午 14:00-18:00

14:00-15:30：LoRA、QLoRA微调技术
15:30-17:00：Flash Attention、Sparse Attention
17:00-18:00：模型压缩与加速

晚上 19:00-22:00

19:00-20:30：刷选择题40道（大模型专题）
20:30-22:00：整理大模型优化技术对比表

练习题清单：

计算KV Cache的显存占用
理解量化带来的精度损失
对比LoRA和全参数微调

复习要点：

KV Cache如何减少计算量
量化的原理和类型
LoRA的rank参数含义

第13-14天（周末）：第二周总复习

周六

上午：回顾CNN、RNN、Transformer
下午：完成3套编程题模拟
晚上：整理Transformer相关所有知识点

周日

上午：刷选择题150道（第二周范围）
下午：手写Transformer核心组件
晚上：准备第三周内容

Week 3：传统算法+数据处理

第15天（周一）：KNN算法

上午 9:00-12:00

9:00-10:30：KNN原理、距离度量（欧式、曼哈顿、余弦）
10:30-12:00：K值选择、KD树优化

下午 14:00-18:00

14:00-17:00：手写KNN分类器
17:00-18:00：优化KNN性能

晚上 19:00-22:00

19:00-20:30：刷选择题30道（KNN、距离度量）
20:30-22:00：实现不同距离度量

练习题清单：

实现KNN分类（完整版）
实现3种距离度量
在Iris数据集上测试

第16天（周二）：决策树+随机森林

上午 9:00-12:00

9:00-10:30：决策树原理、信息增益、基尼系数
10:30-12:00：剪枝策略、随机森林

下午 14:00-18:00

14:00-16:00：实现简单的决策树
16:00-18:00：理解随机森林的Bagging机制

晚上 19:00-22:00

19:00-20:30：刷选择题30道（决策树专题）
20:30-22:00：对比决策树、随机森林、GBDT

练习题清单：

计算信息增益
理解决策树的分裂过程
对比不同集成学习方法

第17天（周三）：数据预处理（高频考点）

上午 9:00-12:00

9:00-10:30：数据标准化vs归一化（Z-score、Min-Max）
10:30-12:00：缺失值处理（均值填充、中位数、KNN填充）

下午 14:00-18:00

14:00-16:00：异常值检测（IQR、Z-score、孤立森林）
16:00-18:00：特征工程（独热编码、标签编码）

晚上 19:00-22:00

19:00-20:30：刷选择题30道（数据预处理）
20:30-22:00：手写所有预处理函数

练习题清单：

实现Z-score标准化
实现Min-Max归一化
实现缺失值填充（3种方法）
实现异常值检测

复习要点：

标准化和归一化的区别
什么时候用均值填充，什么时候用中位数
如何检测异常值

第18天（周四）：相似度计算

上午 9:00-12:00

9:00-10:30：余弦相似度、欧式距离、曼哈顿距离
10:30-12:00：Jaccard相似度、编辑距离

下午 14:00-18:00

14:00-16:00：文本相似度计算（TF-IDF + 余弦相似度）
16:00-18:00：时间窗口检索问题

晚上 19:00-22:00

19:00-20:30：刷选择题30道（相似度专题）
20:30-22:00：实现文档检索系统

练习题清单：

实现余弦相似度计算
实现TF-IDF
实现时间窗口检索

第19天（周五）：评估指标

上午 9:00-12:00

9:00-10:30：分类指标（Accuracy、Precision、Recall、F1-score）
10:30-12:00：混淆矩阵、ROC曲线、AUC

下午 14:00-18:00

14:00-16:00：回归指标（MSE、RMSE、MAE、R²）
16:00-18:00：交叉验证、过拟合判断

晚上 19:00-22:00

19:00-20:30：刷选择题30道（评估指标）
20:30-22:00：手写所有评估指标

练习题清单：

实现Precision/Recall/F1
根据混淆矩阵计算指标
实现MSE、RMSE、MAE

第20-21天（周末）：第三周复习

周六

上午：复习传统算法
下午：完成3套编程题
晚上：整理数据预处理模板

周日

上午：刷选择题100道
下午：手写所有算法
晚上：准备冲刺阶段

Week 4：刷题冲刺+模拟考试

第22-26天：疯狂刷题

每天安排：

上午：1套完整模拟题（150分钟，严格计时）
下午：分析错题，补充知识点
晚上：专项练习（选择题或编程题）

刷题清单（每天完成）：

1套完整模拟题（选择题+编程题）
选择题错题回顾
编程题超时用例优化
整理1个知识专题

第27天：考前复习

上午：快速过一遍所有笔记
下午：最后1套模拟题
晚上：准备考试环境，早休息

📅 2周稳健版（推荐有基础）

第1-2天：机器学习基础速成

Day 1 上午：线性回归、逻辑回归、激活函数
Day 1 下午：手写线性回归、逻辑回归
Day 1 晚上：刷选择题50道 + ACM输入输出

Day 2 上午：损失函数、优化器、正则化
Day 2 下午：手写梯度下降、实现Dropout
Day 2 晚上：刷选择题50道

练习题清单：

手写线性回归（梯度下降）
手写逻辑回归
实现SGD和Adam优化器
刷选择题100道

第3-4天：神经网络+CNN/RNN

Day 3 上午：神经网络前向反向传播
Day 3 下午：手写双层MLP
Day 3 晚上：刷选择题50道

Day 4 上午：CNN原理、卷积计算
Day 4 下午：RNN、LSTM基础
Day 4 晚上：刷选择题50道

练习题清单：

手写MLP前向传播
计算卷积输出尺寸（20道）
理解LSTM结构

第5-7天：Transformer+大模型（重中之重）

Day 5 全天：

上午：Attention机制、Self-Attention
下午：Multi-Head Attention、位置编码
晚上：手写Multi-Head Attention + 刷题50道

Day 6 全天：

上午：Transformer架构、Encoder-Decoder
下午：KV Cache、量化技术
晚上：LoRA、大模型优化 + 刷题50道

Day 7 全天：

上午：复习Transformer所有知识点
下午：刷选择题100道（Transformer专题）
晚上：手写Transformer核心代码

练习题清单：

手写Self-Attention
手写Multi-Head Attention
计算KV Cache显存占用
理解量化技术

第8-9天：传统算法+数据处理

Day 8 全天：

上午：KNN、决策树原理
下午：手写KNN分类器
晚上：刷选择题50道

Day 9 全天：

上午：数据标准化/归一化、缺失值处理
下午：余弦相似度、TF-IDF
晚上：手写数据预处理函数 + 刷题50道

练习题清单：

手写KNN（完整版）
实现Z-score标准化
实现缺失值填充
实现余弦相似度

第10-13天：疯狂刷题

每天：

上午：1套完整模拟题（严格计时150分钟）
下午：分析错题，补充知识盲区
晚上：专项训练（编程题或选择题）

刷题目标：

完成至少8套完整模拟题
选择题正确率稳定在75%以上
编程题第一题能在30分钟内AC

第14天：考前准备

上午：快速过笔记（不学新知识）
下午：最后1套模拟题
晚上：准备考试环境，调试设备，早睡

📅 1周速成版（适合临时抱佛脚）

警告：1周时间非常紧张，只适合有一定基础或只求及格（180分）的同学！

Day 1-2：核心理论速成

Day 1：

上午：激活函数、损失函数、优化器（只记结论，不求甚解）
下午：手写线性回归、逻辑回归
晚上：刷选择题100道 + 熟悉ACM输入输出

Day 2：

上午：神经网络基础、前向反向传播
下午：手写MLP
晚上：刷选择题100道

Day 3-4：Transformer突击（最高频）

Day 3：

上午：Attention机制、Multi-Head Attention
下午：Transformer架构
晚上：手写Self-Attention + 刷题50道

Day 4：

上午：KV Cache、量化技术、LoRA
下午：位置编码、LayerNorm
晚上：刷选择题100道（Transformer专题）

Day 5：数据处理+传统算法

上午：数据标准化、归一化、缺失值处理
下午：KNN、余弦相似度
晚上：手写数据预处理函数 + KNN

Day 6：疯狂刷题

上午：完整模拟题2套
下午：完整模拟题2套
晚上：整理错题，背高频考点

Day 7：考前冲刺

上午：过一遍笔记和错题
下午：最后1套模拟题
晚上：准备考试环境，早休息

速成版重点：

放弃深入理解，以刷题为主
选择题靠刷题+背答案
编程题第一题必须拿下
编程题第二题能拿部分分就拿，不强求

📅 临考前3天冲刺版（救命版）

适用场景：3天后就要考试，现在才开始准备（虽然不推荐，但总比裸考好）

Day -3：核心知识点突击

上午 8:00-12:00：

看完激活函数、损失函数、优化器（背结论）
快速理解神经网络前向传播

下午 13:00-18:00：

Transformer核心概念（Multi-Head Attention、KV Cache）
看一遍大模型优化技术（量化、LoRA）

晚上 19:00-23:00：

疯狂刷选择题200道（不管对错，看答案记住）
熟悉ACM输入输出模板

必背清单：

ReLU、Sigmoid、GELU的性质
Adam优化器的特点
Transformer的注意力复杂度
KV Cache的作用
量化技术（INT8、FP16）

Day -2：编程题突击+刷题

上午 8:00-12:00：

手写线性回归（梯度下降）- 必须会！
手写逻辑回归（二分类）- 必须会！
手写KNN分类器 - 必须会！

下午 13:00-18:00：

数据预处理：标准化、归一化、缺失值填充
余弦相似度计算
准备好所有代码模板

晚上 19:00-23:00：

完整模拟题2套（计时完成）
整理编程题模板到本地

必练代码：

线性回归（手写梯度下降）
逻辑回归
KNN分类器
Z-score标准化
缺失值填充
余弦相似度

Day -1：模拟考试+考前准备

上午 8:00-12:00：

完整模拟题2套（严格计时150分钟）
重点练习ACM输入输出

下午 13:00-17:00：

快速过一遍笔记
刷选择题100道（查漏补缺）
整理错题

晚上 18:00-20:00：

准备考试环境（双机位、Chrome浏览器、本地IDE）
把所有代码模板复制到本地文件
准备好NumPy速查表

20:00之后：

不要再学新东西
早睡！！！（重要）

救命策略：

目标定在180分（及格即可）
选择题靠刷题记答案（目标80分）
编程题第一题必须拿下（目标100-120分）
编程题第二题能做就做，做不出来就放弃

核心知识点清单

选择题必背（150分）

激活函数专题（高频）

✅ ReLU (Rectified Linear Unit)

公式：f(x) = max(0, x)
优点：计算简单、缓解梯度消失、训练快
缺点：Dead ReLU问题（神经元死亡）
应用：CNN中间层

✅ Sigmoid

公式：f(x) = 1 / (1 + e^(-x))
取值范围：(0, 1)
优点：输出可解释为概率
缺点：梯度消失严重、计算慢
应用：二分类输出层

✅ Tanh

公式：f(x) = (e^x - e^(-x)) / (e^x + e^(-x))
取值范围：(-1, 1)
优点：零中心化，收敛快
缺点：梯度消失
应用：RNN

✅ GELU (Gaussian Error Linear Unit)

公式：f(x) = x * Φ(x)（Φ是标准正态分布累积分布函数）
优点：平滑、性能好
应用：Transformer（BERT、GPT）

✅ LeakyReLU

公式：f(x) = max(αx, x)，α通常是0.01
优点：解决Dead ReLU问题
应用：GAN

✅ Swish / SiLU

公式：f(x) = x * sigmoid(x)
优点：平滑、非单调
应用：EfficientNet

高频考点：

Dead ReLU原因：当x<0时梯度为0，如果权重更新后神经元始终输出负值，梯度永远为0
为什么GELU用于Transformer：平滑性好、非凸非单调、适合大模型
Sigmoid vs Tanh：Tanh是零中心的，收敛更快

损失函数专题

✅ MSE (Mean Squared Error) - 回归任务

公式：L = (1/n) * Σ(y_pred - y_true)²
特点：对异常值敏感
应用：线性回归

✅ Cross-Entropy Loss - 分类任务

二分类：L = -[y*log(p) + (1-y)*log(1-p)]
多分类：L = -Σ y_i * log(p_i)
应用：所有分类任务

✅ Hinge Loss - SVM

公式：L = max(0, 1 - y*f(x))
应用：支持向量机

✅ Focal Loss

解决类别不平衡问题
应用：目标检测

高频考点：

为什么分类用交叉熵而不是MSE：交叉熵梯度更稳定，MSE会导致梯度消失
交叉熵的数学推导：基于最大似然估计

优化器专题（超高频）

✅ SGD (Stochastic Gradient Descent)

公式：θ = θ - lr * ∇L
优点：简单、通用
缺点：收敛慢、容易震荡
学习率：需要手动调整

✅ Momentum

公式：v = βv + ∇L; θ = θ - lrv
优点：加速收敛、减少震荡
典型β值：0.9

✅ Adam (Adaptive Moment Estimation)

结合Momentum和RMSprop
优点：自适应学习率、收敛快、鲁棒性好
缺点：可能过拟合
典型参数：β1=0.9, β2=0.999, ε=1e-8
应用：最常用的优化器

✅ AdamW

Adam + 权重衰减
优点：比Adam泛化性能更好
应用：Transformer训练

✅ Learning Rate Scheduler

StepLR：每N个epoch衰减一次
CosineAnnealingLR：余弦退火
ReduceLROnPlateau：验证集不下降时衰减

高频考点：

Adam vs SGD：Adam自适应学习率，SGD需要手动调整，但SGD泛化性能可能更好
AdamW vs Adam：AdamW解耦权重衰减，避免L2正则化和自适应学习率冲突
学习率太大/太小的影响：太大震荡或发散，太小收敛慢或陷入局部最优

Transformer专题（重中之重，30-40分）

✅ Self-Attention计算流程

计算Q、K、V：Q=XW_q, K=XW_k, V=XW_v
计算注意力分数：scores = QK^T / sqrt(d_k)
Softmax归一化：attention_weights = softmax(scores)
加权求和：output = attention_weights * V

时间复杂度：O(n²d)，其中n是序列长度，d是特征维度
空间复杂度：O(n²)（存储注意力矩阵）

✅ 为什么除以sqrt(d_k)

防止点积过大导致softmax梯度消失
d_k越大，点积方差越大，除以sqrt(d_k)可以归一化

✅ Multi-Head Attention

多个注意力头并行计算，捕获不同子空间的信息
公式：MultiHead(Q,K,V) = Concat(head_1,…,head_h)W_o
head_i = Attention(QW_qi, KW_ki, VW_vi)
典型头数：8或16

参数量计算：

单头：3d_modeld_k（Q、K、V三个权重矩阵）
多头：h3d_model*(d_model/h) + d_modeld_model = 4d_model²

✅ 位置编码 (Positional Encoding)

为什么需要：Self-Attention没有位置信息
公式：
- PE(pos, 2i) = sin(pos / 10000^(2i/d_model))
- PE(pos, 2i+1) = cos(pos / 10000^(2i/d_model))
特点：可以处理任意长度序列
可学习 vs 固定：BERT用可学习，GPT用固定

✅ KV Cache优化（超高频）

原理：推理时缓存已计算的Key和Value，避免重复计算
应用场景：自回归生成（GPT类模型）
显存占用计算：
- 单层单个token：2 * d_model * sizeof(float16)
- n层、batch_size=b、seq_len=s：2 * n * b * s * d_model * 2字节
- 例：32层、d_model=4096、seq_len=2048、batch=1：232204840962字节 ≈ 1GB
优化方法：
- Multi-Query Attention（MQA）：多个Query头共享一组KV
- Grouped-Query Attention（GQA）：分组共享
- Page Attention：分页管理KV Cache

✅ 量化技术（高频）

INT8量化：FP32→INT8，模型大小减少4倍，速度提升2-3倍
FP16 (Half Precision)：FP32→FP16，减少2倍显存
4-bit量化：QLoRA使用，极致压缩
量化感知训练 (QAT)：训练时模拟量化
训练后量化 (PTQ)：训练后直接量化
精度损失：一般INT8损失<1%，4-bit损失2-5%

✅ LoRA (Low-Rank Adaptation)

原理：冻结预训练权重，只训练低秩分解矩阵
公式：W’ = W + BA，其中B∈R^(d×r)，A∈R^(r×d)，r<<d
优点：
- 参数量少：r=8时只训练0.1%参数
- 显存占用低
- 可插拔（多个LoRA切换）
rank参数：r越大表达能力越强，但参数越多。典型值：4、8、16、32
QLoRA：LoRA + 4-bit量化，在消费级GPU训练大模型

✅ Flash Attention

优化注意力计算的IO效率
减少显存占用，提升训练速度

✅ LayerNorm vs BatchNorm

BatchNorm：对batch维度归一化，用于CNN
LayerNorm：对特征维度归一化，用于Transformer
为什么Transformer用LayerNorm：
- 序列长度可变，batch统计不稳定
- LayerNorm不依赖batch，适合小batch或推理

超高频考题：

Transformer注意力的时间复杂度？O(n²d)
KV Cache如何减少计算量？缓存历史K、V，只计算新token
为什么要除以sqrt(d_k)？防止点积过大导致梯度消失
Multi-Head Attention比单头好在哪？捕获不同子空间信息
LoRA的rank参数含义？低秩分解的秩，越大表达能力越强
INT8量化能压缩多少？4倍模型大小，损失<1%精度

正则化技术

✅ L1正则化（Lasso）

公式：Loss = Loss_original + λ * Σ|w|
效果：产生稀疏解（很多权重为0）
应用：特征选择

✅ L2正则化（Ridge）

公式：Loss = Loss_original + λ * Σw²
效果：权重衰减，防止过拟合
应用：最常用的正则化

✅ Dropout

训练时随机丢弃一部分神经元（典型p=0.5）
测试时使用全部神经元，输出乘以(1-p)
原理：集成学习思想
应用：全连接层

✅ Early Stopping

验证集性能不再提升时停止训练
防止过拟合

✅ Data Augmentation

图像：旋转、翻转、裁剪、颜色抖动
文本：同义词替换、回译、EDA

高频考点：

L1 vs L2：L1产生稀疏解，L2平滑权重
Dropout为什么有效：模拟集成学习，防止神经元共适应
BatchNorm vs Dropout：BN在卷积层，Dropout在全连接层

CNN专题

✅ 卷积输出尺寸计算

公式：output_size = (input_size - kernel_size + 2*padding) / stride + 1
例：输入28×28，卷积核5×5，padding=0，stride=1 → 输出24×24

✅ 感受野 (Receptive Field)

定义：输出特征图上一个像素对应输入图像的区域大小
计算：每层感受野累积
重要性：感受野越大，捕获的上下文信息越多

✅ 残差连接 (Residual Connection)

ResNet核心：y = F(x) + x
解决：深层网络退化问题、梯度消失
应用：ResNet、Transformer

✅ 常见架构

LeNet-5：早期CNN，手写数字识别
AlexNet：ImageNet冠军，8层，ReLU+Dropout
VGG：3×3小卷积核堆叠
ResNet：残差连接，可训练超过100层
Inception：多尺度卷积核并行

RNN/LSTM专题

✅ RNN梯度消失/爆炸

原因：长序列反向传播时梯度连乘
梯度消失：梯度<1时，多次相乘趋近于0
梯度爆炸：梯度>1时，多次相乘趋近于∞
解决：LSTM/GRU、梯度裁剪

✅ LSTM门控机制

遗忘门 (Forget Gate)：决定遗忘多少历史信息
输入门 (Input Gate)：决定接收多少新信息
输出门 (Output Gate)：决定输出多少信息
细胞状态 (Cell State)：长期记忆

✅ GRU vs LSTM

GRU：2个门（更新门、重置门），参数少，训练快
LSTM：3个门，表达能力更强
选择：短序列用GRU，长序列用LSTM

传统算法专题

✅ KNN

原理：找K个最近邻，投票决定类别
K值选择：K太小容易过拟合，K太大欠拟合。通常用交叉验证选择
距离度量：欧式、曼哈顿、余弦
优点：简单、无需训练
缺点：计算慢（O(nd)）、需要大量存储
优化：KD树、Ball树

✅ 决策树

分裂标准：信息增益（ID3）、信息增益率（C4.5）、基尼系数（CART）
剪枝：预剪枝（提前停止）、后剪枝（先生长后剪枝）
优点：可解释性强
缺点：容易过拟合

✅ 随机森林

Bagging + 决策树
特点：并行训练、不易过拟合
优点：性能好、鲁棒

✅ GBDT (Gradient Boosting Decision Tree)

Boosting思想：串行训练，后一棵树修正前面的错误
XGBoost：GBDT的高效实现，加入正则化

数据预处理（高频考点）

✅ 标准化 (Standardization / Z-score Normalization)

公式：x’ = (x - μ) / σ
结果：均值0，标准差1
应用：特征尺度差异大时、线性模型、SVM、逻辑回归
不改变数据分布形状

✅ 归一化 (Normalization / Min-Max Scaling)

公式：x’ = (x - min) / (max - min)
结果：缩放到[0, 1]
应用：神经网络、图像处理（像素值归一化）
对异常值敏感

✅ 标准化 vs 归一化

标准化：不限制范围，保留异常值信息，适用于正态分布数据
归一化：限制在[0,1]，对异常值敏感，适用于有明确边界的数据

✅ 缺失值处理

删除：数据量大且缺失少时
均值填充：数值型、数据正态分布
中位数填充：数值型、有异常值
众数填充：类别型
KNN填充：根据相似样本填充，效果好但计算慢
插值法：时间序列数据

✅ 异常值检测

IQR (四分位距)：Q1-1.5IQR ~ Q3+1.5IQR之外为异常
Z-score：|Z| > 3为异常（假设正态分布）
孤立森林 (Isolation Forest)：基于树的异常检测
LOF (Local Outlier Factor)：局部异常因子

✅ 特征编码

标签编码 (Label Encoding)：0,1,2,… (有序类别)
独热编码 (One-Hot Encoding)：[1,0,0], [0,1,0], [0,0,1] (无序类别)
目标编码 (Target Encoding)：用目标变量的统计量编码

相似度计算（必考）

✅ 余弦相似度

公式：cos(θ) = (A·B) / (||A|| * ||B||)
取值范围：[-1, 1]，1表示完全相同
应用：文本相似度、推荐系统
特点：只关注方向，不关注长度

✅ 欧式距离

公式：d = sqrt(Σ(a_i - b_i)²)
应用：KNN、聚类
特点：考虑长度

✅ 曼哈顿距离

公式：d = Σ|a_i - b_i|
应用：网格路径问题

✅ Jaccard相似度

公式：J = |A∩B| / |A∪B|
应用：集合相似度

✅ 编辑距离 (Levenshtein Distance)

两个字符串之间的最小编辑操作数
应用：拼写纠错、DNA序列比对

评估指标

✅ 分类指标

Accuracy：(TP+TN) / (TP+TN+FP+FN)
Precision（精确率）：TP / (TP+FP)，预测为正的样本中真正为正的比例
Recall（召回率）：TP / (TP+FN)，真实为正的样本中被正确预测的比例
F1-score：2 * (Precision * Recall) / (Precision + Recall)，调和平均数
ROC曲线：TPR vs FPR
AUC：ROC曲线下面积，0.5随机，1.0完美

什么时候用Precision，什么时候用Recall？

Precision：关注预测为正的准确性（如垃圾邮件分类，不能误杀正常邮件）
Recall：关注找全所有正样本（如疾病诊断，不能漏诊）
F1：平衡二者

✅ 回归指标

MAE (Mean Absolute Error)：Σ|y_pred - y_true| / n，对异常值不敏感
MSE (Mean Squared Error)：Σ(y_pred - y_true)² / n，对异常值敏感
RMSE：sqrt(MSE)，与目标变量同量纲
R² (决定系数)：1 - (SS_res / SS_tot)，越接近1越好

✅ 混淆矩阵

1
2
3

                预测正  预测负
实际正   TP      FN
实际负   FP      TN

其他高频考点

✅ 过拟合 vs 欠拟合

过拟合：训练集表现好，测试集差。解决：正则化、Dropout、Early Stopping、增加数据
欠拟合：训练集测试集都差。解决：增加模型复杂度、增加特征、减少正则化

✅ Bias-Variance Tradeoff

High Bias (欠拟合)：模型过于简单
High Variance (过拟合)：模型过于复杂
目标：找到平衡点

✅ 交叉验证

K-Fold：数据分K份，轮流做验证集
留一法 (LOO)：每次留一个样本做验证
分层采样：保持类别比例

✅ Embedding

Word2Vec：CBOW、Skip-gram
GloVe：基于全局词共现矩阵
BERT Embedding：上下文相关的词向量

✅ Batch Size影响

大Batch：训练快、稳定，但泛化性能可能差、需要更多显存
小Batch：泛化好、正则化效果，但训练慢、不稳定

✅ 数据集划分

训练集：验证集：测试集 = 70:15:15 或 80:10:10
训练集：训练模型
验证集：调超参数
测试集：最终评估（只用一次）

编程题必练（450分中的300分）

第一题（150分）- 基础算法实现

必练题型：

✅ 1. 线性回归（梯度下降法）

import numpy as np

def linear_regression_gd(X, y, lr=0.01, epochs=1000):
    """
    X: (n_samples, n_features)
    y: (n_samples,)
    """
    n_samples, n_features = X.shape
    # 初始化权重和偏置
    w = np.zeros(n_features)
    b = 0
    
    for epoch in range(epochs):
        # 前向传播
        y_pred = np.dot(X, w) + b
        
        # 计算梯度
        dw = (2/n_samples) * np.dot(X.T, (y_pred - y))
        db = (2/n_samples) * np.sum(y_pred - y)
        
        # 更新参数
        w -= lr * dw
        b -= lr * db
        
        # 计算损失（可选）
        if epoch % 100 == 0:
            loss = np.mean((y_pred - y) ** 2)
            print(f"Epoch {epoch}, Loss: {loss:.4f}")
    
    return w, b

✅ 2. 逻辑回归（二分类）

def sigmoid(z):
    return 1 / (1 + np.exp(-z))

def logistic_regression(X, y, lr=0.01, epochs=1000):
    n_samples, n_features = X.shape
    w = np.zeros(n_features)
    b = 0
    
    for epoch in range(epochs):
        # 前向传播
        z = np.dot(X, w) + b
        y_pred = sigmoid(z)
        
        # 计算梯度
        dw = (1/n_samples) * np.dot(X.T, (y_pred - y))
        db = (1/n_samples) * np.sum(y_pred - y)
        
        # 更新参数
        w -= lr * dw
        b -= lr * db
    
    return w, b

✅ 3. KNN分类器（完整版）

import numpy as np
from collections import Counter

def euclidean_distance(x1, x2):
    return np.sqrt(np.sum((x1 - x2) ** 2))

def knn_predict(X_train, y_train, X_test, k=3):
    predictions = []
    
    for test_point in X_test:
        # 计算测试点到所有训练点的距离
        distances = []
        for i, train_point in enumerate(X_train):
            dist = euclidean_distance(test_point, train_point)
            distances.append((dist, y_train[i]))
        
        # 按距离排序，取前k个
        distances.sort(key=lambda x: x[0])
        k_nearest = [label for _, label in distances[:k]]
        
        # 投票
        most_common = Counter(k_nearest).most_common(1)[0][0]
        predictions.append(most_common)
    
    return np.array(predictions)

✅ 4. 双层MLP前向传播

def relu(x):
    return np.maximum(0, x)

def mlp_forward(X, W1, b1, W2, b2):
    """
    X: (n_samples, input_dim)
    W1: (input_dim, hidden_dim)
    W2: (hidden_dim, output_dim)
    """
    # 第一层
    z1 = np.dot(X, W1) + b1
    a1 = relu(z1)
    
    # 第二层
    z2 = np.dot(a1, W2) + b2
    # 如果是分类任务，这里可以加softmax
    # a2 = softmax(z2)
    
    return z2

✅ 5. 数据标准化（Z-score）

def z_score_normalization(X):
    """
    X: (n_samples, n_features)
    """
    mean = np.mean(X, axis=0)
    std = np.std(X, axis=0)
    # 避免除以0
    std[std == 0] = 1
    X_normalized = (X - mean) / std
    return X_normalized, mean, std

✅ 6. 数据归一化（Min-Max）

def min_max_normalization(X):
    """
    归一化到[0, 1]
    """
    min_val = np.min(X, axis=0)
    max_val = np.max(X, axis=0)
    # 避免除以0
    range_val = max_val - min_val
    range_val[range_val == 0] = 1
    X_normalized = (X - min_val) / range_val
    return X_normalized, min_val, max_val

✅ 7. 缺失值填充

def fill_missing_values(X, strategy='mean'):
    """
    strategy: 'mean', 'median', 'mode'
    """
    X_filled = X.copy()
    
    for col in range(X.shape[1]):
        mask = np.isnan(X[:, col])
        if np.any(mask):
            if strategy == 'mean':
                fill_value = np.nanmean(X[:, col])
            elif strategy == 'median':
                fill_value = np.nanmedian(X[:, col])
            elif strategy == 'mode':
                # 对于众数，需要处理非nan值
                values = X[~mask, col]
                fill_value = np.bincount(values.astype(int)).argmax()
            
            X_filled[mask, col] = fill_value
    
    return X_filled

✅ 8. 余弦相似度

def cosine_similarity(vec1, vec2):
    """
    计算两个向量的余弦相似度
    """
    dot_product = np.dot(vec1, vec2)
    norm1 = np.linalg.norm(vec1)
    norm2 = np.linalg.norm(vec2)
    
    if norm1 == 0 or norm2 == 0:
        return 0.0
    
    return dot_product / (norm1 * norm2)

def cosine_similarity_matrix(X, Y=None):
    """
    计算矩阵X和Y之间的余弦相似度矩阵
    X: (n_samples, n_features)
    Y: (m_samples, n_features) 或 None（如果None，计算X内部的相似度）
    返回: (n_samples, m_samples)
    """
    if Y is None:
        Y = X
    
    # 归一化
    X_norm = X / np.linalg.norm(X, axis=1, keepdims=True)
    Y_norm = Y / np.linalg.norm(Y, axis=1, keepdims=True)
    
    # 计算点积
    similarity = np.dot(X_norm, Y_norm.T)
    
    return similarity

✅ 9. 时间窗口检索

def time_window_query(data, timestamps, start_time, end_time):
    """
    在时间窗口内检索数据
    data: 数据数组
    timestamps: 时间戳数组
    start_time, end_time: 时间窗口
    """
    mask = (timestamps >= start_time) & (timestamps <= end_time)
    return data[mask]

✅ 10. TF-IDF计算

def compute_tf(doc):
    """计算词频"""
    tf = {}
    total_words = len(doc)
    for word in doc:
        tf[word] = tf.get(word, 0) + 1
    # 归一化
    for word in tf:
        tf[word] /= total_words
    return tf

def compute_idf(docs):
    """计算逆文档频率"""
    import math
    N = len(docs)
    idf = {}
    
    # 统计每个词出现在多少个文档中
    for doc in docs:
        unique_words = set(doc)
        for word in unique_words:
            idf[word] = idf.get(word, 0) + 1
    
    # 计算IDF
    for word in idf:
        idf[word] = math.log(N / idf[word])
    
    return idf

def compute_tfidf(docs):
    """计算TF-IDF"""
    idf = compute_idf(docs)
    tfidf_docs = []
    
    for doc in docs:
        tf = compute_tf(doc)
        tfidf = {}
        for word in tf:
            tfidf[word] = tf[word] * idf.get(word, 0)
        tfidf_docs.append(tfidf)
    
    return tfidf_docs

第二题（300分）- 综合应用题

特点：

难度较高，通常是复杂的算法实现或优化问题
可能结合多个知识点
有部分分，建议至少拿50-100分

常见题型：

优化问题：如神经网络训练、超参数调优
复杂数据处理：如时间序列分析、图像处理
算法优化：如KNN加速、矩阵运算优化
模型融合：如Ensemble方法
实际应用：如推荐系统、异常检测

策略：

先读懂题意，理解输入输出
实现基础版本，确保能通过部分测试用例
如果时间充足，再优化性能
不要在第二题卡太久，确保前面都做完

每日打卡清单（可打印版）

📋 日常学习打卡表

日期：______ 年 ______ 月 ______ 日    第 ______ 天

【上午学习】9:00-12:00
□ 理论学习（知识点：___________________________）
□ 笔记整理
□ 知识点理解测试

【下午学习】14:00-18:00
□ 代码实现（算法：___________________________）
□ 调试运行成功
□ 代码理解与优化

【晚上学习】19:00-22:00
□ 选择题刷题 ______ 道（目标：30-50道）
  正确率：______%
□ 编程题练习 ______ 道
□ 错题整理
□ 复习今日内容

【今日完成情况】
✓ 手写算法：_______________________________
✓ 刷题数量：选择题 ______ 道，编程题 ______ 道
✓ 掌握知识点：_______________________________
✓ 遇到的问题：_______________________________
✓ 明日计划：_______________________________

【自我评分】（1-10分）
理论掌握：______ 分
代码能力：______ 分
刷题效率：______ 分

【学习时长统计】
今日学习：______ 小时
累计学习：______ 小时

加油！坚持就是胜利！💪

📋 周总结打卡表

第 ______ 周总结

【本周学习概况】
□ 完成理论章节：_______________________________
□ 手写算法数量：______ 个
□ 选择题总数：______ 道，正确率：______%
□ 编程题总数：______ 道
□ 模拟考试：______ 套

【本周重点掌握】
1. _______________________________
2. _______________________________
3. _______________________________

【本周易错点】
1. _______________________________
2. _______________________________
3. _______________________________

【下周计划】
1. _______________________________
2. _______________________________
3. _______________________________

【状态评估】
□ 进度正常，信心十足
□ 进度正常，略有压力
□ 进度落后，需要调整
□ 其他：_______________________________

真实考生经验分享

🎓 经验1：零基础2周通过（180分）

背景：非CS专业，只学过Python基础，备考2周

备考经历：

第1周：疯狂补基础理论，每天刷选择题100道，虽然正确率只有40%，但一直坚持看答案学习
第2周：重点练编程题，把线性回归、逻辑回归、KNN手写了至少5遍，确保闭眼都能写出来
考前3天：每天1套模拟题，严格计时

考试策略：

选择题做了45分钟，大概对了12道（90分）
编程题第一题是逻辑回归，30分钟AC（150分）
编程题第二题看了10分钟没思路，果断放弃
最终得分：240分

经验总结：

✅ ACM输入输出要练熟，考试时不能在这上面浪费时间
✅ 编程题第一题一定要拿下，这是生命线
✅ 选择题不会的直接跳过，不要纠结
✅ 时间管理很重要：选择题40分钟、第一题40分钟、第二题60分钟（或放弃）

🎓 经验2：有基础1周通过（310分）

背景：计算机专业，学过机器学习课程，备考1周

备考经历：

前3天：快速过一遍知识点，重点看Transformer和大模型优化（之前没接触过）
后4天：每天2套模拟题，整理错题和盲区

考试策略：

选择题40分钟做完，正确率约85%（127分）
编程题第一题25分钟AC（150分）
编程题第二题是一个优化问题，实现了基础版本，通过了40%测试用例（33分）
最终得分：310分

经验总结：

✅ 有基础的同学重点突破Transformer，这部分分值很高
✅ 编程题第二题即使做不完，也要写部分解法拿部分分
✅ Python的NumPy要熟练，能大大提升编程效率
✅ 考试时先做会的，把能拿的分都拿到

🎓 经验3：冲高分失败的教训（260分）

背景：有较好基础，备考2周，目标350+

失败原因：

❌ 在编程题第二题上花了太多时间（70分钟），最后还是只通过了一半测试用例
❌ 选择题做得太快，有几道会做的题粗心做错了
❌ 没有严格按照时间分配，导致心态崩了

教训总结：

⚠️ 不要贪心，编程题第二题如果短时间没思路，先做部分分
⚠️ 选择题即使简单也要仔细，别送分
⚠️ 严格执行时间管理，用手表或计时器
⚠️ 考前模拟一定要计时，培养时间感

🎓 经验4：二战成功经验（一战160，二战280）

一战失败原因：

ACM输入输出不熟练，编程题第一题调试了40分钟才通过
Transformer相关的选择题几乎全错
心态崩了，后半场发挥失常

二战准备：

针对性训练：ACM输入输出练了50道题，闭眼能写
重点突破：Transformer知识点整理了10页笔记，反复背
心态调整：告诉自己180分及格就够，不给自己太大压力

二战考试：

心态平稳，按部就班
选择题稳定发挥，约115分
编程题第一题25分钟AC（150分）
编程题第二题拿了15分部分分
最终得分：280分

感悟：

✅ 找到自己的薄弱点，针对性训练
✅ 一战失败不可怕，总结经验再战
✅ 心态真的很重要，别给自己太大压力
✅ 基础题一定要拿稳，别想着拿满分

常见问题FAQ

Q1：考试可以用什么编程语言？

A：Python、Java、C++都可以。强烈推荐Python，因为：

NumPy库功能强大，很多矩阵运算一行代码搞定
语法简洁，代码量少，写得快
大部分考生用Python，网上资料多

Q2：考试能查资料吗？

A：不能。考试全程监控，禁止切屏，禁止查百度/Google。但可以：

使用本地IDE（VSCode、PyCharm等）
查看自己提前准备的本地文件（代码模板、笔记等）
所以要提前准备好所有模板和速查表

Q3：ACM模式是什么？

A：需要自己处理输入输出，不像LeetCode那样给你函数签名。

# 典型的ACM输入输出
# 输入：第一行n，第二行n个数字
n = int(input())
nums = list(map(int, input().split()))

# 处理逻辑
result = sum(nums)

# 输出
print(result)

Q4：180分及格难吗？

A：不难！只要认真准备1-2周，通过率很高。策略：

选择题拿80分（20道对11道，正确率55%）
编程题第一题拿100分（不要求AC，80%测试用例即可）
编程题第二题0分（直接放弃）
合计180分，及格！

Q5：选择题来不及怎么办？

A：

不会的直接跳过，先做会的
40-50分钟必须完成选择题，不能拖
实在不会就蒙，有25%的概率（4选1）
千万别在选择题上耗太久，编程题更重要

Q6：编程题第一题多久能做完？

A：

水平好：20-30分钟AC
一般水平：30-40分钟AC
如果40分钟还没AC，检查一下ACM输入输出是否有问题
超过50分钟还没做出来，考虑先放弃，做第二题拿部分分

Q7：编程题第二题要不要做？

A：分情况：

如果前面做得很快（选择题+第一题共80分钟内完成），可以尝试第二题
如果第二题10分钟内有思路，就做；没思路就写暴力解法拿部分分
如果目标只是及格（180分），可以直接放弃第二题
记住：第二题0分也能过，不要有心理压力

Q8：考试会原题吗？

A：

选择题：很少原题，但知识点重复率高（如Transformer、KV Cache几乎必考）
编程题：基本不会原题，但题型相似（如第一题高频考逻辑回归、KNN）
所以不要指望原题，要真正理解知识点

Q9：考试时紧张怎么办？

A：

考前：多做几套完整模拟题（计时），习惯考试节奏
考试开始：深呼吸3次，告诉自己”我准备充分了”
做题时：专注当前题目，不要想太多
卡住时：跳过，先做后面的，别死磕
记住：180分就够，不需要拿满分

Q10：NumPy不熟练怎么办？

A：

必须掌握的操作（花2小时练习）：
- 数组创建：np.array(), np.zeros(), np.ones()
- 数组运算：加减乘除、点积np.dot()、矩阵乘法@
- 统计函数：np.mean(), np.std(), np.sum()
- 索引切片：a[1:3], a[:, 0], 布尔索引
- 形状操作：reshape(), transpose()
准备速查表：把常用函数写在本地文件，考试时随时查

Q11：考试时间不够怎么办？

A：时间分配建议（总共150分钟）：

选择题：40-50分钟（平均每题2-2.5分钟）
编程题第一题：30-40分钟
编程题第二题：60-70分钟（如果做）
检查：10分钟

如果还是不够：

放弃编程题第二题，专注把前面做对
选择题不会的直接蒙，不要纠结
提前准备好代码模板，考试时直接复制粘贴

Q12：考试设备要求是什么？

A：双机位要求：

主机位：电脑摄像头，拍摄正面（脸部+屏幕）
副机位：手机支架，拍摄侧面（键盘+手部+屏幕）
两个机位都要开启，全程录制
建议提前调试好角度

电脑要求：

Windows/Mac/Linux都可以
Chrome浏览器（最新版）
网络稳定（建议有线网络）
可以使用本地IDE

环境要求：

独立安静的房间
光线充足
桌面整洁（不要有书籍、笔记等）

Q13：可以用本地IDE吗？

A：可以！ 这是很大的优势。

可以用VSCode、PyCharm、Jupyter等任何本地IDE
在IDE里写好代码，再复制到考试平台提交
可以使用IDE的代码补全、语法检查功能
注意：不能联网查资料，但可以查看本地文件

建议：

提前在本地准备好代码模板文件
考试时在IDE里写代码，在浏览器里提交
熟练掌握IDE的快捷键，提高效率

Q14：如何准备代码模板？

A：在本地准备一个templates.py文件，包含所有常用代码：

# ========== ACM输入输出模板 ==========
# 单行输入
n = int(input())

# 多个数字输入
a, b = map(int, input().split())

# 列表输入
nums = list(map(int, input().split()))

# 多行输入
lines = []
for _ in range(n):
    lines.append(input())

# ========== 数学函数 ==========
import numpy as np

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def relu(x):
    return np.maximum(0, x)

# ========== 数据预处理 ==========
def z_score_norm(X):
    mean = np.mean(X, axis=0)
    std = np.std(X, axis=0)
    std[std == 0] = 1
    return (X - mean) / std

def min_max_norm(X):
    min_val = np.min(X, axis=0)
    max_val = np.max(X, axis=0)
    range_val = max_val - min_val
    range_val[range_val == 0] = 1
    return (X - min_val) / range_val

# ========== 相似度计算 ==========
def cosine_similarity(vec1, vec2):
    return np.dot(vec1, vec2) / (np.linalg.norm(vec1) * np.linalg.norm(vec2))

# ========== 线性回归 ==========
def linear_regression(X, y, lr=0.01, epochs=1000):
    w = np.zeros(X.shape[1])
    b = 0
    for _ in range(epochs):
        y_pred = np.dot(X, w) + b
        dw = (2/len(X)) * np.dot(X.T, (y_pred - y))
        db = (2/len(X)) * np.sum(y_pred - y)
        w -= lr * dw
        b -= lr * db
    return w, b

# ========== KNN ==========
def knn_predict(X_train, y_train, X_test, k=3):
    predictions = []
    for test_point in X_test:
        distances = [np.linalg.norm(test_point - train_point) 
                     for train_point in X_train]
        k_indices = np.argsort(distances)[:k]
        k_labels = y_train[k_indices]
        predictions.append(np.bincount(k_labels).argmax())
    return np.array(predictions)

Q15：考试会检测代码相似度吗？

A：不会。华为AI机试主要看结果是否正确，不检测代码相似度。

可以使用标准的算法实现
可以使用NumPy等库函数
重点是能AC（通过所有测试用例）
代码风格、变量命名不重要

Q16：Python版本要求？

A：一般是Python 3.7+，常见库都支持：

NumPy, Pandas, SciPy
Math, Collections, Itertools等标准库
不支持：TensorFlow, PyTorch, Scikit-learn（考试就是要你手写算法）

Q17：选择题有多少道关于Transformer？

A：6-8道，占选择题的30-40%，超高频！

Multi-Head Attention原理
KV Cache计算
位置编码
量化技术
LoRA原理
时间复杂度计算
LayerNorm vs BatchNorm

备考策略：Transformer是重中之重，必须吃透！

Q18：编程题第一题一般考什么？

A：高频题型排序（按出现频率）：

KNN分类器（最高频，约25%）
数据预处理（标准化/归一化/缺失值填充，约20%）
相似度计算（余弦相似度/TF-IDF，约20%）
线性回归/逻辑回归（约15%）
神经网络前向传播（约10%）
其他（决策树、评估指标计算等，约10%）

备考重点：前4种题型必须闭眼能写！

Q19：如果考试中途网络断了怎么办？

A：

不要慌，立即重新连接
考试平台一般会保存你的答题进度
如果无法恢复，联系监考老师
平台会根据录像判断是否给你补时
预防：考试前检查网络，尽量用有线网络

Q20：考完多久出结果？

A：

一般2-5个工作日
通过会收到HR电话或邮件，邀请技术面试
没通过一般不会通知（也有例外）
如果7天还没消息，基本是没过

Q21：没过可以再考吗？

A：

同一个岗位一般半年后才能再申请
但可以申请其他部门的岗位（立即可以）
建议：总结经验，准备充分再战

Q22：考试可以带草稿纸吗？

A：可以！

可以在纸上列公式、画图、演算
但不能带任何有字的资料（笔记、书籍等）
草稿纸会被摄像头拍到，不能作弊

Q23：培训班有必要上吗？

A：不必要。

华为AI机试不难，自学完全可以
网上免费资源很多（牛客网、GitHub）
这份备考计划已经很全面了
省下培训费买点好吃的犒劳自己

Q24：刷多少题才能过？

A：质量比数量重要。

选择题：300-500道（覆盖所有知识点）
编程题：30-50道（重点是把常见题型练熟）
模拟题：至少5套完整模拟（计时）

不要盲目刷题：

做错的题要整理，理解为什么错
同类型的题做几道就够，不要重复刷
重点是掌握知识点，不是背题

Q25：考前一晚应该做什么？

A：

✅ 快速过一遍笔记（不学新东西）
✅ 准备好考试设备（电脑、手机、充电器）
✅ 调试双机位
✅ 准备好本地代码模板
✅ 早睡！！！（10点半前睡觉）
❌ 不要熬夜刷题
❌ 不要喝咖啡或浓茶（影响睡眠）

心理调节与备考心态

💪 备考期间心态管理

常见心理问题及应对

问题1：觉得时间不够，很焦虑

认知调整：180分及格真的不难，很多人1-2周就过了
行动建议：
- 制定切实可行的计划，不要贪多
- 每天完成小目标，积累成就感
- 专注当下，不要总想”还有多少没学”
心理暗示：”我每天都在进步，及格问题不大”

问题2：知识点太多，记不住

认知调整：不需要全记住，抓重点就够
行动建议：
- 使用思维导图整理知识结构
- 重点记Transformer、数据预处理、KNN等高频考点
- 编程题重点练常见题型，不求全面
- 利用艾宾浩斯遗忘曲线，定期复习
记忆技巧：
- 激活函数：画图记忆（看曲线形状）
- 公式：理解推导过程，而不是死记
- 代码：手写5遍，肌肉记忆

问题3：刷题错误率高，怀疑自己

认知调整：刷题初期错很多是正常的，这就是学习的过程
行动建议：
- 错题是最好的老师，每道错题都要弄懂
- 记录错题率的变化，看到自己的进步
- 和其他考生交流，发现大家都会错
数据支持：
- 第一周选择题正确率40-50%是正常的
- 第二周能提升到60-70%
- 考前能稳定在75%+就很好了

问题4：考前一周突然很慌

认知调整：这是正常的考前焦虑，每个人都会有
行动建议：
- 做几套完整模拟题，找找感觉
- 确认自己已经掌握的内容（列清单）
- 和考友聊天，互相打气
- 适当运动（跑步、散步），释放压力
心理暗示：”我已经准备充分了，正常发挥就能过”

问题5：看到别人进度快，压力大

认知调整：每个人基础不同，不要盲目比较
行动建议：
- 专注自己的进度，不要被别人影响
- 记住：考试是和自己比，不是和别人比
- 180分及格，不需要比别人强
心理暗示：”我按照自己的节奏来，稳扎稳打”

保持动力的方法

🎯 目标可视化

制作进度表，每天打卡
把”通过华为AI机试”写在显眼的地方
想象通过后的喜悦和拿到offer的场景

🏆 奖励机制

完成一周学习：吃顿好的、看部电影
完成一套模拟题：玩1小时游戏
每天完成任务：奖励自己喜欢的零食

👥 寻找考友

加入备考群，互相监督
和考友分享进度和心得
一起讨论难题，共同进步

📈 记录进步

记录每天的学习时长
记录选择题正确率的变化
记录手写算法的速度提升
定期回顾，看到自己的成长

备考期间作息建议

学习日作息表（以1个月版为例）

07:00 - 08:00  起床、早餐、晨间复习
08:30 - 12:00  上午学习时段（理论学习）
12:00 - 14:00  午餐、午休
14:00 - 18:00  下午学习时段（代码实践）
18:00 - 19:00  晚餐、散步放松
19:00 - 22:00  晚间学习时段（刷题）
22:00 - 23:00  洗漱、放松、回顾今日
23:00         睡觉

注意事项：

✅ 每学习50分钟休息10分钟（番茄工作法）
✅ 保证每天7-8小时睡眠
✅ 适当运动（每天30分钟）
✅ 饮食规律，不要暴饮暴食
❌ 不要熬夜（效率低且伤身体）
❌ 不要久坐不动（伤颈椎和眼睛）

周末作息调整：

可以稍微睡晚一点（8点起床）
增加户外活动时间（2-3小时）
安排一些娱乐活动（看电影、聚餐）
不要完全放松，保持学习节奏

如何克服拖延症

策略1：5分钟启动法

告诉自己”我只学5分钟”
往往一旦开始，就能持续下去
降低启动阻力是关键

策略2：任务分解

把”学习Transformer”分解为：
- 看10分钟视频
- 整理3个知识点
- 手写1个代码
每个小任务只需15-30分钟

策略3：环境塑造

学习时手机静音、放远处
关闭所有娱乐网站
营造专注的学习氛围

策略4：同伴监督

和考友约定每天汇报进度
在备考群里打卡
互相督促，共同进步

🧘 考前3天心理调节

Day -3：平常心

不要再学新知识，只复习已掌握的内容
告诉自己”我已经准备充分了”
适当运动，释放紧张情绪
和家人朋友聊天，转移注意力

Day -2：建立信心

回顾自己的进步（对比第一天和现在）
看看自己整理的笔记和代码
做1-2套模拟题，找找感觉（不要太在意分数）
想象考试顺利的场景

Day -1：放松休息

上午：快速过一遍笔记
下午：准备考试设备，调试环境
晚上：看部轻松的电影或综艺
22:30前睡觉（重要！）

考试当天：

考前1小时：

吃点东西垫底（不要吃太饱）
上厕所
深呼吸5次，放松身心
打开本地代码模板，准备好

考试开始：

深呼吸3次：”我准备好了”
快速浏览所有题目，心里有数
按照时间分配执行，不要乱
专注当前题目，不要分心

遇到困难时：

卡住了：跳过，先做后面的
紧张了：深呼吸，喝口水
慌了：告诉自己”180分就够”
想放弃：想想自己准备了这么久

🎯 考试心态黄金法则

目标清晰：180分及格，不求满分
策略优先：先做会的，后做难的
时间管理：严格按照时间分配
不要纠结：不会的题果断跳过
相信自己：准备充分了，正常发挥就能过
心态平和：一次没过还能再考
享受过程：把考试当成展示学习成果的机会

考前准备清单

📋 考前1周准备清单

技术准备

完成至少5套完整模拟题（计时）
整理高频错题（选择题50道+编程题10道）
手写常见算法（KNN、线性回归、数据预处理等）
熟练ACM输入输出（闭眼能写）
复习Transformer所有知识点
准备本地代码模板文件
准备NumPy速查表

设备准备

确认电脑性能良好（不会卡顿）
安装并测试Chrome浏览器（最新版）
安装并配置好本地IDE（VSCode/PyCharm）
测试摄像头和麦克风
准备手机支架（副机位）
确保网络稳定（测速，最好有线网络）
准备充电器和电源线

环境准备

找一个独立安静的房间
清理桌面（不要有书籍、笔记等）
调整光线（确保摄像头能清晰拍到脸）
准备手表或计时器
准备草稿纸和笔
准备一杯水

📋 考前1天准备清单

复习确认

快速过一遍所有笔记（2-3小时）
看一遍高频考点清单
做1套模拟题（找找手感）
确认代码模板都准备好了

设备测试

测试双机位角度（能同时拍到脸、手、屏幕）
测试网络（打开考试平台，确认能正常访问）
测试本地IDE（新建文件，运行Python代码）
确认电脑电量充足或插上电源

物品准备

身份证（可能需要验证）
手表（计时用）
草稿纸、笔
水杯
纸巾
充电器

身体准备

吃营养丰富的晚餐
不喝咖啡或浓茶
22:30前睡觉
设置闹钟（考前2小时起床）

📋 考试当天清单（考前2小时）

起床后

洗漱、整理仪容（摄像头会拍到）
吃早餐/午餐（不要太饱，不要吃容易拉肚子的）
上厕所

考前1小时

再次测试双机位
登录考试平台，确认能进入
打开本地IDE，打开代码模板文件
打开NumPy速查表
关闭所有无关网页和软件
手机静音（但要开摄像头）

考前30分钟

深呼吸，放松心情
快速过一遍高频公式（激活函数、损失函数等）
准备好草稿纸和笔
确认网络正常
再次上厕所

考前10分钟

坐在考试位置上，调整坐姿
确认双机位角度正确
深呼吸5次，告诉自己”我准备好了”
手放在键盘上，准备开始

📋 考试中检查清单

每道题提交前

检查ACM输入输出格式是否正确
检查是否有语法错误
检查边界条件（空数组、单个元素等）
用样例数据测试一遍
确认输出格式符合要求

时间节点检查

40分钟时：选择题是否做完？没做完赶紧加速
80分钟时：第一题是否AC？没AC考虑放弃第二题
120分钟时：第二题做到哪了？还剩30分钟
140分钟时：检查所有题目，确认都提交了

提交前最后检查

所有题目都提交了吗？
选择题有没有漏做的？
编程题输出格式正确吗？
还有时间，可以再优化一下代码

📋 考试后清单

立即做

保存考试录像（可能需要手动上传）
记录考试内容（题型、知识点）
记录自己的答案和思路
估算自己的分数

1小时后

放松！考完就不要再想了
吃顿好的，奖励自己
和家人朋友聊聊天
做点喜欢的事情

等待结果期间

2-3天：耐心等待，不要焦虑
如果通过：准备技术面试
如果没过：总结经验，准备二战
关注华为招聘公众号/邮箱

高频考点速查表（考前必看）

🔥 激活函数速查

激活函数	公式	取值范围	优点	缺点	应用
ReLU	max(0,x)	[0,+∞)	计算快、缓解梯度消失	Dead ReLU	CNN中间层
Sigmoid	1/(1+e^-x)	(0,1)	输出可解释为概率	梯度消失严重	二分类输出层
Tanh	(e^x-e^-x)/(e^x+e^-x)	(-1,1)	零中心化	梯度消失	RNN
GELU	x*Φ(x)	(-∞,+∞)	平滑、性能好	计算稍慢	Transformer
LeakyReLU	max(αx,x)	(-∞,+∞)	解决Dead ReLU	需要调α	GAN
Swish/SiLU	x*sigmoid(x)	(-∞,+∞)	平滑、非单调	计算慢	EfficientNet

🔥 损失函数速查

损失函数	公式	应用场景	特点
MSE	(1/n)Σ(y_pred-y)²	回归	对异常值敏感
MAE	(1/n)Σ\|y_pred-y\|	回归	对异常值不敏感
Cross-Entropy	-Σy*log(p)	分类	梯度稳定
Hinge Loss	max(0,1-y*f(x))	SVM	最大间隔
Focal Loss	-α(1-p)^γ*log(p)	目标检测	解决类别不平衡

🔥 优化器速查

优化器	特点	学习率	应用场景
SGD	简单、通用	需手动调整	传统任务
Momentum	加速收敛	需手动调整	训练加速
Adam	自适应、收敛快	默认1e-3	最常用
AdamW	Adam+权重衰减	默认1e-3	Transformer训练

🔥 Transformer核心公式

Self-Attention：

1 2	`Q = XW_q, K = XW_k, V = XW_v Attention(Q,K,V) = softmax(QK^T / sqrt(d_k)) * V`

Multi-Head Attention：

1 2	`MultiHead(Q,K,V) = Concat(head_1,...,head_h)W_o head_i = Attention(QW_qi, KW_ki, VW_vi)`

位置编码：

1 2	`PE(pos, 2i) = sin(pos / 10000^(2i/d_model)) PE(pos, 2i+1) = cos(pos / 10000^(2i/d_model))`

时间复杂度：O(n²d)

KV Cache显存：2 * n_layers * batch_size * seq_len * d_model * 2字节

🔥 评估指标速查

分类：

Accuracy = (TP+TN) / (TP+TN+FP+FN)
Precision = TP / (TP+FP)
Recall = TP / (TP+FN)
F1 = 2PR / (P+R)

回归：

MAE = (1/n)Σ|y_pred-y|
MSE = (1/n)Σ(y_pred-y)²
RMSE = sqrt(MSE)
R² = 1 - SS_res/SS_tot

🔥 距离/相似度速查

欧式距离：sqrt(Σ(a_i-b_i)²)
曼哈顿距离：Σ|a_i-b_i|
余弦相似度：(A·B) / (||A||*||B||)
Jaccard相似度：|A∩B| / |A∪B|

🔥 数据预处理速查

标准化（Z-score）：x’ = (x-μ)/σ

结果：均值0，标准差1
应用：线性模型、SVM

归一化（Min-Max）：x’ = (x-min)/(max-min)

结果：[0,1]
应用：神经网络、图像

缺失值填充：

均值：正态分布数据
中位数：有异常值
众数：类别型数据

备考资源推荐

📚 学习资料

视频课程：

吴恩达机器学习（Coursera）- 经典入门课程
李宏毅深度学习（B站）- 讲解生动，适合华为备考
跟李沐学AI（B站）- Transformer讲得很透彻

在线刷题：

牛客网 - 华为AI机试专项练习
LeetCode - 编程基础（虽然格式不同，但锻炼算法思维）
Kaggle - 实战数据处理

电子书/文档：

《统计学习方法》- 李航 - 传统机器学习圣经
《动手学深度学习》- 李沐 - 代码实现很详细
Attention Is All You Need - Transformer原论文（必读）

🔧 工具推荐

IDE：

VSCode（轻量、插件丰富）
PyCharm（功能强大）
Jupyter Notebook（适合调试）

笔记工具：

Notion（结构化笔记）
Obsidian（知识图谱）
OneNote（手写+文字）

刷题辅助：

Anki（记忆卡片，复习高频考点）
XMind（思维导图，梳理知识结构）
Stopwatch（计时器，模拟考试）

👥 社群资源

推荐加入：

牛客网华为AI机试讨论区
GitHub上的备考仓库
知乎”华为AI机试”话题

注意事项：

不要完全依赖别人的答案，要自己思考
看到不同的解法，要理解为什么
和考友互相鼓励，不要比较焦虑

最后的叮嘱

给所有备考同学的话

亲爱的考友们：

看到这里，说明你已经认真阅读了整份备考计划。首先要给你点赞！很多人连完整的计划都没看完，你已经超越了大部分人。

关于备考：

华为AI机试真的不难，180分及格线是很容易达到的。我见过太多零基础的同学，准备2周就顺利通过了。关键是：

策略要正确（抓重点，不贪多）
执行要到位（计划要落实，不能只是看看）
心态要稳定（及格就够，不求满分）

关于心态：

备考过程中，你可能会遇到：

知识点记不住 → 很正常，多复习几遍就好
题目做不出来 → 很正常，慢慢就会了
感觉时间不够 → 很正常，抓紧时间就好
考前很紧张 → 很正常，每个人都这样

记住：焦虑解决不了问题，行动才能。遇到困难时，不要想太多，先开始做，做着做着就有感觉了。

关于考试：

考试时，记住这几点：

时间管理最重要：严格按照40分钟选择题、40分钟第一题、60分钟第二题的节奏
不要纠结难题：不会就跳过，不要浪费时间
相信自己的准备：你准备了这么久，一定能过
保持平常心：就是一场考试而已，一次不过还能再来

关于未来：

无论这次考试结果如何，记住：

通过了，恭喜你，准备好技术面试
没过，不要气馁，总结经验再战
这只是人生中的一个小坎，不要看得太重
学到的知识是自己的，不会浪费

最后：

祝你考试顺利，成功拿到offer！

加油，未来的华为人！💪

版本更新记录

v3.0 (2026-09-01)

新增：考前3天冲刺版计划
新增：心理调节与备考心态章节
新增：考前准备清单（详细到每个时间点）
新增：高频考点速查表
新增：25个常见问题FAQ
扩充：真实考生经验分享（4个案例）
扩充：每日打卡清单（可打印版）
优化：所有备考计划的时间安排更详细

v2.0 (2026-08-25)

新增：1个月、2周、1周三版本计划
新增：核心知识点清单（超详细）
新增：编程题必练代码
新增：每日学习打卡表

v1.0 (2026-08-20)

初始版本

文档作者：华为AI机试备考小组
最后更新：2026年9月1日
文档字数：约40,000字
预计阅读时间：90分钟

声明：本文档所有内容均来自真实考生经验总结，仅供备考参考。考试内容以华为官方为准。

如果这份备考计划对你有帮助，请分享给其他需要的考友！

一起加油，祝大家都能顺利通过！🎉

如果时间不够：

优先保证选择题和第一题完成
第二题写暴力解法拿部分分
不要在一道题上卡太久

Q12：考试环境怎么准备？

A：

双机位摄像头：一个拍正面，一个拍侧面（手机支架准备好）
浏览器：Chrome浏览器，提前更新到最新版
本地IDE：VSCode或PyCharm，提前配置好Python环境
关闭所有弹窗软件：微信、QQ、邮箱通知等
网络稳定：有线网优于WiFi
准备纸笔：草稿纸、笔（计算、画图用）

Q13：考试可以用本地IDE吗？

A：可以！而且强烈建议用：

本地IDE有代码补全、语法检查，效率更高
写完后复制粘贴到网页提交即可
提前准备好代码模板文件，考试时直接复制

Q14：提前多久开始准备？

A：

零基础：至少2周，推荐1个月
有基础：1-2周
强化冲刺：3-7天
临时抱佛脚：3天（只求及格）
不建议裸考：通过率不到20%

Q15：需要买课程吗？

A：不需要！免费资源足够：

吴恩达机器学习课程（Coursera，免费旁听）
B站搜”华为AI机试”有很多经验分享
牛客网有很多真题和讨论
GitHub上有开源的备考资料
本文档已经包含了核心知识点

心理调节指南

备考阶段心理调节

🌟 刚开始准备（第1-3天）

常见心态：

“知识点好多，根本学不完”
“看不懂怎么办”
“我能考过吗”

调节方法：
✅ 接受现状：每个人开始都觉得难，这很正常
✅ 分解目标：不要想着全部学完，先完成今天的计划
✅ 相信过程：只要每天进步一点点，积累起来就很多
✅ 看成功案例：很多零基础的人都过了，你也可以！

心理暗示：

“我不需要考满分，180分就够了”
“我只要把编程题第一题练熟，就成功一半了”
“今天比昨天进步一点点，就是胜利”

🌟 备考中期（第4-10天）

常见心态：

“刷题正确率不高，好挫败”
“编程题写得好慢”
“感觉什么都记不住”

调节方法：
✅ 关注进步而非完美：对比自己昨天的正确率，而不是和别人比
✅ 整理错题：错题是进步的阶梯，每个错题都是学习机会
✅ 适当休息：累了就休息，劳逸结合效率更高
✅ 和考友交流：加个备考群，互相鼓励

心理暗示：

“错题很正常，关键是要搞懂”
“我的正确率在稳步提升”
“熟能生巧，多练几遍就快了”

🌟 冲刺阶段（考前3-5天）

常见心态：

“还有好多没复习到”
“万一考到不会的怎么办”
“紧张，睡不着”

调节方法：
✅ 停止学新知识：这时候学新的容易慌，重点复习已掌握的
✅ 做模拟题找信心：做几套模拟题，确认自己能及格
✅ 准备Plan B：告诉自己”大不了二战，没什么大不了”
✅ 放松运动：散步、听音乐、做运动，别一直学习

心理暗示：

“我已经准备得很充分了”
“考试只是检验，不是决定我的全部”
“180分及格并不难，我可以的”

考试当天心理调节

🎯 考前1小时

要做的：

上个厕所
喝点水（别喝太多，考试中途不能上厕所）
深呼吸5次，放松肩膀
看一眼代码模板，找找感觉（不要学新东西）
告诉自己：”我准备好了！”

不要做的：

❌ 不要再刷题了（容易慌）
❌ 不要和别人讨论题目（容易被影响）
❌ 不要喝咖啡（容易手抖、上厕所）
❌ 不要熬夜（保持清醒头脑）

🎯 考试进行中

遇到不会的题：

“跳过，先做后面的”
“不会很正常，不影响及格”
“把会做的都做对，就够了”

时间紧张时：

“深呼吸，别慌”
“先保证做完的题都对”
“部分分也是分”

做错题了：

“一题而已，不影响大局”
“专注下一题”
“不要回想，往前看”

做得很顺：

“保持状态，稳住”
“仔细检查，别大意”
“考完再高兴，现在专注”

考后心理调节

✅ 考得还可以

不要放松警惕，等出成绩再庆祝
总结经验，帮助其他考友

❌ 考得不好

接受结果：一次失败不代表能力不行
总结经验：哪里做得不好？ACM输入输出？时间管理？知识点？
准备二战：很多人二战都过了，你也可以！
调整心态：这只是一场考试，不是人生的全部

记住：

华为AI机试只是求职路上的一个小关卡
过了固然好，没过也可以准备其他公司
保持学习的热情和成长的心态，比一次考试重要得多

考前一天准备清单（详细版）

✅ 设备与环境准备（务必提前测试）

双机位摄像头：

主机位：笔记本摄像头或外接摄像头（拍正面）
副机位：手机摄像头（拍侧面和手部）
- 手机支架准备好
- 手机充满电或插着充电器
- 测试副机位摄像头角度（能拍到手和键盘）
进入考试系统测试摄像头是否正常识别
确保摄像头清晰，光线充足

电脑与软件：

Chrome浏览器更新到最新版
关闭所有不相关软件（微信、QQ、邮箱、杀毒软件弹窗）
关闭所有浏览器插件（除非考试必须）
本地IDE准备好（VSCode/PyCharm），测试能否正常运行Python

Python环境检查：NumPy库是否已安装

1	`python -c "import numpy; print(numpy.__version__)"`

网络准备：

有线网优于WiFi（更稳定）
测试网速（至少10Mbps）
确保考试期间不会有人断网或占用带宽
准备手机热点作为备用网络

考试环境：

安静的独立房间（家人不会打扰）
书桌整理干净（只留纸笔、水杯、电脑）
光线充足（别背光）
门贴上”考试中，请勿打扰”的纸条

✅ 代码模板与资料准备

本地文件准备（放在桌面，方便考试时打开）：

ACM输入输出模板（10种常见格式）
线性回归、逻辑回归、KNN代码模板
数据预处理函数（标准化、归一化、缺失值填充）
余弦相似度、TF-IDF计算模板
NumPy常用函数速查表
常见错误调试Checklist

文件命名建议：

华为AI机试_ACM模板.py
华为AI机试_算法模板.py
华为AI机试_NumPy速查.txt
华为AI机试_调试清单.txt

✅ 知识点最后复习（不要学新的）

快速过一遍（每项5-10分钟）：

激活函数（ReLU、Sigmoid、GELU）的性质
Transformer核心概念（Multi-Head Attention、KV Cache）
损失函数、优化器对比表
数据标准化 vs 归一化
评估指标（Precision、Recall、F1）

不要做的：

❌ 不要学新知识点
❌ 不要刷新题
❌ 不要看太难的内容

✅ 物品准备

纸笔（草稿纸、计算器禁止）
水杯（喝水不要太多）
纸巾
手表或计时器（监控答题时间）
身份证、准考证（如果需要）
备用手机（作为热点）

✅ 生理与心理准备

作息：

提前1小时睡觉（保证8小时睡眠）
不要熬夜复习
考前一天不要剧烈运动

饮食：

吃清淡食物，别吃坏肚子
考前2小时不要喝太多水（考试中途不能上厕所）
不要喝咖啡或浓茶（容易紧张、手抖）

心态：

告诉自己：”我准备充分了”
深呼吸练习5分钟
想象考试顺利的场景
准备Plan B：”大不了二战，没什么大不了的”

考试当天流程详细指南

📍 考前30分钟

时间点：考试前30分钟（如19:00考试，18:30开始）

要做的事情：

上厕所（重要！考试中途不能去）
再次测试摄像头（主机位+副机位）
打开本地IDE，新建一个测试文件，跑一段简单代码（确保环境正常）
1
2
import numpy as np print("环境正常")
打开代码模板文件（放在旁边，随时复制）
关闭所有不相关的软件和浏览器标签页
调整座椅高度和摄像头角度
深呼吸3次，放松肩膀
准备好水杯、纸笔

📍 考试开始（0-5分钟）

时间点：19:00-19:05

要做的事情：

进入考试系统，确认页面加载正常
仔细阅读考试说明（时长、题型、注意事项）
测试提交功能（有的平台允许测试提交）
快速浏览所有题目（选择题20道，编程题2道）
心理暗示：”稳住，按计划来”

心态调整：

如果看到熟悉的题型 → “太好了，稳了”
如果看到陌生的题目 → “没关系,先做会的”

📍 选择题阶段（5-45分钟）

时间点：19:05-19:45（目标40分钟完成）

答题策略：

快速过一遍（5分钟）：
- 标记出一眼就会的题（做记号）
- 标记出不会的题（先跳过）
先做会做的（20分钟）：
- 把所有会做的题都做完
- 仔细审题，别粗心
- 选完后检查一遍选项（有没有点错）
处理不确定的题（10分钟）：
- 用排除法
- 回忆相关知识点
- 实在不行就蒙（4选1有25%概率）
检查（5分钟）：
- 快速过一遍所有题
- 确保没有漏题
- 确保所有题都选了答案

时间提醒：

19:25（20分钟时）：应该完成至少15道题
19:35（30分钟时）：应该完成至少18道题
19:45（40分钟时）：必须完成所有选择题

心态调整：

如果有不会的 → “正常，不会的就蒙，把会的做对就够了”
如果时间紧张 → “剩下的直接蒙，不要耽误编程题”

📍 编程题第一题（45-85分钟）

时间点：19:45-20:25（目标30-40分钟AC）

做题流程：

1. 读题（3分钟）：

仔细读题，理解题意
找出输入输出格式
找出数据范围（n的大小）
找出核心算法（线性回归？KNN？数据处理？）
在纸上写下关键信息

2. 设计算法（2分钟）：

确定用什么算法
确定数据结构
估算时间复杂度（会不会超时）
在纸上画出流程图或伪代码

3. 编写代码（15-20分钟）：

先写ACM输入输出框架

# 读取输入
n = int(input())
# ...

# 处理逻辑
result = solve()

# 输出结果
print(result)

从模板文件复制算法代码（如果有现成的）
填充核心逻辑
边写边注释（方便自己理解）

4. 本地测试（5-10分钟）：

用样例输入测试
自己构造测试用例（边界情况）
- 最小输入（如n=1）
- 最大输入（如n=10000）
- 特殊情况（如全0、全1、负数）
检查输出格式是否正确（有没有多余空格、换行）

5. 提交与调试（5-10分钟）：

复制代码到网页提交
查看测试结果
如果AC → 太好了！进入第二题
如果部分通过：
- 看是哪些测试用例没过
- 可能是边界情况、数据类型、超时等问题
- 修改后再提交
如果全部不过：
- 检查ACM输入输出格式
- 检查算法逻辑
- 用样例测试本地代码

时间提醒：

20:00（15分钟时）：应该已经写完代码，开始测试
20:15（30分钟时）：应该已经提交并得到结果
20:25（40分钟时）：如果还没AC，考虑是否继续调试还是先做第二题

心态调整：

如果顺利AC → “太好了！第二题稳一点就能过”
如果卡住了 → “先跳到第二题，说不定第二题简单”
如果调试很久 → “别慌，确保输入输出格式正确”

📍 编程题第二题（85-145分钟）

时间点：20:25-21:25（60分钟）

策略分级：

如果目标是及格（180分）：

选择题80分 + 第一题100-150分 = 180-230分
第二题可以直接放弃，或者花10分钟写个暴力解法拿10-20分

如果目标是稳健通过（250分以上）：

必须拿第二题的部分分（至少50分）

做题流程：

1. 读题+判断难度（5分钟）：

仔细读题
判断是什么类型（优化问题？复杂算法？数据处理？）
评估自己有没有思路
- 有思路 → 继续做
- 没思路 → 写暴力解法或放弃

2. 实现基础版本（30-40分钟）：

先实现一个最简单的版本（即使会超时）
确保逻辑正确
通过样例测试

3. 优化（10-20分钟）：

分析哪里可以优化（时间复杂度？空间复杂度？）
实施优化方案
再次测试

4. 提交（5分钟）：

提交代码
查看能通过多少测试用例
如果只通过30-50%，也是胜利！（有部分分）

时间提醒：

20:40（15分钟时）：应该有初步思路，开始写代码
21:00（35分钟时）：应该完成基础版本，开始优化
21:15（50分钟时）：准备提交
21:25（60分钟时）：必须提交，进入检查阶段

心态调整：

如果做出来了 → “太棒了！”
如果只通过部分用例 → “有部分分就够了”
如果完全没思路 → “没关系，前面已经够分了”

📍 最后检查阶段（145-150分钟）

时间点：21:25-21:30（最后5分钟）

检查清单：

确认所有题目都已提交
检查选择题有没有漏选的
检查编程题提交状态（是否显示”已提交”）
如果有时间，快速过一遍选择题（看有没有明显错误）

不要做的：

❌ 不要大改代码（容易出新bug）
❌ 不要纠结某一道题（时间不够）
❌ 不要紧张（已经尽力了）

📍 考试结束后

立即做的：

保存好代码（复制到本地文件）
退出考试系统
放松，深呼吸

不要做的：

❌ 不要马上和别人对答案（容易影响心情）
❌ 不要反复回想错题（已经结束了）
❌ 不要熬夜等成绩（一般几天后才出）

总结经验（考后1-2天）：

哪里做得好？
哪里可以改进？
时间管理是否合理？
知识点有没有盲区？
如果要二战，如何调整策略？

目标分数策略详解

🎯 保底180分方案（及格线）

适用人群：零基础、时间紧张、只求过线

分数构成：

选择题：80分（20道中对11道，正确率55%）
编程题第一题：100分（通过80%测试用例）
编程题第二题：0分（直接放弃）
总分：180分

备考重点：

选择题：
- 重点背高频考点（Transformer、激活函数、优化器）
- 刷题500道以上（不求全懂，记住答案也行）
- 考试策略：会做的认真做，不会的果断蒙
编程题第一题：
- 必须拿下！至少100分
- 熟练掌握：线性回归、逻辑回归、KNN、数据预处理
- ACM输入输出练到闭眼能写
- 考试策略：40分钟内必须提交
编程题第二题：
- 直接放弃，把时间留给前面
- 或者最后10分钟写个暴力解法碰碰运气

时间分配：

选择题：40分钟
编程题第一题：40分钟
编程题第二题：10分钟（写暴力）或0分钟（放弃）
检查：20分钟

心态：

“180分就是胜利，不要贪多”
“把简单的做对，比追求高分重要”

🎯 稳健250分方案（推荐）

适用人群：有一定基础、准备1-2周、求稳通过

分数构成：

选择题：110分（20道中对15道，正确率75%）
编程题第一题：140分（AC或接近AC）
编程题第二题：0-30分（部分分或放弃）
总分：250-280分

备考重点：

选择题：
- 系统学习所有知识点
- 刷题800道以上
- 正确率稳定在70-80%
- 重点突破：Transformer（必考30分以上）
编程题第一题：
- 必须AC或接近AC
- 所有基础算法都要手写3遍以上
- 能在30分钟内完成
- 考试策略：确保拿到140分以上
编程题第二题：
- 先实现基础版本
- 即使超时也能拿部分分
- 目标：30-50分

时间分配：

选择题：45分钟
编程题第一题：35分钟
编程题第二题：60分钟
检查：10分钟

心态：

“目标250分，有容错空间”
“第一题必须拿稳，第二题尽力而为”

🎯 冲刺350分方案（高分目标）

适用人群：基础扎实、想拿高分、冲击优秀

分数构成：

选择题：130分（20道中对17-18道，正确率85-90%）
编程题第一题：150分（AC）
编程题第二题：70-100分（优化后通过大部分用例）
总分：350-380分

备考重点：

选择题：
- 深入理解所有知识点
- 刷题1000道以上
- 正确率稳定在85%以上
- 能做到”看到题就知道考什么”
编程题第一题：
- 必须AC
- 20-25分钟内完成
- 代码简洁高效
编程题第二题：
- 必须有完整思路
- 实现优化算法
- 目标通过70%以上测试用例

时间分配：

选择题：35分钟
编程题第一题：25分钟
编程题第二题：80分钟
检查：10分钟

心态：

“稳中求胜，别因为求快出错”
“第二题是拉分项，但也要确保前面不失分”

刷题资源与网站推荐

📚 官方/准官方资源

牛客网：

华为AI机试专题：有真题和模拟题
讨论区：很多考生分享经验和题解
链接：nowcoder.com

华为云ModelArts：

官方AI开发平台
有免费的AI课程和实验

📚 免费学习资源

机器学习基础：

吴恩达机器学习课程（Coursera，可免费旁听）
李宏毅机器学习课程（B站，中文，讲得很好）
3Blue1Brown神经网络系列（B站，可视化超棒）

深度学习：

李沐《动手学深度学习》（B站配套视频）
Stanford CS231n（卷积神经网络）
Stanford CS224n（NLP）

Transformer专题（重点！）：

Jay Alammar的博客《Illustrated Transformer》
李宏毅Transformer专题讲解
B站搜”Transformer原理”有大量优质视频

编程刷题：

LeetCode：练习算法基础（虽然题型不完全一样）
牛客网：华为AI机试真题
GitHub：搜”华为AI机试”有很多开源资料

📚 推荐书籍（可选）

入门级：

《Python机器学习基础教程》（适合零基础）
《统计学习方法》（李航，偏理论）

进阶级：

《深度学习》（花书，Goodfellow著，比较难）
《动手学深度学习》（李沐，代码+理论）

注意：考试准备时间紧张，不需要把书从头到尾看完，重点看本文档列出的知识点即可。

📚 备考交流群

建议：

加入牛客网、知乎、微信的华为AI机试备考群
和考友互相鼓励、分享资料
看别人的经验贴和踩坑记录

注意：

不要被别人的进度影响心态
不要盲目跟风买课程（免费资源够用）
专注自己的计划

常见错误与避坑指南

💣 选择题常见错误

1. 混淆相似概念

❌ 标准化和归一化（结果范围不同）
❌ Precision和Recall（分母不同）
❌ L1和L2正则化（效果不同）
✅ 整理对比表格，加深记忆

2. 记错公式

❌ Attention除以sqrt(d_k)还是d_k？（答：sqrt(d_k)）
❌ Adam的β1和β2默认值？（答：0.9和0.999）
✅ 高频公式抄10遍，考前再看一遍

3. 理解偏差

❌ 认为Dropout只在训练时用（测试时也要调整输出）
❌ 认为BatchNorm适用于所有场景（Transformer用LayerNorm）
✅ 理解原理，而不是死记结论

4. 审题不仔细

❌ 题目问”不正确的是”，选了正确的选项
❌ 没看到”以下哪个除外”
✅ 关键词圈出来，慢慢读

💣 编程题常见错误

1. ACM输入输出格式错误（超高频！）

# ❌ 错误：忘记处理多行输入
n = int(input())
# 后面没有读取数据

# ✅ 正确
n = int(input())
data = list(map(int, input().split()))

# ❌ 错误：输出格式不对（多余空格、换行）
print(result, )  # 注意逗号
print(result, "\n")  # 多余换行

# ✅ 正确
print(result)

常见ACM输入格式：

# 格式1：第一行n，第二行n个数
n = int(input())
nums = list(map(int, input().split()))

# 格式2：第一行n和m，后面n行每行m个数
n, m = map(int, input().split())
matrix = []
for i in range(n):
    row = list(map(int, input().split()))
    matrix.append(row)

# 格式3：多组输入（不知道有多少组）
import sys
for line in sys.stdin:
    data = list(map(int, line.strip().split()))
    # 处理data

# 格式4：第一行T（测试用例数），后面T组数据
T = int(input())
for _ in range(T):
    n = int(input())
    # 处理每组数据

# 格式5：输入直到EOF
try:
    while True:
        line = input()
        # 处理line
except EOFError:
    pass

2. 数据类型错误

# ❌ 错误：整数除法变成浮点数
result = a / b  # Python3会得到float

# ✅ 正确：如果要整数除法
result = a // b

# ❌ 错误：浮点数比较
if a == b:  # 浮点数不能直接==

# ✅ 正确
if abs(a - b) < 1e-9:

3. 数组越界

# ❌ 错误：没检查边界
result = arr[i + 1]  # 如果i是最后一个元素，会越界

# ✅ 正确
if i + 1 < len(arr):
    result = arr[i + 1]

4. 算法超时

❌ 暴力算法时间复杂度O(n²)或更高，n=10^5时会超时
✅ 优化算法，使用NumPy向量化运算

5. 忘记边界情况

❌ 没考虑n=0、n=1的情况
❌ 没考虑全部相同的情况
❌ 没考虑负数、浮点数
✅ 自己构造边界测试用例

6. NumPy相关错误

# ❌ 错误：维度不匹配
a = np.array([1, 2, 3])  # (3,)
b = np.array([[1], [2], [3]])  # (3, 1)
result = a + b  # 可能不是你想要的结果

# ✅ 正确：注意reshape
a = a.reshape(-1, 1)  # 变成(3, 1)

# ❌ 错误：axis参数错误
np.mean(matrix, axis=1)  # 对每行求均值还是每列？

# ✅ 正确：先测试确认axis方向

💣 考试流程常见错误

1. 时间管理失败

❌ 在选择题上花了70分钟（太久）
❌ 在编程题第二题死磕80分钟，第一题只拿了50分
✅ 严格执行时间计划，用手表监控

2. 切屏导致警告

❌ 切换到微信回消息
❌ 切换到浏览器查资料
✅ 只能在本地IDE和考试页面之间切换，其他软件全关闭

3. 摄像头问题

❌ 副机位没对准键盘和手部
❌ 起身离开（不能上厕所）
✅ 考前测试好，考试期间不要乱动

4. 提交失败

❌ 以为点了提交，其实没提交成功
❌ 时间到了还在写代码，没来得及提交
✅ 提交后确认页面显示”已提交”，留出5分钟检查时间

💣 备考阶段常见错误

1. 计划不合理

❌ 前几天很拼命，后面就放弃了
❌ 只刷选择题，不练编程题
❌ 只看理论，不动手写代码
✅ 均衡安排，理论+实践结合

2. 学习方法不对

❌ 看视频当娱乐，不做笔记不动手
❌ 刷题不看答案，错了也不知道为什么
❌ 知识点学了就忘，不复习
✅ 主动学习，整理笔记，定期复习

3. 心态问题

❌ 太焦虑，每天学12小时，效率低
❌ 太佛系，不当回事，裸考
❌ 和别人比进度，影响自己节奏
✅ 张弛有度，专注自己的计划

备考期间生活建议

🏃 作息与健康

推荐作息：

7:00-8:00：起床、洗漱、早餐
9:00-12:00：上午学习（效率最高）
12:00-14:00：午餐、午休
14:00-18:00：下午学习
18:00-19:00：晚餐、休息
19:00-22:00：晚上学习
22:00-23:00：复习、整理、放松
23:00：睡觉

注意事项：

✅ 保证每天7-8小时睡眠
✅ 每学习1小时休息10分钟（远眺、起身走动）
✅ 每天运动30分钟（散步、跑步、做操）
✅ 保持规律作息，不要熬夜
❌ 不要连续学习3小时以上（效率会下降）

🍎 饮食建议

🎮 放松方式

二战/三战考生建议

🔄 如果第一次没过

首先，接受现实：

一次失败不代表能力不行
很多人都是二战才过的
关键是总结经验，调整策略

分析失败原因：

知识点不扎实？
- 选择题正确率低于60% → 重点补基础
- 编程题第一题没AC → 算法不熟练
时间管理问题？
- 选择题花了太久 → 下次果断跳过不会的
- 编程题调试太久 → ACM输入输出要练熟
心态问题？
- 考试时太紧张 → 多做模拟题，培养心态
- 在某道题上死磕 → 学会取舍
考试技巧问题？
- 提交失败、格式错误 → 熟悉考试系统
- 没拿到部分分 → 学习如何拿部分分

二战备考策略调整：

如果是知识点问题：

重新系统学习薄弱部分
增加刷题量（比一战多30%）
重点突破Transformer等高频考点

如果是算法问题：

编程题第一题的所有算法手写10遍
每天至少1道编程题
熟练掌握ACM输入输出

如果是心态问题：

降低期望（180分就够）
模拟考试培养心态
告诉自己”这次有经验了”

二战优势：

✅ 知道考试流程和题型
✅ 知道自己的弱点
✅ 心理压力小一些（已经失败过一次了）

二战注意事项：

不要照搬一战的备考计划（要针对性调整）
不要急于求成（还是要系统准备）
相信自己能过（很多人二战都过了）

终极备考清单（考前自查）

✅ 知识点掌握度自查

基础知识（必须掌握）：

激活函数（ReLU、Sigmoid、GELU）的性质和应用
损失函数（MSE、交叉熵）的应用场景
优化器（SGD、Adam、AdamW）的区别
正则化技术（L1、L2、Dropout）
过拟合和欠拟合的识别与解决

Transformer专题（重点，必须掌握）：

Self-Attention的计算流程
Multi-Head Attention的原理
位置编码的作用
KV Cache的原理和显存计算
量化技术（INT8、FP16）
LoRA的原理和rank参数含义
Transformer的时间复杂度（O(n²d)）

传统算法（必须掌握）：

KNN原理和实现
决策树的分裂标准
距离度量（欧式、曼哈顿、余弦）

数据预处理（高频，必须掌握）：

标准化 vs 归一化的区别和应用
缺失值处理的方法
异常值检测（IQR、Z-score）

评估指标（必须掌握）：

Precision、Recall、F1的计算和应用场景
混淆矩阵的理解
回归指标（MSE、MAE、RMSE）

✅ 编程能力自查

必须能手写（闭眼能写）：

ACM输入输出（5种常见格式）
线性回归（梯度下降法）
逻辑回归（二分类）
KNN分类器
数据标准化（Z-score）
数据归一化（Min-Max）
缺失值填充
余弦相似度计算

应该能写（给5分钟思考时间）：

双层MLP前向传播
Self-Attention实现
TF-IDF计算
时间窗口检索

NumPy掌握度：

数组创建和操作
矩阵运算（点积、转置）
统计函数（mean、std、sum）
布尔索引和切片

✅ 刷题量自查

最低要求（及格）：

选择题：500道以上，正确率60%以上
编程题：30道以上
完整模拟题：5套以上

推荐要求（稳健通过）：

选择题：800道以上，正确率75%以上
编程题：50道以上
完整模拟题：10套以上

高分要求（350+）：

选择题：1000道以上，正确率85%以上
编程题：80道以上
完整模拟题：15套以上

✅ 考试准备自查

硬件环境：

双机位摄像头测试通过
Chrome浏览器最新版
本地IDE配置好Python+NumPy
网络稳定（有线网优于WiFi）
备用网络（手机热点）

软件准备：

ACM输入输出模板（本地文件）
算法代码模板（本地文件）
NumPy速查表（本地文件）
所有弹窗软件关闭

物品准备：

纸笔、水杯
手表或计时器
身份证、准考证（如需要）

心理准备：

做过至少3次完整模拟（计时）
知道自己的时间分配策略
明确目标分数（180/250/350）
准备好Plan B（二战也没关系）

学长最后的叮嘱

💪 给零基础同学

你可能觉得：”我连机器学习是什么都不知道，2周时间怎么可能通过？”

我想告诉你：

我认识的考友里，至少30%是零基础通过的
华为AI机试考的是基础知识，不是研究前沿
180分及格线真的不高，选择题对一半+编程题第一题AC就够了
关键是方法对+坚持练

给你的建议：

不要试图全懂：时间有限，先把高频考点搞懂
重点突破编程题：选择题可以靠刷题记答案，编程题必须真写
ACM输入输出是生命线：这个不熟练，编程题白瞎
降低期望，减轻压力：180分就是胜利！

你能做到的！加油！🔥

💪 给有基础同学

你可能觉得：”我学过ML课程，应该很简单吧？”

我想提醒你：

不要轻敌！很多有基础的人因为轻视而失败
Transformer和大模型优化技术（KV Cache、量化、LoRA）是新内容，必须重点学
ACM模式和LeetCode不一样，要专门练习
有基础的优势是理解快，但手写代码还是要练

给你的建议：

查漏补缺：快速过一遍知识点，找出薄弱项
重点突破Transformer：这是分值最高的部分
多做完整模拟题：培养时间感和考试节奏
目标250+：不要满足于及格，冲一个好成绩

相信你能拿高分！💪

💪 给二战同学

你可能觉得：”一战失败了，我是不是不适合这个？”

我想告诉你：

二战通过率远高于一战（因为有经验了）
失败一次不代表能力不行，可能只是准备不够或策略不对
你现在最大的优势是：知道考什么、知道自己弱在哪

给你的建议：

认真分析一战失败原因：是知识点？算法？时间管理？心态？
针对性调整备考计划：不要重复一战的错误
降低心理压力：已经失败过一次了，这次没什么好怕的
相信自己：很多人都是二战过的，你也可以！

这次一定能过！坚持！🚀

💪 给考前3天的同学

你可能觉得：”还有3天就考试了，现在准备还来得及吗？”

我想告诉你：

3天虽然紧张，但总比裸考强
重点不是学完所有知识，而是把能拿的分都拿到
选择题靠刷题记答案，编程题第一题必须会

给你的建议：

放弃完美主义：不求全懂，只求过线
背高频考点：Transformer、激活函数、优化器、KV Cache
死磕编程题第一题：线性回归、逻辑回归、KNN必须会手写
ACM输入输出练到吐：这个不能出错
目标180分：编程题第二题可以放弃

抓紧时间，冲刺！⏰

💪 给所有同学的通用建议

关于学习方法：

✅ 主动学习：看完理论马上动手写代码
✅ 费曼学习法：能讲出来才是真懂
✅ 刻意练习：针对薄弱点反复练
✅ 定期复习：艾宾浩斯遗忘曲线是真的
❌ 避免被动学习：光看视频不动手

关于刷题：

✅ 错题比对题更重要：搞懂每道错题
✅ 质量>数量：刷100道搞懂，胜过刷1000道糊涂
✅ 模拟真实考试：计时、不查资料
❌ 避免刷题依赖症：刷题是手段，不是目的

关于心态：

✅ 接受自己的节奏：不和别人比进度
✅ 关注过程不关注结果：每天进步一点点
✅ 允许自己犯错：错误是学习的机会
✅ 保持身心健康：学习效率>学习时间
❌ 避免过度焦虑：焦虑不解决问题

关于考试：

✅ 时间管理第一：不会的果断跳过
✅ 拿稳能拿的分：别因为粗心失分
✅ 部分分也是分：编程题第二题写暴力也行
✅ 相信自己：你准备得已经够充分了
❌ 避免贪心：不要因为追求满分而失分

结语

写了这么多，希望能帮到正在备考的你。

华为AI机试确实有一定难度，但绝对不是不可逾越的高山。只要方法对、肯努力、心态稳，180分及格真的不难。

记住几个关键点：

Transformer是重中之重（30-40分），必须搞懂
编程题第一题是生命线（150分），必须拿下
ACM输入输出要练熟，不能在这上面失分
时间管理很重要，不要在一道题上死磕
180分就够了，不要给自己太大压力

备考的这段时间可能会很辛苦：

有看不懂的知识点
有做不出的题目
有怀疑自己的时刻
有想要放弃的念头

但请相信：

每个人都会经历这些
坚持下来的人都过了
你也可以！

最后，无论结果如何：

这段学习经历本身就是收获
你学到的知识是你的财富
你培养的学习能力会伴随终身

祝你考试顺利，一次通过！ 🎉

如果最终没过也不要气馁，总结经验，二战再来！

有问题欢迎交流，有经验欢迎分享！

我们都是并肩作战的战友，加油！💪

附录：快速查阅速查表

激活函数速查

激活函数	公式	取值范围	优点	缺点	应用
ReLU	max(0,x)	[0,∞)	计算快、缓解梯度消失	Dead ReLU	CNN中间层
Sigmoid	1/(1+e^-x)	(0,1)	可解释为概率	梯度消失严重	二分类输出
Tanh	(e^x-e^-x)/(e^x+e^-x)	(-1,1)	零中心化	梯度消失	RNN
GELU	x·Φ(x)	(-∞,∞)	平滑、性能好	计算稍慢	Transformer
LeakyReLU	max(αx,x)	(-∞,∞)	解决Dead ReLU	-	GAN

优化器速查

优化器	自适应学习率	典型参数	优点	缺点	应用
SGD	❌	lr=0.01	简单、泛化好	收敛慢、震荡	通用
Momentum	❌	lr=0.01, β=0.9	加速收敛	仍需调lr	通用
Adam	✅	lr=0.001, β1=0.9, β2=0.999	自适应、收敛快	可能过拟合	最常用
AdamW	✅	同Adam	泛化好	-	Transformer

损失函数速查

损失函数	公式	任务类型	特点
MSE	(1/n)Σ(y_pred-y_true)²	回归	对异常值敏感
MAE	(1/n)Σ\|y_pred-y_true\|	回归	对异常值鲁棒
Cross-Entropy	-Σy·log(p)	分类	常用
Hinge Loss	max(0,1-y·f(x))	SVM	支持向量机

数据预处理速查

方法	公式	结果范围	应用场景
Z-score标准化	(x-μ)/σ	均值0，标差1	线性模型、SVM、数据正态分布
Min-Max归一化	(x-min)/(max-min)	[0,1]	神经网络、图像处理
均值填充	缺失值=mean	-	数值型、正态分布
中位数填充	缺失值=median	-	数值型、有异常值
众数填充	缺失值=mode	-	类别型

评估指标速查

指标	公式	含义	应用场景
Accuracy	(TP+TN)/总数	整体正确率	类别平衡
Precision	TP/(TP+FP)	预测为正中真正的比例	关注误报（如垃圾邮件）
Recall	TP/(TP+FN)	真正样本被找出的比例	关注漏报（如疾病诊断）
F1-score	2PR/(P+R)	精确率和召回率的调和平均	类别不平衡

Transformer核心概念速查

概念	公式/描述	重要度
Self-Attention	Attention(Q,K,V) = softmax(QK^T/√d_k)V	⭐⭐⭐⭐⭐
时间复杂度	O(n²d)	⭐⭐⭐⭐⭐
除以√d_k原因	防止点积过大导致梯度消失	⭐⭐⭐⭐⭐
Multi-Head	多个注意力头并行，捕获不同子空间信息	⭐⭐⭐⭐⭐
KV Cache	缓存历史K和V，避免重复计算	⭐⭐⭐⭐⭐
位置编码	PE(pos,2i)=sin(pos/10000^(2i/d))	⭐⭐⭐⭐
LayerNorm	对特征维度归一化	⭐⭐⭐⭐
LoRA	W’=W+BA，r<<d	⭐⭐⭐⭐
INT8量化	压缩4倍，精度损失<1%	⭐⭐⭐⭐

ACM输入输出速查

# 模板1：单行输入
n = int(input())

# 模板2：一行多个数
n, m = map(int, input().split())

# 模板3：数组输入
arr = list(map(int, input().split()))

# 模板4：矩阵输入
n, m = map(int, input().split())
matrix = []
for i in range(n):
    row = list(map(int, input().split()))
    matrix.append(row)

# 模板5：多组测试
T = int(input())
for _ in range(T):
    # 处理每组数据
    pass

# 模板6：不定组数输入
import sys
for line in sys.stdin:
    data = line.strip().split()
    # 处理data

# 模板7：输入到EOF
try:
    while True:
        line = input()
        # 处理line
except EOFError:
    pass

NumPy常用函数速查

# 创建数组
np.array([1,2,3])
np.zeros((3,4))
np.ones((2,3))
np.eye(3)  # 单位矩阵
np.arange(0,10,2)  # [0,2,4,6,8]
np.linspace(0,1,5)  # [0, 0.25, 0.5, 0.75, 1]

# 统计函数
np.mean(arr, axis=0)  # 均值
np.std(arr, axis=0)   # 标准差
np.sum(arr, axis=0)   # 求和
np.min(arr), np.max(arr)  # 最小最大值

# 矩阵运算
np.dot(A, B)  # 矩阵乘法/点积
A @ B         # 矩阵乘法（Python 3.5+）
A.T           # 转置
np.linalg.norm(A)  # 范数

# 形状操作
arr.reshape(3,4)
arr.flatten()
arr.transpose()

# 索引切片
arr[0]        # 第一个元素
arr[1:3]      # 切片
arr[:, 0]     # 第一列
arr[arr > 0]  # 布尔索引

再次祝你考试顺利！加油加油加油！🎉🎉🎉

面试准备

#华为 #AI #机试 #备考

华为AI机试备考计划（完整版）

https://whyalwaysme.lol/2026/09/01/华为AI机试-备考计划/

作者

Cassiur

发布于

2026年9月1日

许可协议

华为AI机试选择题知识点大全上一篇