2025.10.28 面试记录

整理面试记录，并附上了AI的回答作为参考：

聊实习

略

🚀 场景题

Q: 均衡策略。DeepMind提出的AlphaStar是怎么取得均衡策略的？

A: 确实没了解过。

【AI回答】
AlphaStar实现均衡策略的核心在于它使用了联盟训练（League Training）。它不只是简单的自对弈，而是维护了一个庞大的策略池，包含：主力智能体（Main Agents）、专门用于寻找主力智能体漏洞的“利用性”智能体（Exploiter Agents），以及历史版本的智能体。所有智能体在这个“联盟”中相互博弈。这迫使主力智能体必须学会应对各种各样的战术（而不是只精通一种策略），从而覆盖了广阔的策略空间，最终收敛到一个近似的纳什均衡（Nash Equilibrium）。

Q: 在《QQ飞车》如果用PPO训练，想要车跑得越快越好。地图有捷径，想要走捷径，但是走捷径容易撞，是高风险高收益的。那应该如何调整策略实现最优？

A: 我感觉我会用一些专家数据先训练出基础模型，让他形成走近道的基本倾向，然后再通过rl控制其稳定性。

【AI回答】
您的思路（专家数据预训练 + RL微调）是一个很好的方法。在RL（PPO）阶段，核心是调整**奖励函数（Reward Shaping）**来平衡风险。例如：

  1. 给予一个持续的“时间惩罚”（如每一步-0.1），这会激励智能体寻找最快的路径（即捷径）。
  2. 对撞墙或掉落设置一个“巨大的负奖励”，这个惩罚值必须远大于走捷径所节省的时间收益。
    通过PPO最大化期望回报的目标，智能体会自动学习到：只有当我（策略）有足够高的把握成功通过捷径时，这个“高收益”才值得去冒“高风险”。

Q: 开到赛道里面如果是捷径很容易掉下去，即便鼓励走捷径的行为，虽然路程短，但是挑战大，反而会导致时间更长，怎么办？或者说如果不用PPO，什么方法更适合这样场景？

A: 我感觉可以先把捷径的惩罚关闭或减小……但是如果是以全局时间来计算，似乎罚时也会有影响。那我觉得可以用一些分层的方法，有一个高层规划器指挥底层模型去走捷径。或者说一张固定的图肯定有最优路线，我觉得可以用其和最优路线的偏离程度作为reward的一部分。

【AI回答】
PPO作为On-policy算法，在探索高风险区域时确实困难。如果不用PPO，Off-policy算法（如SAC或TD3）会更适合。
它们的优势在于使用Replay Buffer，可以存储那些“稀有的”成功走通捷径的经验，并反复利用这些“好样本”进行学习。如果结合优先经验回放（PER），可以进一步放大这些关键成功经验的价值。
另外，您提到的**分层强化学习（HRL）**也是一个非常好的方向，它将“是否走捷径”的决策（高层策略）和“如何稳定通过捷径”的执行（底层策略）分离开，显著降低了单一策略的学习难度。

Q: 那你这样（HRL或Reward Shaping）和用Off-policy的好样本回放（例如PER/HER）相比有什么优势？
A: 我觉得方差会小一些，另外也减少了随机探索和采样效率的问题吧，可能训练会稳定一些。

【AI回答】
您提到的分层方法（HRL）的优势在于结构化和引入先验知识。它将一个复杂的长时序问题分解为几个简单的子问题（高层规划+底层控制），这确实能降低学习方差，使训练更稳定，并且具有更好的可解释性。
相比之下，HER/PER这类Off-policy技巧的优势在于通用性和样本利用率，它们不需要对任务进行手动分解（设计子目标），而是通过算法机制（如事后目标设定）来压榨稀疏奖励环境中的样本价值。

Q: 换一个场景。现在是《魔兽世界》场景，要控制智能体打副本BOSS。BOSS有两阶段：第一阶段BOSS召唤小怪，小怪比较脆，可以AOE（范围伤害）干掉；第二阶段是打BOSS本体。与飞车不同，打副本BOSS需要两个策略（AOE和单体伤害）。如果第一阶段学得越好，越容易用群伤，（到了第二阶段）容易产生策略震荡。但限制使用一个策略，怎么办？

A: 我感觉我会做一些特征工程的工作，尽可能地把两个阶段从特征上区分开，或者使用一些类似vae的方法？能够自然把两个阶段分开。

【AI回答】
您的思路（特征工程）是关键。我们必须在**状态（State）中明确提供“当前是第几阶段”的信息，例如一个one-hot向量 s=[sgame,sphase_1,sphase_2]s = [s_{\text{game}}, s_{\text{phase\_1}}, s_{\text{phase\_2}}]。

