今天练习的是华为AI岗最新机考笔试题3题。

各大厂真题都整理了近两年的机考题，题库里面有详细思路和答案~

肥猫学长也提供机考辅导助攻和面试辅导欢迎咨询。

微信号：jackwwang8

目前已经整理的题库有如下：如果有需要可以加我微信获取哦

华为AI岗春招题目4.8

1.单选题

（多选题部分整理在题库里，加微信获取：jackwwang8）

1、如果相关系数ρxy = -1，说明X和Y：

A. 相互独立

B. 存在线性函数关系

C. 完全负线性相关

D. 完全不相关

答案：C

解析：相关系数ρxy = -1表示X和Y之间是完全负线性相关，所有样本点都严格落在一条斜率为负的直线上。

2、对任意实矩阵A，若其奇异值分解为A=UΣV^T，则A的秩rank(A)等于以下哪项?

A. Σ的迹trace(Σ)

B. Σ的对角线上非零奇异值的个数

C. V的行数

D. U的列数

答案：B

解析：矩阵A的秩等于Σ中非零对角元个数，因为U和V正交，不改变秩，非零奇异值个数即秩。

3、设事件A,B满足P(A)=0.4，P(B|A)=0.5，P(B|¬A)=0.3，则P(A|B)的值最接近以下哪个数()

A. 0.4

B. 0.5

C. 0.3

D. 0.6

答案：B

解析：先求P(B)=0.5×0.4+0.3×0.6=0.38，再用贝叶斯公式：P(A|B)=(0.5×0.4)/0.38≈0.526，最接近0.5。

4、在混合精度训练中，常用的loss scaling主要是为了解决哪种数值问题

A. 梯度爆炸

B. 梯度下溢

C. 激活饱和

D. 权重过大

答案：B

解析：混合精度训练使用FP16，数值表示范围较小。Loss scaling通过放大损失值，防止微小的梯度值在FP16格式下变为0（下溢），保证训练正常进行。

5、在主成分分析（PCA）中，我们需要将原始数据投影到特征向量所指向的方向上。假设我们有一个已经完成中心化处理的二维数据点x = [3,4]T。通过计算协方差矩阵，我们得到了对应于最大特征值的第一主成分方向的单位特征向量w = [0.8,0.6]T。请问，数据点x在该主成分方向上的投影值（即降维后的一维坐标）是多少?

A. 3.8

B. 2.4

C. 5.0

D. 4.8

答案：D

解析：投影值为点积：[3,4]·[0.8,0.6]=3×0.8+4×0.6=4.8。

6、以下关于Layer Normalization（LN）说法错误的是:

A. 根据LN的位置不同可分Pre-LN和Post-LN

B. 与RMSNorm相比，LN的主要区别在于去掉了减去均值的部分

C. LN首先计算每个样本的均值和方差，之后进行归一化，最后对归一化的值进行缩放和添加偏置

D. LN可在一定程度上避免梯度消失或梯度爆炸的问题，增强模型的泛化能力

答案：B

解析：RMSNorm的主要改进是去除了减去均值的操作，而LN保留了减去均值。B错误地将RMSNorm的特点说成是LN的。

7、如果损失函数曲面呈现狭长的山谷形状（即在一个方向上曲率大，另一个方向上曲率小），SGD容易发生什么现象?

A. 梯度爆炸

B. 快速收敛

C. 梯度消失

D. 震荡，收敛缓慢

答案：D

解析：狭长山谷中，SGD容易在陡峭方向来回震荡，所以收敛慢。

8、关于KV Cache的量化压缩，以下哪种策略是错误的或存在明显缺陷的?

A. 在推理过程中对KV Cache进行在线量化，每次访问都重新计算量化参数

B. 采用INT8或INT4存储KV Cache，配合反量化到FP16进行注意力计算

C. 使用分组量化（per-channel或per-head）平衡精度和效率

D. 对Key和Value分别计算逐token的缩放因子进行动态量化

答案：A

解析：每次访问都重新计算量化参数会引入巨大计算开销，抵消量化带来的内存和加速收益，效率低下，属于明显缺陷。

9、设A,B为互斥事件，P(A)=0.3，P(B)=0.4，P(C|A)=0.8，P(C|B)=0.5，P(C|¬A∩¬B)=0.1，则P(A|C)=()

A. 约0.52

B. 约0.38

C. 约0.47

D. 约0.65

答案：A

解析：P(¬A∩¬B)=1-0.3-0.4=0.3，P(C)=0.8×0.3+0.5×0.4+0.1×0.3=0.47，P(A|C)=(0.8×0.3)/0.47≈0.511，最接近0.52。

10、关于Transformer中注意力机制的优化方案，以下哪一项描述是正确的?

A. 滑动窗口注意力（SWA）将每个token的注意力范围限制在固定窗口内，因此无法捕获任何超出窗口长度的长距离依赖

B. 在DeepSeek-V3等模型中，SWA层和全注意力层交替使用，其中SWA层需要独立维护自己的KV Cache，因此总显存占用与纯全注意力模型相同

C. Flash Attention通过对注意力矩阵进行低秩近似，将计算复杂度从O(n^2)降低到O(n)

D. 线性注意力在推理时可转化为RNN递推形式，生成每个新token的计算量与已生成的上下文长度无关，而标准注意力需要对全部KV Cache做计算

答案：D

解析：线性注意力通过核技巧实现递归计算，每一步复杂度O(1)，标准注意力需计算所有历史token，复杂度O(n)。D正确描述了该优势。

11、使用泰勒展开式sin(x)=x - x^3/6来近似计算sin(0.1)，其截断误差的主要阶数为:

A. O(x^4)

B. O(x^3)

C. O(x^5)

D. O(x^6)

答案：C

解析：下一项是x5/120，所以误差阶为O(x5)。

12、关于Huber损失函数（Smooth L1），下列说法正确的是:

A. Huber损失平衡了MSE对异常值的敏感性和MAE在零点的不可导性

B. Huber损失存在不可导点，需要特殊处理

C. Huber损失在误差较小时表现为线性（绝对值），误差较大时表现为二次（平方）

D. Huber损失在所有区间都是二次函数，与MSE完全相同

答案：A

解析：Huber损失是分段函数：小误差时(|y-f(x)|≤δ)为二次，平滑可导；大误差时为一次，减少异常值影响，故平衡了MSE和MAE的缺点。

13、在生成式模型（如大语言模型）的解码阶段，模型会为每个候选词输出一个logit值，再通过softmax函数转换为概率分布。温度参数（Temperature）是对logits进行缩放的一种调节手段，用于控制生成结果的随机性与确定性。其计算公式为：P(xi)=exp(zi/T)/Σj exp(zj/T)，其中，zi为第i个token的logit，T为温度参数。基于以上背景，下列关于温度参数作用的说法中，正确的是?

A. 温度=1时，softmax输出随机

B. 温度调节的是logits的缩放，影响概率分布

C. 温度越低，输出越随机

D. 温度越高，输出越确定

答案：B

解析：温度是对logits做缩放，温度低更确定，温度高更随机。

14、在设计端侧后台AI任务调度策略时，以下哪一项是需要综合考虑的约束条件?

A. 用户当前的地理位置

B. 设备的网络连接状态

C. 系统当前的存储空间使用情况

D. 设备温度/热预算

答案：D

解析：端侧设备散热有限，持续AI计算易过热降频。调度时需优先考虑温度/热预算约束，以确保设备稳定运行。

15、子空间的必要条件是?

A. 向量个数有限

B. 向量两两正交

C. 所有向量长度相等

D. 包含零向量

答案：D

解析：子空间必须包含零向量。

2.路由器资源用量预测

题目描述

路由器的某资源利用率与多个运行特征强相关：协议连接数(单位：个)、转发数据包速率(单位：Mpps)、内存占用率(单位：%)。为了精准预测不同负载下的路由器资源利用率，保障网络稳定运行，请实现批量梯度下降法(BGD)来训练资源预测线性回归模型的参数。

特征归一化：对每个特征维度 x_norm = (x - x_min) / (x_max - x_min)，其中 x_min 为该特征在所有样本中的最小值，x_max 为该特征在所有样本中的最大值，若特征无波动，则归一化后的值为0。

特征权重还原：w_real = w / (x_max - x_min)，其中 w 为迭代后的权重，若 x_max - x_min 为0，则 w_real 取0。

偏置项权重还原：b_real = b - sum(w_real * x_min)，b 为迭代后偏置项的权重。

输入描述

第一行：整数 m (样本数量，m > 0)

第二行：整数 n (迭代次数，n > 0)

第三行：浮点数 alpha (学习率，alpha > 0，保留2位小数)

后续 m 行：每行4个整数，依次为 x1 (协议连接数)、x2 (转发数据包速率)、x3 (内存占用率)、y (资源用量)

输出描述

一行，4个浮点数，依次为还原后的 b，w1，w2，w3，结果保留2位小数，银行家舍入，以一个空格分隔，前后无冗余空格。

样例1

输入

3  100  0.10  100 200 150 6000  200 800 600 7500  300 70 60 6500 

输出

4394.59 6.82 1.20 1.55

解题思路