只要状态是可区分的，一个足够深的网络（即“一个策略”）理论上就能学到两个子策略（即 P(a∣s,phase=1)P(a | s, \text{phase}=1) 和 P(a∣s,phase=2)P(a | s, \text{phase}=2)）。为了加强这种区分，防止策略震荡，可以采用多头（Multi-head）架构**：网络共享一个Trunk来编码状态，但在最后分离出两个不同的“动作头”（一个用于P1，一个用于P2），并根据当前阶段的特征来门控（Gating）或选择哪个头生效。

Q: 那，在第二阶段开始时候使用群攻可能会很容易死，奖赏回传会影响第一阶段学习到的策略，应该怎么解决？

A: 我想的话可能会类似MOE的方式，总之尽可能把网络关于第一阶段和第二阶段的参数隔离开，比如设置不同的head。或者用HER的方式，生成一些伪奖励，譬如提前设置done状态来回传。

【AI回答】
您提到的MOE或设置不同的Head是解决这个问题的核心。这个问题的本质是“信用分配”错误。当第二阶段（P2）的错误（如用AOE）导致死亡时，这个巨大的负奖励会通过TD-error回传。
如果P1和P2共享所有参数，这个负奖励就会“污染”P1学到的AOE策略。使用不同的Head（即P1的Q-value头和P2的Q-value头）可以隔离这种影响，使得P2的梯度只更新P2的Head（或相关参数），从而在反向传播时阻断跨阶段的信用分配。HER在这里不太适用，因为它主要解决稀疏奖励问题。

Q: 在FPS游戏里面，如果训练一个智能体可以与玩家战斗，但是行为风格倾向于找掩体，喜欢在掩体后面射击。如果在旷野场景下不太会反击，这是什么原因导致的？应该如何优化？

A: 我觉得应该是因为样本不均匀吧，大量的样本集中在有掩体的场景。那其实针对无掩体的去训练应该能够改善这个问题吧。

【AI回答】
您的判断（样本不均匀）非常准确。这在RL中称为策略“卡”在局部最优解。智能体发现“躲掩体”是一个在大多数情况下（高样本密度）安全且有中等收益的策略，因此它停止了对“旷野战斗”这一高风险（但也可能高收益）策略的探索。
优化方法除了增加旷野场景（如您所说），还可以：

  1. 课程学习（Curriculum Learning）：先强制智能体在旷野场景下训练，学会基础对枪能力，再逐渐混合掩体场景。
  2. 多样化奖励：在旷野中成功击杀时给予额外的奖励，以激励探索。

Q: 如果这个模型是自对弈（Self-Play）训练出来的，那训练过程还需要哪些调整？
A: 我感觉可以在有基础能力的情况下，让对手的策略池多样一些，去训练出一个比较鲁棒的策略。如果已经这么做了的话，我感觉可以尝试用一些规则模型作为对手去训练。

【AI回答】
您的思路（多样化策略池）非常关键。如果智能体只和“自己”对弈（Naive Self-Play），它们可能会“共谋”（collude）出一种双方都“躲掩体”的低风险均衡。
为了打破这种均衡，策略池中必须（如您所说）包含：

  1. 历史版本的对手（防止遗忘）。
  2. 专门的“利用性”对手（Exploiters），例如，训练一个只在旷野冲锋的对手，或者一个专门“清扫掩体”的规则AI。
    这样，主力智能体就被迫学会反制这些“偏科”的策略，从而使自己的策略变得鲁棒，学会在旷野中反击。

📚 基础知识

Q: 在DQN等一些Off-policy算法里面，并没有使用重要性采样（Importance Sampling），是为什么？

A: DQN本质上是基于贪婪的时序差分，永远选择下一个状态中Q值最大的动作，而不管当前的行为策略实际选择了什么动作。这意味着其实他对目标的估计是确定的而不是概率分布。但PG类算法都是需要对 π\pi 求梯度的，这需要将历史样本通过重要性采样修正到当前分布下。