本题是一个典型的多变量线性回归问题，要求使用批量梯度下降(BGD)训练模型参数，并结合特征归一化与参数还原。

由于各特征取值范围差异较大，需要先对每一维做极值归一化。若某一维没有变化，则该维归一化后全部为0。

在归一化后的数据上训练模型，初始化所有参数为0，每轮迭代执行计算误差和梯度更新参数。

最后，把归一化空间下的参数还原到原始特征空间，特别要注意分母为0的情况，直接认定特征权值为0即可。

（更加详细解题思路和CPP、Java代码加我微信获取）

# 题目一：路由器资源用量预测
import sys
import numpy as np
def update_weights_with_bgd(training_data, total_iterations, learning_rate):
    # 将输入数据转成numpy数组方便运算
    data_array = np.array(training_data, dtype=float)

    # 提取特征列和目标值列
    features = data_array[:, :3]
    labels = data_array[:, 3]

    # 获取每一列的最大值最小值以及范围
    min_feature_vals = features.min(axis=0)
    max_feature_vals = features.max(axis=0)
    feature_ranges = max_feature_vals - min_feature_vals

    # 对特征进行归一化处理，处理除零异常
    normalized_features = np.zeros_like(features, dtype=float)
    for col in range(3):
        if feature_ranges[col] != 0:
            normalized_features[:, col] = (features[:, col] - min_feature_vals[col]) / feature_ranges[col]

    # 初始化权重参数数组，索引0为偏置项，1到3为特征权重
    model_weights = np.zeros(4, dtype=float)
    sample_count = len(labels)

    # 进行指定次数的迭代更新
    for _ in range(total_iterations):
        # 计算所有的预测值
        predictions = model_weights[0] + normalized_features @ model_weights[1:]
        errors = predictions - labels

        # 计算对应的偏置项梯度和权重梯度
        bias_gradient = errors.mean()
        weight_gradients = (normalized_features.T @ errors) / sample_count

        # 使用学习率更新模型参数
        model_weights[0] -= learning_rate * bias_gradient
        model_weights[1:] -= learning_rate * weight_gradients

    # 还原到原始空间的权重
    restored_weights = np.zeros(4, dtype=float)

    for col in range(3):
        if feature_ranges[col] != 0:
            restored_weights[col + 1] = model_weights[col + 1] / feature_ranges[col]
        else:
            restored_weights[col + 1] = 0.0

    # 还原对应的偏置项
    restored_weights[0] = model_weights[0] - np.sum(restored_weights[1:] * min_feature_vals)

    return restored_weights
def main_process():
    input_lines = sys.stdin.read().strip().splitlines()
    if not input_lines:
        return

    sample_size = int(input_lines[0].strip())
    total_iters = int(input_lines[1].strip())
    lr = float(input_lines[2].strip())

    dataset = []
    for line_idx in range(3, 3 + sample_size):
        row_data = list(map(float, input_lines[line_idx].split()))
        dataset.append(row_data)

    final_params = update_weights_with_bgd(dataset, total_iters, lr)

    # 格式化输出为最终结果
    print(f"{final_params[0]:.2f} {final_params[1]:.2f} {final_params[2]:.2f} {final_params[3]:.2f}")
if __name__ == "__main__":
    main_process()

3.快递员极速配送挑战

题目描述

某快递员负责一个片区的快递配送业务。假设他手头有 n 个快递包裹需要派送，每个包裹对应一个具体的收货坐标(x,y)(单位：公里)。

为了提高效率，公司要求快递员先利用聚类算法将这 n 个包裹自动划分为 k 个簇(代表 k 个社区)，快递员只需要将快递送到社区中心即可。

快递员从起始位置出发，按照每个社区中心与起点之间的距离由近到远排序，依次送完所有社区的快递，最后返回起始位置。已知快递员的平均行驶速度为 speed km/h。快递员初始坐标为(0,0)。

请编写程序，计算完成所有配送并返回起点所需的总时间(单位：秒，向下取整)。

K均值聚类计算步骤：

种子点初始化：将所有点按到起点的距离从小到大排序，如果距离相同的点，按照输入坐标点的先后顺序从小到大排序。选择排序后的前 k 个点作为初始聚类中心。

迭代优化：将每个点分配到距离最近的聚类中心聚类。重新计算每个聚类的中心点，移动聚类中心。

收敛判断：如果所有聚类中心的移动距离之和小于 0.0001，则停止迭代。如果达到了预设的最大迭代轮次，也停止迭代。否则返回第二步继续进行迭代优化。

输入描述

第一行输入 3 个由空格分隔的整数，分别为 k(社区个数)、n(快递包裹总数)、speed(快递员平均行驶速度，单位 km/h)。