【AI回答】
您的理解基本正确。DQN是值函数（Value-based）算法。它的更新目标是 R+γmax⁡a′Q(s′,a′)R + \gamma \max_{a'} Q(s', a')。这个目标是基于Target网络对下一个状态 s′s' 的最优估计（max Q），这个估计值与“行为策略 πbehavior\pi_{\text{behavior}} 到底在 s′s' 采取了什么动作”无关。
而PG（Policy-based）算法（如PPO）的目标是估计策略 πθ\pi_{\theta} 本身的期望回报 J(θ)J(\theta)，其梯度计算 ∇J(θ)\nabla J(\theta) 必须依赖于 πθ\pi_{\theta} 采样的轨迹。因此，当使用旧策略（Off-policy）的轨迹时，才必须用重要性采样来修正这个分布差异。
（注：也有结合了重要性采样的Q-learning变种，如Retrace(Q)，但标准DQN不使用。）

Q: DQN的Replay Buffer和PPO的（Buffer）有什么区别？

A: DQN的replay buffer可以存放各种数据，比如专家的，或者很历史的。但ppo基本只能是近期的，如果太远可能会导致新旧差异比值过大或过小，一直处于裁剪之外。

【AI回答】
您回答得非常准确。

  1. DQN (Off-policy): 它的Replay Buffer是“离策略”的，可以（也鼓励）存储非常久远的历史数据（如几十万步之前）和专家数据。DQN通过随机采样打乱数据相关性，利用这些数据学习Q函数。
  2. PPO (On-policy): 它的Buffer（通常称为Rollout Buffer）是“在策略”的。它存放的是当前策略 πθold\pi_{\theta_{\text{old}}} 刚刚采样到的一批轨迹（如2048步）。PPO必须在采样这批数据后立即进行训练，然后清空Buffer，再用更新后的策略 πθnew\pi_{\theta_{\text{new}}} 去采样新数据。如您所言，如果PPO使用太旧的数据，新旧策略比值（Ratio）会偏离1太远，导致Clip机制失效。

Q: 那如果新旧比值Ratio就一直在裁剪边界，会有什么影响？

A: （不确定）我感觉可能就是训练不稳定吧，或者说可能训练不会很精细？

【AI回答】
您的直觉是对的。如果Ratio（πθπθold\frac{\pi_{\theta}}{\pi_{\theta_{\text{old}}}}）总是被Clip（例如总是大于 1+ϵ1+\epsilon 或小于 1−ϵ1-\epsilon），这通常意味着学习率（LR）可能设置得太大了，或者Advantage的估计方差太高。
影响是：

  1. 训练低效：策略试图（在多个epoch中）朝一个方向进行大幅更新，但每次都被PPO的Clip机制强行“拉回”。这导致大部分梯度被浪费在Clip边界上。
  2. 训练不稳定：策略在边界附近震荡，难以收敛到精细的最优解。
  3. 收敛过早：策略可能在未充分探索时就收敛到一个次优解。

Q: PPO 通过什么方式使策略更新比较稳定？**

A: 一般就是kl惩罚或clip，常用的就是clip了，限制策略的更新幅度。

【AI回答】
您回答得非常准确。PPO（Proximal Policy Optimization）的核心就是“Proximal”（近端）。它通过两种方式实现稳定更新，防止On-policy策略更新步子太大而“掉下悬崖”：

  1. PPO-Penalty (PPO-KL)：在目标函数中加入一个KL散度的“软惩罚项”，衡量新旧策略的差异，如果差异太大则施加惩罚。
  2. PPO-Clip（常用）：(如您所说) 在目标函数中直接使用一个“裁剪（Clip）”函数， LCLIP(θ)=E^t[min⁡(rt(θ)A^t,clip(rt(θ),1−ϵ,1+ϵ)A^t)]L^{\text{CLIP}}(\theta) = \hat{\mathbb{E}}_t [\min(r_t(\theta) \hat{A}_t, \text{clip}(r_t(\theta), 1-\epsilon, 1+\epsilon) \hat{A}_t)]。这相当于设置了一个“信任域”（Trust Region），确保新策略不会偏离旧策略太远，使得训练过程更稳定。

💻 编程题

Q: 编写两个函数：压缩字符串和解压字符串。
压缩规则： 连续相同字符用“字符”及“出现的次数”表示（如果只有一个则不用加数字）。
示例： aaabbbccd 压缩为 a3b3c2d
解压规则： 输入压缩的字符串，返回原来的字符串。

【AI回答】

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
def compress_string(s: str) -> str:
    if not s:
        return ""

    result = []
    count = 1
    # 遍历字符串，直到倒数第二个字符
    for i in range(len(s) - 1):
        if s[i] == s[i+1]:
            count += 1
        else:
            # 遇到不同的字符，处理前一个字符
            result.append(s[i])
            if count > 1:
                result.append(str(count))
            count = 1 # 重置计数器

    # 处理字符串的最后一个字符
    result.append(s[-1])
    if count > 1:
        result.append(str(count))

    return "".join(result)

def decompress_string(s: str) -> str:
    result = []
    i = 0
    while i < len(s):
        char = s[i]
        i += 1
        
        # 查找数字
        num_str = ""
        while i < len(s) and s[i].isdigit():
            num_str += s[i]
            i += 1
            
        if num_str:
            count = int(num_str)
            result.append(char * count)
        else:
            # 如果没有数字，说明只有一个
            result.append(char)
            
    return "".join(result)

# --- 示例测试 ---
original = "aaabbbccd"
compressed = compress_string(original)
print(f"Original: {original}")
print(f"Compressed: {compressed}") # Output: a3b3c2d

original_2 = "abcd"
compressed_2 = compress_string(original_2)
print(f"Original: {original_2}")
print(f"Compressed: {compressed_2}") # Output: abcd

compressed_input = "a3b3c2d"
decompressed = decompress_string(compressed_input)
print(f"Compressed Input: {compressed_input}")
print(f"Decompressed: {decompressed}") # Output: aaabbbccd
求职之路
#理论学习 #面经
2025.10.28 面试记录
http://dufolk.github.io/2025/10/29/tencent2/
作者
Dufolk
发布于
2025年10月29日
许可协议