接下来的 n 行分别表示每个包裹的 x 和 y 坐标(单位：公里)，用空格分割。

输出描述

输出快递员送完所有快递所需的时间，保留整数，向下取整，单位 s。

样例1

输入

3 10 301.2 1.51.8 1.25.0 5.25.5 4.84.9 5.5-2.0 3.0-2.5 3.5-1.8 2.81.5 1.85.2 5.0

输出

2502

解题思路

本题核心分为两部分：聚类计算加上最终路径距离计算。

首先实现K算法对所有包裹进行聚类。初始化时，按点到原点距离升序排序，取前 k 个点作为初始聚类中心。

接下来多轮迭代优化，每个点分配到最近的中心，对每个簇重新计算中心。若某簇无点，则保持原中心不变。

最后如果所有中心移动距离之和足够小或达到最大迭代次数，停止迭代。

得到最终聚类中心后，按中心到原点欧氏距离升序排序，按照排序后的顺序依次连接距离计算出全部路径。结合速度大小算出具体折合时间。

（更加详细解题思路和CPP、Java代码加我微信获取）

# 题目二：快递员极速配送挑战
import sys
import math
import numpy as np
def calculate_euclidean_distance(point_a, point_b):
    # 辅助函数：计算两点直接的欧式距离
    difference = point_a - point_b
    return math.sqrt(difference[0] * difference[0] + difference[1] * difference[1])
def execute_kmeans_clustering(data_points, target_k, max_loops=50, tolerance_threshold=1e-4):
    num_points = len(data_points)
    actual_k = min(target_k, num_points)

    # 计算距离原点的大小并排序，找到初始种子点
    ordered_indices = sorted(range(num_points), key=lambda idx: (data_points[idx][0] ** 2 + data_points[idx][1] ** 2, idx))
    cluster_centers = data_points[ordered_indices[:actual_k]].copy()

    cluster_assignments = np.zeros(num_points, dtype=int)

    for _ in range(max_loops):
        previous_centers = cluster_centers.copy()

        # 将每个点分配给最近的中心
        for point_idx in range(num_points):
            closest_center_idx = 0
            min_dist = float('inf')
            for center_idx in range(actual_k):
                dist = calculate_euclidean_distance(data_points[point_idx], cluster_centers[center_idx])
                if dist < min_dist:
                    min_dist = dist
                    closest_center_idx = center_idx
            cluster_assignments[point_idx] = closest_center_idx

        # 根据新的分配计算新的族中心点
        updated_centers = cluster_centers.copy()
        for center_idx in range(actual_k):
            points_in_cluster = data_points[cluster_assignments == center_idx]
            if len(points_in_cluster) > 0:
                updated_centers[center_idx] = points_in_cluster.mean(axis=0)

        cluster_centers = updated_centers

        # 考察移动距离是否满足结束规则
        total_movement = 0.0
        for center_idx in range(actual_k):
            total_movement += calculate_euclidean_distance(previous_centers[center_idx], cluster_centers[center_idx])

        if total_movement < tolerance_threshold:
            break

    return cluster_centers
def calculate_delivery_time(target_k, num_points, moving_speed, data_points):
    # 执行聚类算法搜寻所有的中心
    found_centers = execute_kmeans_clustering(data_points, target_k)

    # 按照原点距离升序以访问社区
    sorted_centers = sorted(found_centers, key=lambda c: c[0] * c[0] + c[1] * c[1])
    start_origin = np.array([0.0, 0.0])

    total_travel_distance = 0.0
    current_location = start_origin

    # 计算累计历程
    for center in sorted_centers:
        total_travel_distance += calculate_euclidean_distance(current_location, center)
        current_location = center

    total_travel_distance += calculate_euclidean_distance(current_location, start_origin)

    # 时间转换为秒，随后向下取整
    total_duration_seconds = math.floor(total_travel_distance * 3600.0 / moving_speed)
    return total_duration_seconds
def main_execution():
    raw_input_data = sys.stdin.read().strip().split()
    if not raw_input_data:
        return

    target_k = int(raw_input_data[0])
    num_points = int(raw_input_data[1])
    moving_speed = int(raw_input_data[2])

    coordinate_values = list(map(float, raw_input_data[3:]))
    coords_list = []

    for idx_step in range(0, 2 * num_points, 2):
        coords_list.append([coordinate_values[idx_step], coordinate_values[idx_step + 1]])

    points_array = np.array(coords_list, dtype=float)
    final_time = calculate_delivery_time(target_k, num_points, moving_speed, points_array)

    print(final_time)
if __name__ == "__main__":
    main_execution()