Created by: Yuanpeng QU
Created time: 2025年8月15日 14:37

2. 两数相加[mid]

给定两个链表l1，l2，表示逆向储存的数字，比如1→2→3表示321，求两个链表表示的数字相加的和的链表，两个链表的长度可以不一样，每个节点的值不超过10。

实际上逆向储存的意思就是刚好按照个十百千这个顺序来的。

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

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next

class Solution(object):
    def addTwoNumbers(self, l1, l2):
        """
        :type l1: Optional[ListNode]
        :type l2: Optional[ListNode]
        :rtype: Optional[ListNode]
        """
        dummy_head = ListNode()
        current = dummy_head
        carry = 0 # 进位

        while l1 or l2 or carry:
          l1_val = l1.val if l1 else 0
          l2_val = l2.val if l2 else 0

          # 个位开始相加(包含上一位的进位)
          sum_ = l1_val + l2_val + carry
          d = sum_ % 10
          carry = sum_ // 10

          current.next = ListNode(d) #第一次创建的话就是在dummy.next
          current = current.next

          if l1:
            l1 = l1.next
          if l2:
            l2 = l2.next

        return dummy_head.next

• 关键思路：明白逆向的意义，以及知道储存相加导致的进位carry

• 不知道的话就会想到将链表读取值后转成数组，再转成数字，相加后再转换回链表，这样复杂度爆炸，因为如果链表长度特别长的话运行时间肯定超

• 知道逆向存储是按照个十百千这个顺序的话，还需要再知道一个关键：

  num % 10 ⇒对任意一个数取余数，比如7%10=7, 12%10=2，就能得到其个位数是什么

  num // 10 ⇒对任意一个数取10位数的值，可以表示要进几位，比如7//10=0,17//10=1

  这样任意一个数就能通过num%10 num//10-拼在一起得到

• 开始的时候先定一个哑巴指针dummy让curr指向它，最后dummy.next指向的链表作为输出。

• while l1 or l2 or carry：只要其中有不为0或none的话就还需要继续算，先取出l1和l2第一个节点的值，也就是个位数将他们和carry相加，得到结果，因为是个位所以carry=0不会造成进位，然后求出现在这个数的值(%10)和是否需要进位(//10)，将这个值存到curr.next上，而cur.next还没被创建，也就是得先创建新节点用来存值，再将cur指向新节点的next，最后再把l1和l2向后移一位(要判断下一位是否为空)

19. 删除链表的倒数第 N 个结点[mid]

1→2→3→4→5 n=2 ⇒ 1→2→3→5

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

class Solution(object):
    def removeNthFromEnd(self, head, n):
        """
        :type head: Optional[ListNode]
        :type n: int
        :rtype: Optional[ListNode]
        """
        dummy_head = ListNode(0,head)
        current = head
        size = 0
        while current:
          current = current.next
          size += 1

        p = size - n
        current = head
        
        if p == 0:
          head = head.next
          return head
        
        for _ in range(p-1):
          current = current.next
        current.next = current.next.next
        return dummy_head.next

• 最直观的想法：先计算链表的长度size，再通过size-n得到需要删除的节点所在的正向顺序，然后再遍历一遍链表到这个位置的前一个节点，将这个节点的nextnext指向删掉的节点的next，这样就删掉了。
• 注意如果size-n==0，也就是说是head节点被删了，就需要head.next赋给现在的head，这样原来的head就删了。

21. 合并两个有序链表[easy]

两个值从小到大排列的链表合并成一个，合并完的链表仍然是从小到大排序的

1→2→3→4→5

1→3→4→4→8

1→1→2→3→3→4→4→4→5→8

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

class Solution(object):
    def mergeTwoLists(self, list1, list2):
        """
        :type list1: Optional[ListNode]
        :type list2: Optional[ListNode]
        :rtype: Optional[ListNode]
        """
        dummy_head = ListNode(0)
        current = dummy_head

        while list1 and list2:

          if list1.val <= list2.val:
            current.next = list1
            list1 = list1.next
          else:
            current.next = list2
            list2 = list2.next

          current = current.next
        if list1:
          current.next = list1
        else:
          current.next = list2

        return dummy_head.next  

• 关键点：有序链表，可以把两个链表的节点比较大小后像拉链一样一个一个塞到新链表里
• 一般需要新建链表的时候都会提前初始化一个dummy_head=ListNode(0)，然后让它指向我们最后要返回的链表。
• 只要list1和list2都不为空才需要比较大小，如果有一个为空的话另一个不为空的显然要比所有的值都要大，因为是递增链表。这样的话直接将剩下的值拼接到合并的链表最后面就完成了。
• 比大小则是current指向新链表，然后将值小的节点放到current指的位置，current往后移，如此重复。

141. 环形链表[easy]

判断一个链表有没有环，有就返回true，其中pos只是告诉你例题中环的所指位置

1
2
3
4
5
6
7
8
9
10
11
12
13

class Solution(object):
    def hasCycle(self, head):
        """
        :type head: ListNode
        :rtype: bool
        """
        fast, slow = head, head
        while fast and fast.next:
            fast = fast.next.next
            slow = slow.next
            if fast == slow:
                return True
        return False

• 核心思想：运动场跑道上跑得快和跑得慢的人同时从起点出发，跑得快的人肯定会在某圈后和跑的慢的人相遇
• 直接创建一个fast和slow指针指向head，fast每次遍历两个节点，slow遍历一个，这样如果没有环的话fast肯定先到末尾，fast.next会指向none，以及fast自己也可能是none，这样就能作为while的停止条件了，而如果有环的话肯定会有一个时间点有fast == slow，这个时候返回true

142. 环形链表 II[mid]

和141一样，但是要求第一次遇到环的时候环的起点位置。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

import collections

class Solution(object):
    def detectCycle(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        hashmap = set()
        current = head
        while current:
            if current in hashmap:
                return current
            hashmap.add(current)
            current = current.next

        return None

• 解法一还是弗洛伊德法，也就是141的方法，最高效O（1）但是难懂，我选择解法二，也就是哈希表查表秒杀
• 关键：哈希表不能用带默认值int的，因为链表和数组不一样没法确定节点index，所以set()才是最好的，也就是说循环遍历链表的同时将节点整个加入set中（add），然后同时判断set里面有没有重复的节点，有的话直接返回，没有的话循环到最后肯定会跳出，也就是current.next最后肯定是none，返回false即可。

160. 相交链表[easy]

给定两个链表，判断他们到那个节点会相交，相交后成为一个链表，也就是【Y】逆时针90度的样子

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

class Solution(object):
    def getIntersectionNode(self, headA, headB):
        """
        :type head1, head1: ListNode
        :rtype: ListNode
        """
        if headA is None or headB is None:
            return None

        pA = headA
        pB = headB

        while pA != pB:
            if pA is None:
                pA = headB
            else:
                pA = pA.next
            if pB is None:
                pB = headA
            else:
                pB = pB.next

            # 简洁版：
            # pA = pA.next if pA else headB
            # pB = pB.next if pB else headA
        
        return pA

• 核心思路：一个指针从走完A链表再走B链表 == 另一个指针走完B链表再走A链表，如果他们有交点，那到最后两指针走的路肯定相等，并且最后的交汇处就是交点：假如AB链表相交后的链表为C，那就有指针1的路径A+C+B，指针2的路径B+C+A,显然这两个路径是相等的，并且都走到底后就该走C了，他们会相交。如果没有交点的话他们不相交，最后两个指针的值肯定都是none。注意while的条件就是他们不相交就一直遍历，如果不相交最后也会因为都是none而跳出循环。
• 或者用哈希表存A链表的每一个节点也可以，再遍历B，遍历的时候去哈希表里查有没有和A重复，重复的第一个节点就是相交节点，直接返回

206. 反转链表[easy]

将给定链表反转

两种方法都常考，分别是指针法和递归法

• 指针法可以把链表想象成火车，A→B→C→D，现在对B施工（current）想将它的车头和车尾调过来，第一步就是先把B前头的牵引B→C系上安全绳（tmp = current.next）防止前面的车厢丢了，第二步就可以将牵引接到A上了（current.next = prev），完事后需要到下个车厢C去继续调转车头车尾，需要从B“过去”，B车厢则是之前的工作地(current = prev)此时current还是B车厢，最后我们到了C车厢，C车厢则成为现在的工作地（current = tmp）
• 原链表:1→2→3→4(pre=null)
  1: null←1 2→3→4(pre=1)
  2: null←1←2 3→4(pre=2)
  3: null←1←2←3 4(pre=3)
  4: null←1←2←3←4(pre=4)

1
2
3
4
5
6
7
8
9
10

prev = None
current = head

while current:
    tmp = current.next
    current.next = prev
    prev = current
    current = tmp

return prev # 返回的是prev！！！！

• 递归法：利用head和head.next==None的条件来递归调用自己

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

class Solution(object):
    def reverseList(self, head):
        """
        :type head: Optional[ListNode]
        :rtype: Optional[ListNode]
        """
        if head is None or head.next == None:
            return head # 链表为空或者只有一个节点直接返回本身,同时作为递归停止条件
        
        newHead = self.reverseList(head.next)

        head.next.next = head
        head.next = None

        return newHead

• 假如要反转1→2→3，那么递归法首先会执行到newHead = self.reverseList(head.next), 其中head==1，所以head.next==2，把2作为head再调用自己一次，此时的newHead = self.reverseList(1)暂停，等待递归结果返回，现在进入newHead = self.reverseList(2)，
• 2里面同样不满足if的递归停止判断，来到newHead = self.reverseList(2.next) 也就是 self.reverseList(3)，到了 self.reverseList(3)，满足了if条件，return head==3，这下 self.reverseList(2)等到了返回的结果也就是newHead = 3，但是在 self.reverseList(2)中head还是2，head.next == 3,
• 我们直接反转链表，也就是将head.next.next = 2，也就是将3的next直接设为2（这个时候head还是2，而newhead才是3），就是当前节点这样就出现了1 -> 2 <-> 3，2和3双头都链接了，需要断掉2→3这个链子，所以下一步就是head.next = None也就是2.next = none，结果就是1 -> 2 <- 3，return newHead回去self.reverseList(1)，相同操作就能得到null←1←2←3了,最后返回的头节点就是newHead==3

24. 两两交换链表中的节点[mid]

将一个链表里的元素两两分别交换：1-2-3-4 ⇒ 2-1-4-3

• 方法一，迭代法，基本就是三个指针两两交换，但是这里最关键也是最方便理解的是设定一个prev指针指向head，并且以prev的视角来交换节点。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

class Solution(object):
    def swapPairs(self, head):
        """
        :type head: Optional[ListNode]
        :rtype: Optional[ListNode]
        """
        dummy_head = ListNode(0,head)
        prev = dummy_head
        while prev.next and prev.next.next:
            node1 = prev.next
            node2 = prev.next.next

# prev->1->2->3->4  前后两个链不能断，也就是prev.next和node2.next
            prev.next = node2
            node1.next = node2.next
            node2.next = node1
            prev = node1

        return dummy_head.next

• 首先需要设置一个dummy_head用来输出变化完后的整个数组，然后再设置一个prev指向head
• 条件是while prev.next和prev.next.next 都不为none，当然可以设值current，但是这里以prev的视角来会更简单。并且设node1=prev.next, node2=prev.next.next
• 接下来开始迭代的经典操作，prev.next = node2 , node1.next = node2.next, node2.next = node1注意，这三个顺序是可变的，关键在于有没有错误的把后面的链接断掉。最后将prev移动到node1：prev = node1进行下一轮while
• 递归法暂时先不看，并且递归法空间复杂度高一点

25. K一个组翻转链表[hard]

给定一个链表和一个k，将链表按长度为k的子链表进行划分，再将每个子链表内部进行翻转，如果划分到最后长度不够k则这部分不用翻转。 1→2→3→4→5, k=2 ⇒ 2→1→4→3→5

这题主要分3步，1.按k划分 2.子链表内部翻转 3.翻转后的结果拼接到原来链表上

• 所以先考虑怎么按k来划分。把长度为k的子链表看成一个整体节点的话，对于这个整体我们需要它前面的指针（group_prev）和后面的指针（group_next）,然后还有指向它自己的指针kth
• 所以使用dummy_head方便表示边界和输出，并且将group_prev和他一样指向头部节点。接下来就是遍历链表到k的位置，如果链表的长度不够k则没法翻转任何地方，所以直接跳出，返回。这里的关键是kth = group_prev，kth也从头节点的前一个开始，这样for循环遍历完后kth就会在这一子链表的最后一个节点。同样第二个关键则是还需要判断一次 if kth is None:
• 最关键的就是kth到位后，需要把现在的子链表和链表的后续节点链接起来，这样才不会丢失后续节点，也就是 group_next = kth.next。同样也需要保存最开始的节点这样能够在翻转完后能够将开始节点链接到后续节点head_of_group = group_prev.next，因为翻转后它就成子链表的最后节点了。此时group_next指向后续节点，group_prev指向子链表第一个节点前面的节点。
• 接下来开始翻转子链表，关键在于需要用到prev和curr专门来对翻转子链表进行操作。（和206题一样）此时prev = group_next(不同于206，因为206反转完后最后一个节点前面是null，而这题前面则是下一组的第一个节点)，curr = group_prev.next
• 翻转子链表内容就和206完全一样，想象一个火车的车厢对调，先系安全绳：next_tmp = curr.next, 然后翻转当前车厢: curr.next = prev, 翻转完成后需要移动到下一个车厢继续，所以现在的上一个车厢则成了刚才施工的车厢：prev = curr, 现在的车厢在哪？在安全绳的后面: curr = next_tmp。
• 完成后的关键就是拼接回后续链表（和前面的链表）上，也就是将kth所指位置给到group_prev的next上，这样就能把上一组的末尾节点通过group_prev链接到刚刚翻转完成的这一组的头节点上：group_prev.next = kth（kth在翻转前是这一组的最后面，翻转后就到最前面了，要将前面一组的头部节点和它链接）, 然后就是链接后面节点，head_of_group本来是这组的头节点，翻转完后就到最后一个节点了（下一组的前面一个节点），通过这个公式将group_prev 链接到下一组的前面一个节点：group_prev = head_of_group，注意不能把上面这两个公式一块看，要分开看。至此结束，循环结束后返回dummy_head.next就能得到整个链表

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

class Solution(object):
    def reverseKGroup(self, head, k):
        """
        :type head: Optional[ListNode]
        :type k: int
        :rtype: Optional[ListNode]
        """
        if head is None or k == 1:
            return head
        
        dummy_head = ListNode(0, head)
        group_prev = dummy_head
        while True: #
            kth = group_prev #
            for _ in range(k): #
                if kth is None:
                    break
                kth = kth.next
            
            if kth is None:
                break
            
            group_next = kth.next
            head_of_group= group_prev.next #

            prev = group_next
            curr = group_prev.next

            for _ in range(k):
                next_tmp = curr.next
                curr.next = prev # 
                prev = curr
                curr = next_tmp

            group_prev.next = kth #
            group_prev = head_of_group #
        
        return dummy_head.next

Created by: Yuanpeng QU
Created time: 2025年8月14日 11:27

15. 三数之和[mid]

给一个数组nums，求 满足nums[i]+nums[j]+nums[k]==0的所有[nums[i],nums[j],nums[k]]组合，顺序没有要求，但是不能有重复的组合出现

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

class Solution(object):
    def threeSum(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        nums.sort()
        
        n = len(nums)
        # left, right = 1, n-1 关键2
        res = []

        for k in range(n):
            if nums[k] > 0:
                break

            if k > 0 and nums[k] == nums[k-1]:
                continue
            
            left, right = k+1, n-1 # 关键2

            while left < right:
                if nums[left] + nums[right] + nums[k] < 0: # 关键2
                    left += 1
                elif nums[left] + nums[right] + nums[k] > 0:
                    right -= 1
                else:
                    res.append([nums[k],nums[left],nums[right]])

                    while left < right and nums[left] == nums[left+1]:# 关键1
                        left += 1
                    while left < right and nums[right] == nums[right-1]:
                        right -= 1
                    
                    left += 1 #关键2
                    right -= 1
        return res

• 我想到的地方：先把nums排序，这样就能用双指针做，也就是先固定一个k，再求nums[i]+nums[j]判断其是否等于-nums[k]从而得到一组结果。但是错误的是我想着同时挪动两个指针往中间靠了，所以没写出来。
• 关键1：去重，k和left和right所对应的nums的值可能和上一个或下一个重复，需要跳过，并且需要一个list保存结果
• 关键2：left, right = k+1, n-1要在for 里面这样才能确保left能够更新，并且nums[left] + nums[right] + nums[k] < 0 的时候是left+=1而不是>0的时候，仔细想想就知道如果nums[left] + nums[right]的值要小过结果的话，只有把nums[left]往大的值挪才有可能让结果==0。对于nums[right]也同理。 只有最后等于0的结果出现了才需要left和right都往中间挪，这是因为它们现在所在位置的值都被用上了，避免重复使用。

283. 移动零[easy]

给一个数组nums，将所有0移动到最后面

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

class Solution(object):
    def moveZeroes(self, nums):
        """
        :type nums: List[int]
        :rtype: None Do not return anything, modify nums in-place instead.
        """
        slow, fast = 0, 0
        
        while fast < len(nums):
            if nums[fast] != 0:
                nums[slow] = nums[fast]
                slow += 1
            fast += 1
        while slow < len(nums):
            nums[slow] = 0
            slow += 1
        
        return nums

• 关键思路：双指针（快慢指针版）
• 一开始就想错了不能用朝中间靠拢版的双指针，问题的关键在于使用fast遍历整个数组，slow则用于储存非0的数后+1，并且两个指针开始都指向0，这样就能保证slow和其左边的值都是非0的，最后等fast遍历完后将slow的右边全部赋0就可以了。
• 改进：用for循环替代while fast<len(nums): fast+=1和while slow < len(nums): slow += 1。这会更加python！

75. 颜色分类[mid]

给一个数组nums里面元素只有0，1，2，按顺序表示红白蓝，现在要求按照这个顺序把nums内所有的元素原地排序，不能用sort，进阶方法是只遍历一次

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

import collections
class Solution(object):
    def sortColors(self, nums):
        """
        :type nums: List[int]
        :rtype: None Do not return anything, modify nums in-place instead.
        """
        dict_num = collections.defaultdict(int)
        for i in range(len(nums)):
            if nums[i] == 0:
                dict_num[0] += 1
            elif nums[i] == 1:
                dict_num[1] += 1
            else:
                dict_num[2] += 1
        
        for j in range(len(nums)):
            if j < dict_num[0]:
                nums[j] = 0
            elif j < dict_num[0]+dict_num[1]:
                nums[j] = 1
            else:
                nums[j] = 2
            
        return nums  

• 我的做法：哈希储存+遍历2次
• 简单直观的想法就是遍历第一次找一个地方储存0，1，2出现的次数，再遍历一次将出现0，1，2出现的次数分别填上去
• 缺点是空间复杂度高
• 最优解是3指针，
• p0：指向 0 区的末尾。初始时 p0 = 0。[0, p0-1] 区间内的都是0。
• p2：指向 2 区的开头。初始时 p2 = len(nums) - 1。[p2+1, n-1] 区间内的都是2。
• curr：当前遍历到的元素的指针。初始时 curr = 0。

我们让 curr 指针从头到尾遍历数组，在 curr <= p2 的条件下循环，根据 nums[curr] 的值来执行不同的操作：

• 如果 nums[curr] == 0:
  • 说明这个 0 应该被放到 0 区。
  • 我们将 nums[curr] 和 nums[p0] 进行交换。
  • 交换后，p0 指向的元素已经处理完毕，所以 p0 向右移动一位 (p0 += 1)。
  • curr 指针也向右移动一位 (curr += 1)，继续检查下一个元素。
• 如果 nums[curr] == 2:
  • 说明这个 2 应该被放到 2 区。
  • 我们将 nums[curr] 和 nums[p2] 进行交换。
  • 交换后，p2 指向的元素已经处理完毕，所以 p2 向左移动一位 (p2 -= 1)。
  • 注意： 此时 curr 指针不能移动！因为从 p2 交换过来的那个新 nums[curr] 还没有被检查过，它可能是 0、1 或 2，需要下一轮循环来处理它。
• 如果 nums[curr] == 1:
  • 说明这个 1 就在它应该在的位置（在 0 区和 2 区之间）。
  • 我们不需要做任何交换，只需要移动 curr 指针，继续检查下一个元素 (curr += 1)。

循环在 curr 指针“追上”或超过 p2 指针时结束。此时，整个数组的排序就完成了。

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

from typing import List

class Solution:
    def sortColors(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        荷兰国旗问题解法 (三指针)
        """
        n = len(nums)
        # p0 指向 0 区的末尾边界
        # p2 指向 2 区的开头边界
        p0, p2 = 0, n - 1
        # curr 用于遍历数组
        curr = 0
        
        # 当 curr 还没有“追上” p2 时
        while curr <= p2:
            if nums[curr] == 0:
                # 发现 0，与 p0 指向的元素交换
                nums[curr], nums[p0] = nums[p0], nums[curr]
                # 交换后，p0 和 curr 都向前进一步
                p0 += 1
                curr += 1
            elif nums[curr] == 2:
                # 发现 2，与 p2 指向的元素交换
                nums[curr], nums[p2] = nums[p2], nums[curr]
                # 交换后，p2 向前一步
                # curr 不动，因为换过来的新 nums[curr] 需要被重新判断
                p2 -= 1
            else: # nums[curr] == 1
                # 发现 1，位置正确，curr 直接向前一步
                curr += 1

42.接雨水[hard]

典中典

给一个数组height表示各个位置上的方块个数（高度），求整个数组表示的图形能接多少个水方块

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

class Solution(object):
    def trap(self, height):
        """
        :type height: List[int]
        :rtype: int
        """
        left, right = 0, len(height)-1
        left_max, right_max = 0, 0
        total = 0

        if len(height) <= 2:
            return 0

        while left < right:
            if height[left] < height[right]:
                if height[left] >= left_max:
                    left_max = height[left]
                else:
                    total += left_max - height[left]
                left += 1
            else:
                if height[right] >= right_max:
                    right_max = height[right]
                else:
                    total += right_max - height[right]
                right -= 1
        
        return total

• 核心就是双指针（往中间靠拢版）
• 关键1：这题和11. 盛最多水的容器类似，都是双指针，不同的地方在于11可以通过算left和right围起来的面积来求最大值，而这题可能有多个水坑可以接水，所以需要设置左边和右边都要有个最大高度来确保装水的量。而最大高度则通过每次遍历指针的时候与其对比不断更新。
• 关键2：确保有最大高度后，只需要计算在遍历的时候当前的位置头顶上能够顶几个水方块即可，注意不需要知道当前水坑能够装多少，只需要计算每一个位置的水方块最后加起来就可以。而这个方块数则可以通过最大高度-当前高度来得到。
• 关键3：总数小于等于2的时候没法围成水坑，所以直接返回0

3. 无重复字符的最长子串[mid]

给一个字符串s，求它里面最长的无重复字符的子串长度，其中子串和子序列的区别要搞清楚。

1
2
3
4
5
6
7
8
9
10
11
12
13

left = 0
max_len = 0
char_set = set() 

for right in range(len(s)):
while s[right] in char_set:
char_set.remove(s[left])
left += 1
char_set.add(s[right])

max_len = max(max_len, right-left+1)
return max_len

• 模式：滑动窗口+哈希储存
• 想象一个窗口，从左开始，一直把不重复的元素放入set中，直到right遍历到set里重复的元素，这个时候就需要按顺序从左开始删除元素，直到删除到set里没有重复元素为止，所以要用while而不是if，最后right走到终点后right-left+1就是最大长度
• 关键：使用set储存窗口元素，为什么不用defaultdict（int）？是因为我们只需要判断x字符在不在哈希表里，而不需要判断有多少个x字符在不在。set集合可以用add和remove来添加和删除
• 需要不断更新max_len是因为right到最后，但是最长子串可能在中间，时刻更新max_len确保一直是最大的

239. 滑动窗口最大值[hard]

给定一个数组nums，再给定一个滑动窗口大小k，输出滑动窗口从头到尾中每个窗口的最大值组成的list

1
2
3
4
5
6
7
8
9
10
11

输入：nums = [1,3,-1,-3,5,3,6,7], k = 3
输出：[3,3,5,5,6,7]
解释：
滑动窗口的位置                最大值
---------------               -----
[1  3  -1] -3  5  3  6  7      3
 1 [3  -1  -3] 5  3  6  7      3
 1  3 [-1  -3  5] 3  6  7      5
 1  3  -1 [-3  5  3] 6  7      5
 1  3  -1  -3 [5  3  6] 7      6
 1  3  -1  -3  5 [3  6  7]     7

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

class Solution(object):
    def maxSlidingWindow(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: List[int]
        """
        left = 0
        right = left + k - 1 
        res = []
        max_i = float('-inf')
        while right < len(nums):
            for i in range(left, right+1):
                max_i = max(max_i, nums[i])
            res.append(max_i)
            right += 1
            left += 1
            max_i = float('-inf')

        return res

• 我直接暴力解决，但是超时了，因为时间复杂度为O(N*k), N和k都很大时运算量爆炸
• 最佳解法是用双向队列deque解决，时间复杂度为O(N)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

   deque = collections.deque() # 创建小队
   res = []

   for i in range(len(nums)):
       
       # 规则3， 队头离开了滑动窗口需要请走
       if deque and deque[0] <= i - k:
           deque.popleft()
       # 规则2， 每个入队的元素需要和队里所有成员“比武”，比不过的老队员全部踢出去，这样就能保证每一个循环的队头都是最大的
       while deque and nums[deque[-1]] < nums[i]:
           deque.pop()
       # 规则1， 新人入队， 队里只存nums的index，而不存值
       deque.append(i)

       # 窗口形成后，将每次队里的最大值（队头）取出
       if i >= k - 1:
           res.append(nums[deque[0]])
return res

• 为什么要用双向队列？

  • 用暴力法 O(N*k) 之所以慢，是因为每当窗口向右滑动一格时，我们都重新在 k 个元素里找了一遍最大值。这里面有大量的重复劳动。
  • 比如窗口从 [1, 3, -1] 滑动到 [3, -1, -3]。在 [1, 3, -1] 中，3 是最大值。当 1 离开，-3 加入时，我们其实不需要重新比较 3 和 -1。我们只需要让新来的 -3 和之前的最大值 3 比较一下就行。
  • 但问题是，如果离开的元素恰好是最大值怎么办？比如从 [3, -1, -3] 滑动到 [-1, -3, 5]，此时最大值 3 离开了，我们就需要知道剩下元素里的“第二大值”是谁。
  • 所以，核心难点在于：我们需要一个数据结构，它能帮我们快速知道“当旧的最大值离开窗口后，新的最大值是谁？”

• 用一个“精英小队”来解决问题 (双端队列 Deque 的比喻)

  想象一下，我们不让窗口里的所有 k 个成员都参与“比武招亲”，而是组织一个“精英小队”（这就是我们的双端队列 Deque）。

  这个小队有几条非常严格的规矩：

  1. 队员身份：小队里只记录队员的编号（即数组索引 index）。
  2. 入队规矩（从队尾进）：新人 A 想要入队时，要从队尾开始，跟前面的老队员 B、C、D … 挨个比武。如果老队员打不过新人 A (nums[老队员] < nums[A])，那么这个老队员就直接被踢出队伍（从队尾踢出）。A 会一直踢到遇见一个比他强的，或者队伍里没人了，他才从队尾站进去。
  3. 出队规矩（从队头出）：我们只关心队头的那个人。如果发现他的编号太老了（已经滑出窗口范围了），就把他从队头请出去。

  这个规矩带来了什么神奇效果？

  • 因为规矩2的存在，这个“精英小队”从队头到队尾，永远是按“武力值”（即 nums 的值）从大到小排列的。
  • 因此，队头的那个队员，永远是当前小队里最能打的，也就是当前窗口的最大值！

• 这样顺序就是，先创建一个deque，用来储存index，nums里面的第一个值进来后先判断规则3和规则2（最前面有判断deque是否为空）保证第一个元素能直接进来。然后第二个元素进来后需要和第一个元素所对应的nums值进行比较，如果赢了那就把第一个踢掉，值最大的index当队长！保证队头的index对应的值一定是这次for里最大的。

• 以此类推，先等到遍历到窗口长度的时候（i≥k-1,也就是nums的下标到长度k的时候）取出当前窗口最大的队头记录，然后到下一轮循环的时候根据规则3判断窗口的左边界i-k是否已经比队头的index大了将小的index对应的队头移出去就完成移动了。

• 注意最后的if i≥k-1表示是否已经形成窗口，形成窗口后窗口就不会消失了也就是说之后的for循环代表的窗口头边界往前移一位那就会产生一个新的窗口最大值。

438. 找到字符串中所有字母异位词[mid]

给两个字符串s和p，找出s中满足p的所有异位词，异位词就是不管字母顺序只管字符串长度是否相等，字母是否相同。

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

import collections
class Solution(object):
    def findAnagrams(self, s, p):
        """
        :type s: str
        :type p: str
        :rtype: List[int]
        """
        s_len, p_len = len(s),len(p)
        if s_len < p_len:
            return []
        
        p_dict = collections.defaultdict(int)
        window = collections.defaultdict(int)
        res = []

        for i in range(p_len):
            p_dict[p[i]] += 1
            window[s[i]] += 1
        
        if window == p_dict:
            res.append(0)
        
        for j in range(p_len, s_len):
            s_in = s[j]
            s_out = s[j-p_len]

            window[s_in] += 1
            window[s_out] -= 1

            if window[s_out] == 0:
                del window[s_out]

            if window == p_dict:
                res.append(j - p_len + 1) # 这是子串的头字符的index
        return res

• 这题用滑动窗口+哈希，看到固定字符串长度就想到滑动窗口
• 问题的关键在于我们创建的两个带默认值的哈希表，和239题不一样，这次的滑动窗口需要我们先填充元素，也就是说我们创建p的哈希表和window哈希表，p_dict初始化就是将p的值全部放进去变成{’a’:1, ‘c’:2, …}。 而window哈希表也需要初始化，内容就是把它放到s里的第一组值。
• 这样我们在初始化之后就可以开始挪动窗口了，指向窗口头部的for循环直接从p_len位置开始直到s结束位置，窗口头部指针指向的值加入window，并且将窗口尾部的指针指向的值从window里扔掉，这样就是window[s[j]]+=1, window[s[j-p_len]] -=1
• 不出错的关键在于如果window里面被删除的元素没了的话，要使得if window == p_dict生效，一定需要把归零的元素del 掉
• 最后通过if window == p_dict判断窗口里的子串是否是p的异位，将是的子串的开头字符的下标j-p_len+1存入res即可。

506. 和为 K 的子数组[mid]

给定一个数组nums，求能够满足和为k的所有子数组，其中的元素是连续的

这题是经典的前缀和的应用题，什么是前缀和？给定一个长度为j+1的数组nums，有

1
2

prefix_map[i] = nums[0]+…+nums[i]
prefix_map[j] = nums[0]+…+nums[i] + nums[i+1]+…+nums[j]

想要求一个连续子数组的和sum(nums[i,..,j])可以通过prefix_map[j]-prefix[i-1]得到

**最关键：**所以这题能够转化为想要求子数组和为k(nums[i~j])的数目，有：

prefix_map[j] = prefix_map[i-1]+k，也就是prefix_map[i-1] = prefix_map[j] - k

这个时候prefix_map[j]就是for循环遍历的指针指到的位置之前的和，可以记为curr_sum,而k是满足条件的子数组的和，prefix_map[i-1]则是要通过上面公式来在数组中比对的和

• 所以这个时候就明确了：我们需要将cur_sum每走一步就记录一次，把记录存在hashmap里，记录完了后再和k相减，看看hashmap里有没有满足相减结果的值，有的话就说明现在有一个前缀和满足了，计数器+1
• 关键1：在hashmap初始化的时候不要忘了0这个数，因为有可能会出现nums的两个值和刚好被k整减，最后为0的结果，或者是nums里面刚好有等于k的数。所以初始化一定要prefix_map[0] += 1
• 关键2：count += prefix_map[target_sum] 而不是count += 1
• 关键3：prefix_map[curr_sum] += 1 这个一定放在if后面，因为if里面涉及到了prefix_map的更新，也就是如果curr_num等于target_sum的情况（k=0时）如果先把 current_sum 的计数值加了1，然后又用 current_sum 本身作为 target 去查找，你就会把自己刚刚放进去的那个计数值也算进去，导致重复计算。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

import collections
class Solution(object):
    def subarraySum(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: int
        """
        prefix_map = collections.defaultdict(int)
        prefix_map[0] = 1
        curr_sum, count = 0, 0

        for j in range(len(nums)):
            curr_sum += nums[j]

            target_sum = curr_sum - k
            if target_sum in prefix_map:
                # count += 1 不对，要存的是target_sum的个数，也就是找到多少组
                # 并且count += 1 会导致某个prefix_map[x] = 2的情况时漏掉一次，如nums = [1, -1, 1, -1, 1], k = 1
                count += prefix_map[target_sum]

            prefix_map[curr_sum] += 1 #这个一定放在if后面

        return count

Created by: Yuanpeng QU
Created time: 2025年8月13日 21:29

HOT100 抱佛脚计划

1.两数之和(Two Sum)[easy]

一句话概括题意：在一个数组里找两个数，让他们的和等于指定目标值

思路：

• 我自己的思路：暴力求解O(N^2) 不是最优

1
2
3
4

for i in range(len(nums)):
for j in range(i+1,len(nums)):
if nums[i] + nums[j] == target:
return [i, j]

• 核心：用hashmap (python里面的字典)，时间为O(N), i+j == target可以转化为 j == target - i

1
2
3
4
5
6
7

hashmap = {}
for idx, i in enumerate(nums):
j = target - i
if j in hashmap:
return [idx, hashmap[j]]
else:
hashmap[i] = idx # 把{idx:i}存入哈希表

• 注意：hashmap[value] = key，或者hashmap[key] = value 语法上都对，但是取决于查询目标。在“两数之和”里，我们的目标是查询值，所以必须用值来做 key。

76. 最小覆盖子串[hard]

给定两个字符串s和t，求s里包含t中所有字符的最小字符串，没有就返回“”

根本想不到（

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

import collections
class Solution(object):
    def minWindow(self, s, t):
        """
        :type s: str
        :type t: str
        :rtype: str
        """
        need = collections.defaultdict(int)
        window = collections.defaultdict(int)
        left, right = 0, 0
        start, valid = 0, 0

        min_len = float('inf') # 初始化最小字串的长度为无穷

        for char in t:
          need[char] += 1 # need字典初始化，将需要比对的t转换为字符后储存在字典里，这里的+=1 则能计算每个字符数
        
        while right < len(s):
          c = s[right]
          right += 1

          if c in need:
            window[c] += 1
            
            # 关键1
            if window[c] == need[c]: # 这个if是在上一个的里面
              valid += 1

# 关键2
          while valid == len(need):
            
            if right - left < min_len:
              start = left # 这个也在if里
              min_len = right - left
            
            # 这两句在if后面
            d = s[left]
            left += 1

# 关键3
            if d in need:
              if window[d] == need[d]:
                valid -= 1
              window[d] -= 1
        return "" if min_len == float('inf') else s[start: start + min_len]

• 最主要的记法：滑动窗口+2x哈希表
• 两个哈希表，一个need将t字符串里的所有字符按照{字符：出现次数}保存，另一个哈希表window用于记录s字符串中滑动窗口两个指针中间的窗口部分的字符数量，同样按照上面的格式储存，need显然只需要执行一次，也就是将t储存后剩下的都是起判断作用
• 哈希表初始化： import collections → need = collections.defaultdict(int) 因为value是字符次数
• **关键1：**使用一个valid变量来判断读取到某个属于need的字符c的时候window[c]是否和need[c]次数相等，相等就说明这个字符已经达到输出要求了，valid+=1，这样最后valid ==len(need)的时候window里面就已经有所有need数量的字符了。
• **关键2：**关键1过后，左边的指针left就可以往右边移动了，当然移动之前得先确认好现在的最小字符串长度是多少（因为是第一次达到关键1结果，所以直接min_len = right-left）注意min_len初始化的时候是min_len = float(’inf’)无穷大，因为要用作判断if right-left < min_len，这表示最小字符串有更小的值了，需要更新。更新完min_len后就可以将left往前挪1了，挪的同时需要保存原来的left指向的地方（d = s[left]），这里还需要在开始部分定义一个start=0用于保存最小字符串的起始位置。
• **关键3：**对d进行判断，如果被删掉的这个d是属于need的话，那就还需要再判断一下如果窗口里面d的数量已经和need 相等了，那被删掉后就不满足valid == len(need)条件了，也就是说这个时候valid要-1，跳出内循环while，for循环重新判断新的right和c。如果窗口里d的数量还是比need里的多，就说明还能继续删。

11. 盛最多水的容器[mid]

给一个数组height，元素表示高度，求这些统计图里的柱子围起来的水的最大体积，显然水的多少由最矮那边决定。

• 模板：典中典双指针（两侧靠拢版）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

class Solution(object):
    def maxArea(self, height):
        """
        :type height: List[int]
        :rtype: int
        """
        if len(height) <= 1: # 其实可以直接max_area = 0就行了
            return 0

        left, right = 0, len(height)-1
        max_area = 0
        while left < right:
            tall = min(height[left], height[right])
            area = tall * (right - left)
            if area > max_area:
                max_area = area
            if height[left] < height[right]: # 高度如果相等的话向左向右移动都可以！！
                left += 1
            else: # 这里是左移了
                right -= 1
        return max_area
        

• 这题想到了tall = min(height[left], height[right])以及使用max_area = area来储存最大体积，但是唯一的错误就是把两个指针都设在左边了，最开始写的是left, right = 0, 1, while的条件成了：while right < len(height): 这样其实到最后还是变成暴力求解，复杂度为N平方
• 关键就是左右两边向中间靠拢的双指针，而不是同向。并且应该是哪边矮则哪边向中间靠拢，因为高的那边靠拢的话得到的结果可能还是矮的那边更矮，并且向中间靠拢底长也变短了。

Created by: Yuanpeng QU
Created time: 2025年8月13日 10:43

第一部分：神经网络的核心组件 (Core Components of Neural Networks)

1.1 激活函数：从经典到现代

激活函数是神经网络的灵魂，它负责向网络中引入非线性，使得网络有能力学习和拟合现实世界中复杂的非线性关系。如果没有激活函数，多层神经网络本质上等同于一个单层的线性模型。

1.1.1 Sigmoid & Tanh：经典饱和函数的特性与局限性

1. Sigmoid 函数

• 公式：

  $$f(x) = \frac{1}{1+e^{-x}}$$

• 核心特性：

  • 将任意实数输入压缩到 (0, 1) 区间内。
  • 这个特性使其输出可以被直观地解释为概率，因此在逻辑回归以及各类分类模型的输出层中，当需要预测一个概率时，Sigmoid 仍然是标准选择。特别是在CTR/CVR预估中，它的地位不可动摇。

• 主要局限性 (面试重点):

  1. 梯度消失 (Vanishing Gradient): 这是 Sigmoid 最致命的弱点。当输入值的绝对值很大时（例如 x > 5 或 x < -5），Sigmoid 函数的曲线非常平坦，其导数（梯度）趋近于0。在深度网络中，根据链式法则，梯度在反向传播时会逐层相乘。多个接近0的小数相乘，会导致传到浅层网络的梯度变得无限小，使得浅层网络的参数几乎无法更新，模型也就学不动了。
  2. 输出非零中心 (Non-Zero-Centered): Sigmoid 的输出恒为正数。这会导致后一层神经元的输入全是正的，在反向传播计算梯度时，会导致对权重的梯度方向要么全为正，要么全为负。这种更新方式效率低下，收敛过程会呈现“Z”字形，拖慢训练速度。

2. Tanh (双曲正切) 函数

• 公式：

  $$\tanh(x) = \frac{e^x - e^{-x}}{e^x + e^{-x}}$$

• 核心特性：

  • 可以看作是“加强版”的 Sigmoid，它将输入压缩到 (-1, 1) 区间。
  • 优点： 它的输出是零中心的，解决了 Sigmoid 的非零中心问题，因此在实践中通常比 Sigmoid 收敛更快。
  • 局限性： 它依然是一个饱和函数，在输入值绝对值很大时，两端同样非常平坦，所以仍然存在梯度消失的问题，只是相比 Sigmoid 有所缓解。

总结： 由于梯度消失的致命缺陷，Sigmoid 和 Tanh 目前已很少被用于深度神经网络的隐藏层，它们的位置被下面要讲的 ReLU 所取代。

1.1.2 ReLU：现代网络的默认选择、优点与“死亡”问题

ReLU (Rectified Linear Unit, 修正线性单元) 是深度学习领域最重要的突破之一，它极大地促进了深度网络的成功训练。

• 公式：

  $$f(x) = \max(0, x)$$

• 核心特性与优点 (面试重点):

  1. 有效解决梯度消失： 在输入为正数时 (x > 0)，ReLU 的导数恒为1。这意味着梯度在反向传播过程中可以完整地通过激活函数，不会像 Sigmoid/Tanh 那样逐层衰减。这是它能够支持训练非常深的网络的最主要原因。
  2. 计算效率极高： 实现上只是一个简单的取最大值操作，相比 Sigmoid/Tanh 的指数运算，计算成本极低，无论在前向传播还是反向传播中都非常快。
  3. 引入稀疏性： 当输入为负数时，ReLU 的输出为0。这会使得网络中的一部分神经元“关闭”，形成稀疏的激活状态。这种稀疏性一方面降低了计算量，另一方面也被认为有助于降低过拟合。

• 主要局限性：

  1. “死亡 ReLU” 问题 (Dying ReLU): 这是 ReLU 最著名的缺点。在训练过程中，如果一个神经元接收到的输入，由于某次不恰当的权重更新（比如学习率过大），导致其之后对于整个训练集的所有输入都恒为负数，那么这个神经元的输出将永远是0。由于 x<0 时 ReLU 的梯度也为0，这个神经元的权重将永远无法再得到更新。它就像一个“坏死”的神经元，不再对任何输入有响应，在网络中失去了作用。
  2. 输出非零中心： 和 Sigmoid 一样，ReLU 的输出也非零中心（恒大于等于0），这会带来一些优化上的低效，但相比其解决梯度消失的巨大优点，这个问题通常被认为是次要的。

1.1.3 Swish & GELU：更平滑、更先进的激活函数探索

在 ReLU 成为主流之后，研究者们并未停止探索的脚步。他们希望找到一种激活函数，既能拥有 ReLU 解决梯度消失的优点，又能克服其“硬拐点”（在0处不可导）和“死亡”等问题。Swish 和 GELU 就是其中的佼佼者。

1. Swish 函数

• 公式： f(x)=x⋅σ(x)，其中 σ(x) 是 Sigmoid 函数。
• 核心思想：自门控 (Self-gating)。 函数的输出是输入 x 本身与一个由 x 生成的“门” σ(x) 的乘积。这个门的取值在 (0, 1) 之间，可以被看作是一个软性的、连续的开关，决定了原始输入 x 有多大比例可以通过。
• 特性与优点：
  • 平滑连续： Swish 在所有点上都是可导的，解决了 ReLU 在0点的硬拐点问题，这通常有利于优化过程。
  • 非单调性： 在负值区域，Swish 的函数图像会先轻微下降再上升。这种非单调的特性被认为增加了模型的表达能力，使其能拟合更复杂的关系。
  • 经验性成功： Swish 最初是由 Google 通过自动化架构搜索发现的，在许多深度模型上的实验表明，它的性能通常略优于 ReLU。

2. GELU (Gaussian Error Linear Unit) 函数

• 公式： f(x)=x⋅Φ(x)，其中 Φ(x) 是标准正态分布的累积分布函数 (CDF)。
• 核心思想：概率化的 ReLU。 GELU 的设计思想更具理论性。它可以被理解为对输入 x 进行的一种随机正则化。Φ(x) 代表了“从标准正态分布中采样的值小于x”的概率。因此，GELU 的输出可以看作是输入 x 在其可能被“激活”（即其值在统计上足够显著）的概率下的期望值。
• 特性与应用 (面试重点)：
  • 理论驱动： 其设计与 Dropout 和 Zoneout 等正则化方法有深刻的理论联系。
  • 性能卓越： GELU 是 Transformer 架构（如 BERT, GPT）中前馈网络层（FFN）的标准激活函数。提到这一点可以充分展现你对前沿模型的了解。

Swish 与 GELU 的关系：
它们的函数形状和性能表现都非常相似。在实践中，Swish 可以被看作是 GELU 的一个非常有效且形式更简洁的近似。它们的核心区别在于设计思想：GELU 源于概率理论，而 Swish 源于实验搜索。

1.1.4 GLU (门控线性单元)：一种智能的信息流控制机制

GLU 不是一个简单的、作用于单个神经元的激活函数，而是一种更复杂的、控制信息流的网络结构单元。

• 公式： GLU(x,v)=x⊙σ(v)，其中 ⊙ 代表逐元素相乘。
• 工作机制：
  1. 输入分裂： 将上一层的输出 Tensor 在特征维度上分成两半，得到 x 和 v。
  2. 信息流 (x)： 作为主要的待处理信息。
  3. 控制门 (v)： 作为“阀门”的控制信号。它会经过一个 Sigmoid 函数 σ(v)，生成一个值在 (0, 1) 之间的门控向量。
  4. 信息过滤： 将信息流 x 与其对应的门控向量 σ(v) 进行逐元素相乘。这样，门控向量中的每个值就决定了信息流 x 中对应维度的信息有多大比例可以通过。如果门控值为0，则信息被完全阻断；如果为1，则信息无损通过。
• 核心价值： GLU 赋予了网络一种动态的、依赖于数据自身来控制信息流的能力。这比静态的、一成不变的激活（如ReLU）要灵活得多。
• 应用与联系：
  • 这个“门控”思想是 LSTM 和 GRU 等循环神经网络的核心。
  • Swish 函数 x * σ(x) 可以被视为 GLU 的一种特例，其中信息流和控制门都来自同一个输入 x。
  • 在现代的 Transformer 模型中，使用 GLU 的变体（如 SwiGLU, GeGLU）来构建前馈网络层，已经成为提升模型性能的有效手段。

1.1.5 基础辨析：为什么不用 sin/cos 作为激活函数？

这是一个很好的“第一性原理”问题，考察你对激活函数根本作用的理解。在标准的分类、回归等任务中，sin/cos 不被用作激活函数，主要有以下三个原因：

1. 周期性导致的“多对一”歧义：
   这是最根本的问题。由于 sin(x) = sin(x + 2π)，多个不同的输入会映射到完全相同的输出。这给模型的学习带来了巨大的歧义。在反向传播时，如果输出层出现某个误差，模型将无法判断这个误差是由哪个输入周期引起的，导致梯度更新方向不明确，模型难以收敛。
2. 不稳定的周期性梯度：sin(x) 的导数是 cos(x)，其值在 [-1, 1] 之间周期性地来回震荡，并且会周期性地取到0。对于深度网络，我们希望梯度能够稳定地、一致地传播。一个来回变换正负、大小不一且会周期性消失的梯度，会使得网络的训练过程非常不稳定，权重更新摇摆不定，难以走向最优。
3. 缺乏理想的函数特性：
   主流的激活函数通常具备一些理想的特性来帮助学习。例如，ReLU 提供了单侧抑制和稀疏性，并且其激活值没有上限；Sigmoid 提供了 (0, 1) 的平滑门控。而 sin/cos 的输出被严格限制在 [-1, 1]，并且其非单调的波动特性，对于深度网络逐层提取和抽象特征这一通用目标来说，通常不具备优势。

1.2 权重初始化：让训练稳定起步

在开始训练神经网络之前，我们需要为模型的权重（Weight）和偏置（Bias）赋一个初始值。这个看似简单的步骤，却对整个训练过程的成败至关重要。一个好的初始化方案能让训练事半功倍，而一个糟糕的初始化则可能让网络从一开始就无法学习。

为什么权重初始化如此重要？如果初始化不当，主要会导致梯度消失或梯度爆炸问题。

• 初始化太小（比如都接近0）：
  输入信号 x 在逐层前向传播时，每经过一层，其方差（可以理解为信号的“能量”）都会缩小。传到深层时，信号可能已经变得非常微弱。在反向传播时，梯度也会逐层衰减，最终导致梯度消失。
• 初始化太大：
  信号在逐层传播时，其方差会不断被放大。传到深层时，激活值可能变得极大。这会导致两个问题：
  1. 对于 Sigmoid/Tanh 等饱和激活函数，巨大的输入值会使其落入“饱和区”，导致梯度为0，从而引发梯度消失。
  2. 在反向传播时，梯度也可能被逐层放大，最终变得极其巨大，引发梯度爆炸，这会导致参数更新过猛，使训练过程完全发散。

核心原则：
一个好的初始化方法，其核心目标是让网络各层的激活值和梯度的方差在传播过程中都能保持稳定，既不放大也不缩小。

1.2.1 Xavier 与 He 初始化：激活函数的“最佳拍档”

Xavier 和 He 是目前最主流的两种初始化方法，它们的选择与你所使用的激活函数紧密相关。

1. Xavier 初始化 (又名 Glorot 初始化)

• 设计目标/适用场景：
  专为对称的、以零为中心的激活函数设计，最典型的就是 Tanh 和 Sigmoid（在输入标准化后）。
• 核心思想：
  Xavier 的推导基于一个前提：激活函数在线性区工作，且输入和输出的均值为0。它试图让每一层输出的方差等于输入的方差，同时让反向传播的梯度方差也保持不变。
• 公式（思想）：
  它会根据一层的输入神经元数量 fan_in 和输出神经元数量 fan_out 来决定权重的初始方差。一个常见的实现是从一个均值为0，方差为 Var(W)=fanin+fanout2 的分布中进行采样。
  • 直观理解： 输入连接 fan_in 越多，输出的方差越容易被放大。为了抵消这种影响，权重的方差就需要相应地调小，所以 fan_in 和 fan_out 会出现在分母上。
• 不适用于 ReLU 的原因：
  ReLU 函数会将所有负数输入都置为0，这破坏了 Xavier 所需的“零中心”假设。更重要的是，这个操作会使得输出的方差大约变为输入方差的一半。因此，如果将 Xavier 初始化用于 ReLU 网络，信号的方差依然会逐层递减，当网络很深时，最终还是会导致梯度消失。

2. He 初始化 (又名 Kaiming 初始化)

• 设计目标/适用场景：
  专为 ReLU 及其变种（Leaky ReLU, PReLU 等） 量身打造。这是目前深度学习模型的标准选择。
• 核心思想：
  He 初始化精准地解决了 Xavier 初始化在 ReLU 网络中的问题。它考虑到了 ReLU 会使方差减半这一特性。
• 公式（思想）：
  它的实现是从一个均值为0，方差为 Var(W)=fanin2 的分布中进行采样。
  • 关键洞察： 与 Xavier 的一个常用变种（方差为 1/fan_in）相比，He 初始化的方差正好是其两倍。这个“乘以2”的操作，就是为了补偿 ReLU 激活函数带来的方差减半的损失，从而保证了信号方差在网络中能够保持稳定。

总结：

第二部分：模型的“导航系统”：损失函数 (The Model’s “Navigation System”: Loss Functions)

损失函数（Loss Function）的核心作用是衡量模型预测结果与真实标签之间的差距。模型训练的过程，本质上就是通过优化算法（如梯度下降）来不断调整参数，以最小化这个“差距”（即损失函数的值）。

2.1 分类问题的基石：交叉熵 (Cross-Entropy)

在所有分类任务中，无论是二分类还是多分类，交叉熵都是当之无愧的“标准”损失函数。要深刻理解交叉熵，我们必须先从它的“理论源头”——KL散度开始。

2.1.1 KL 散度与交叉熵的深刻联系

1. KL 散度 (Kullback-Leibler Divergence)：衡量分布的“距离”

• 核心思想：
  KL散度源于信息论，它用于衡量两个概率分布之间的差异性或**“距离”**。这里的“距离”不是几何距离，而是信息论意义上的距离。
  假设我们有两个分布：
  • P：真实世界的数据分布（真相）。
  • Q：我们模型预测出的概率分布（模型的认知）。
    KL散度 DKL(P∣∣Q) 度量了当我们用“模型的认知Q”来描述“真相P”时，相比于用“真相P”本身来描述，会额外产生多少信息损失或“意外”。
• 目标：
  在机器学习中，我们的目标就是让我们模型的认知 Q 无限地逼近真相 P，也就是最小化 DKL(P∣∣Q)。当两个分布完全相同时，KL散度为0。
• 关键特性： KL散度是非对称的，即 D_KL(P||Q)!=D_KL(Q||P)。我们始终使用前者，因为它惩罚的是“模型未能预测出真实情况”，这正是我们想要的。

2. 交叉熵 (Cross-Entropy)：KL散度的“实用替身”

既然我们的目标是最小化KL散度，为什么在实践中几乎所有的代码里写的都是交叉熵损失呢？答案就藏在下面这个关键的恒等式中：

$$H(P,Q) = H(P) + D_{KL}(P||Q)$$

• 公式解读：
  • H(P,Q)：分布 P 和 Q 的交叉熵。
  • H(P)：真实分布 P 的信息熵。它代表了真实数据本身所固有的不确定性或信息量。对于一个给定的、不变的数据集来说，H(P) 是一个固定的常数。
  • DKL(P∣∣Q)：P 和 Q 之间的 KL散度。
• “Aha!”时刻：
  我们的优化目标是最小化 DKL(P∣∣Q)。观察上面的公式，由于 H(P) 是一个无法被模型改变的常数，那么最小化等式右边的 DKL(P∣∣Q)，就完全等价于最小化等式左边的交叉熵 H(P,Q)！
• 为什么选择交叉熵？
  因为交叉熵的计算更简单、更方便。

  • KL散度的公式为：计算时需要用到 logP(x)。

    $$D_{KL}(P||Q) = \sum P(x) \log \frac{P(x)}{Q(x)}$$

  • 交叉熵的公式为：

    $$H(P,Q) = -\sum P(x) \log Q(x)$$

    交叉熵的计算只需要真实标签（P(x)，在分类中通常是0或1）和模型的预测概率（Q(x)），完全避开了对 logP(x) 的计算，在编程实现上更加直接。

总结：

“KL散度和交叉熵是衡量两个概率分布差异的两个高度相关的指标。KL散度是理论上的差异度量，也是我们模型优化的根本目标。而交叉熵可以被分解为‘真实数据的信息熵’与‘KL散度’之和。

在机器学习任务中，由于真实数据的信息熵是一个固定的常数，因此最小化交叉熵就等价于最小化KL散度。我们之所以在实践中都使用交叉熵作为损失函数，是因为它的计算形式比KL散度更简洁，不涉及对真实分布取对数，从而在实现上更方便，但达成的优化目标是完全一致的：即使模型的预测分布 Q 尽可能地接近真实的数据分布 P。”

2.1.2 二元交叉熵 (BCE) vs. 多元交叉熵 (CE)

虽然都叫交叉熵，但这两个术语是交叉熵原理在两种不同分类场景下的具体应用。其根本区别在于问题的性质和模型的输出层设计。

1. 二元交叉熵 (Binary Cross-Entropy, BCE)

• 应用场景：二分类问题 (Binary Classification)

  • 任务是“是/否”的判断，类别之间是“二选一”。
  • “搜广推”典型应用： 点击率(CTR)预估（点击/不点击）、转化率(CVR)预估（转化/不转化）、垃圾邮件检测（是/否）等。

• 模型输出层设计：

  • 最后一层网络通常只有 1个输出神经元。
  • 激活函数使用 Sigmoid，将输出值 z 映射为一个 (0, 1) 之间的概率 p，这个 p 代表了样本属于正类（类别为1）的概率。负类的概率则隐含为 1-p。

• 损失函数公式：

  $$L_{BCE} = -[y \log(p) + (1 - y) \log(1 - p)]$$

  • y 是真实标签（取值为0或1）。
  • p 是模型预测为正类的概率。
  • 工作原理： 当真实标签 y=1 时，损失为 log(p)，为了最小化损失，模型必须让 p 趋近于1。当 y=0 时，损失为 log(1-p)，模型必须让 p 趋近于0。这个公式巧妙地将两种情况统一了起来。

2. 多元交叉熵 (Categorical Cross-Entropy, CE)

• 应用场景：多分类问题 (Multi-class Classification)

  • 任务是“N选一”，类别之间是互斥的。
  • “搜广推”典型应用： 预测一个商品属于哪个品类（电子/图书/服装/…），预测用户年龄分段，识别图片中的物体属于哪个类别。

• 模型输出层设计：

  • 最后一层网络有 K个输出神经元（K为类别总数）。
  • 激活函数使用 Softmax，它将K个神经元的输出 z_1, ..., z_K 转化为一个K维的概率向量，向量中每个元素代表样本属于该类的概率，且所有元素之和为1。

• 损失函数公式：

  $$L_{CE} = -\sum_{k=1}^{K} y_k \log(p_k)$$

  • y 是 one-hot 编码的真实标签向量（如 [0, 1, 0] 表示真实类别是第2类）。y_k 是该向量的第k个元素。
  • p_k 是模型预测样本属于第k类的概率。
  • 工作原理： 由于 y 是 one-hot 向量，只有一个 y_k 为1，其余都为0。因此，上面的求和公式会简化为：LCE=−log(pc)，其中 p_c 是模型对那个唯一的正确类别所预测的概率。其目标就是最大化模型对正确答案预测的置信度。

2.1.3 核心辨析：为什么分类任务用交叉熵，而不是均方误差(MSE)？

这是一个在面试中极高频出现的问题，能清晰回答代表你对模型训练的原理有深刻理解。MSE 在回归任务中是王者，但用于分类任务则水土不服，主要有两大原因：

1. 梯度优化问题：MSE 在分类任务中会“偷懒”

• MSE的梯度陷阱：
  在分类任务中，我们通常用 Sigmoid/Softmax 将输出映射为概率。以 Sigmoid 为例，其函数曲线在两端（输出接近0或1）非常平坦，这意味着它的导数在这些区域非常小。
  MSE 损失的梯度，根据链式法则，正比于 (预测值 - 真实值) * Sigmoid的导数。
  问题来了： 当模型犯下弥天大错时（比如真实标签是1，模型预测概率接近0），“预测值-真实值”这一项很大，但“Sigmoid的导数”这一项却趋近于0！导致最终的梯度非常小。
  结论就是：模型在错得最离谱的时候，梯度反而消失了，学习得最慢。 这完全违背了我们希望模型“知错能改，大错快改”的初衷。
• 交叉熵的梯度优势：
  交叉熵损失函数经过数学上的巧妙设计，其梯度（相对于激活前的输出z）可以被推导和化简为一个非常简洁优美的形式：预测概率 - 真实值（即 p - y）。
  这就完美了！ 梯度的大小直接正比于预测误差的大小。模型错得越多，梯度就越大，参数更新的步长就越大，学习得就越快。这提供了一个非常稳定且高效的学习信号。

2. 损失函数的目标不匹配：MSE“关心错了重点”

• MSE的目标： 它衡量的是预测值与真实值（0或1）在数值上的距离。它希望预测的概率值 p 在数值上离 y 越近越好。
• 交叉熵的目标： 它衡量的是模型对正确答案预测的置信度。
• 举例说明： 假设真实标签为1。
  • 预测A：p=0.6，模型“有点把握”。
  • 预测B：p=0.1，模型“错得离谱”。
  • MSE的视角： 它觉得A的误差是0.4，B的误差是0.9。惩罚的差异是有限的。
  • 交叉熵的视角： 损失分别是 log(0.6) 和 log(0.1)。由于log函数的特性，对低概率的惩罚是指数级增长的。log(0.1) 比 log(0.6) 要大得多得多。它会给那个“错得离谱”的预测B一个极其巨大的惩罚，迫使模型去修正这个严重的错误。

总结：
“在分类问题中，我们选择交叉熵而不是MSE，主要有两个原因：

1. 从梯度来看： MSE与Sigmoid等激活函数结合时，在模型预测错误的情况下会出现梯度消失问题，导致学习缓慢。而交叉熵的梯度形式非常优雅，梯度大小与误差成正比，能提供更稳定高效的优化路径。
2. 从优化目标来看： MSE关心的是数值上的差异，而交叉熵关心的是模型对正确类别的预测置信度。交叉熵的对数形式能极大地惩罚那些“自信的错误预测”，这与分类任务的目标——最大化正确类别的概率——是完全一致的。”

2.2 回归问题的选择：MSE, MAE 与 Huber Loss

当模型的预测目标是一个连续值，如预测用户观看视频的时长、预测商品的价格时，我们就需要回归损失函数来衡量预测值 ŷ 和真实值 y 之间的数值差距。

2.2.1 MSE vs. MAE：对离群点的敏感度与收敛点（均值vs.中位数）的差异

1. MSE (Mean Squared Error, 均方误差)

• 公式：

  $$MSE = \frac{1}{n} \sum_{i=1}^{n} (\hat{y}_i - y_i)^2$$

• 核心思想： 惩罚误差的平方。这是一种“严厉”的惩罚机制，误差越大，损失会呈指数级增长。

• 对离群点的敏感度：非常敏感。

  • 原因： 由于损失是误差的平方，一个离群点（即 y 与 ŷ 差距极大的点）会产生一个巨大的损失值。为了最小化总损失，模型会被迫投入过多精力去“迁就”这一个离群点，可能会导致其对其他正常数据的拟合效果变差。整个模型的预测线会被离群点“拽”过去。

• 收敛点特性：

  • 最小化 MSE 的模型，其预测结果会收敛于目标值的条件均值 (Conditional Mean)。
  • 理解： 均值本身就是一个对离群点非常敏感的统计量（比如一个亿万富翁可以显著拉高整个小区的平均收入）。因此，一个以均值为优化目标的模型，自然也会对离群点敏感。

• 优点： 数学上，MSE 的损失函数处处可导且平滑，优化过程非常稳定高效。

2. MAE (Mean Absolute Error, 平均绝对误差)

• 公式：

  $$MAE = \frac{1}{N} \sum_{i=1}^{N} |y_i - \hat{y}_i|$$

• 核心思想： 惩罚误差的绝对值。这是一种“温和”的惩罚机制，损失与误差呈线性关系。

• 对离群点的敏感度：非常鲁棒 (Robust)。

  • 原因： 即使一个离群点产生了巨大的误差，它对总损失的贡献也是线性的，不会被不成比例地放大。因此，模型有能力“忽视”这些极端值，而专注于拟合数据的主体部分，不会轻易被带偏。

• 收敛点特性：

  • 最小化 MAE 的模型，其预测结果会收敛于目标值的条件中位数 (Conditional Median)。
  • 理解： 中位数是一个对离群点非常鲁棒的统计量（无论那个亿万富翁多有钱，小区的收入中位数都不会有太大变化）。因此，以中位数为优化目标的模型，自然也继承了这种鲁棒性。

• 缺点： 在误差为0的点，MAE 的导数不连续（有一个“拐点”），这可能导致在接近最优解时，梯度仍在-1和1之间跳跃，不利于模型进行精细的收敛。

2.2.2 Huber Loss：集大成者的稳健选择

既然 MSE 和 MAE 各有优劣，Huber Loss 便应运而生，它试图集二者之长。

• 核心思想： 它是一个分段函数，兼具了智慧与灵活性。
  • 当误差较小时 (|y - ŷ| ≤ δ)： 此时损失函数等同于 MSE。这保证了在接近最优解时，损失函数平滑可导，梯度会平稳地减小，利于模型进行精细的收敛。
  • 当误差较大时 (|y - ŷ| > δ)： 此时损失函数等同于 MAE（但形式上有所调整以保证连接处平滑）。这保证了当遇到离群点时，损失不会被过度放大，模型依然保持鲁棒。
• δ (delta) 是一个超参数，它定义了“小误差”和“大误差”之间的边界。

总结：

“在回归任务中，MSE、MAE和Huber Loss是最核心的三种损失函数。

• MSE 对大误差惩罚最重，对离群点最敏感，它的优化目标是预测数据的均值。优点是优化过程平滑稳定。
• MAE 对所有误差的惩罚是线性的，对离群点非常鲁棒，它的优化目标是预测数据的中位数。缺点是在最优解附近梯度不稳定。
• Huber Loss 是两者的结合。它在误差小时使用MSE的特性，保证收敛精度；在误差大时使用MAE的特性，保证模型鲁棒性。

在选择时，如果数据比较干净，我会优先考虑 MSE。如果数据中含有较多噪音或离群点，比如在搜广推场景中预测用户的观看时长或消费金额这类长尾分布的数据，为了保证模型的稳健性，Huber Loss 通常是比 MAE 更好的实践选择。”

2.3 解决特定难题的进阶损失函数

2.3.1 Focal Loss：应对“搜广推”场景中的样本极度不均衡问题

1. 问题背景：样本不均衡的“诅咒”

在“搜广推”的核心任务——点击率（CTR）和转化率（CVR）预估中，一个普遍且棘手的问题就是样本极度不均衡。

• 现象： 在广告或推荐场景中，用户点击（正样本）的行为是极其稀疏的，绝大部分的曝光（负样本）并不会产生点击。正负样本的比例可能达到 1:1000 甚至更悬殊。
• 使用标准交叉熵的后果：
  • 损失被“多数派”主导： 模型的总损失会被海量的负样本淹没。即使这些负样本都“很容易”被正确分类（比如模型预测的点击概率是0.001，非常接近真实值0），它们的总损失加起来也远远超过了少数正样本贡献的损失。
  • 模型“走捷径”： 为了快速降低总损失，模型会学到一个最简单的策略：对所有样本都预测为“不点击”。这样虽然整体准确率很高（比如99.9%），但模型完全没有学到如何识别我们真正关心的、有价值的正样本，因此这个模型是毫无用处的。

2. 核心思想：让模型“聚焦”于难点

Focal Loss 的设计哲学非常直观：我们不应该在已经学得很好的“简单题”上浪费时间，而应该把精力“聚焦”到那些模型搞不懂的“难题”上。

它通过修改标准的交叉熵损失，动态地降低了那些“容易分类、置信度高”的样本对总损失的贡献权重，从而让模型能够更专注于学习那些“难以分类、置信度低”的样本。

3. 公式与机制解析

我们从标准的二元交叉熵（BCE）出发，一步步演进到 Focal Loss。

• BCE Loss:

  $$L_{BCE} = -\log(p_t)$$

  （其中 p_t 是模型对正确类别预测的概率）

• 加权 BCE Loss (α-balanced):

  $$L_{\alpha BCE} = -\alpha_t \log(p_t)$$

  这是处理不均衡的传统方法，即为数量少的正类分配一个更高的权重 α，为数量多的负类分配一个较小的权重 1-α。这在一定程度上能缓解问题，但它无法区分样本的“难易”程度。

• Focal Loss:

  $$L_{F L}=-\alpha_{t}\left(1-p_{t}\right)^{\gamma} \log \left(p_{t}\right)$$

  • 关键创新：调制因子 (1−pt)γ
  • γ (gamma) 被称为聚焦参数，是一个可调的超参数，通常 γ ≥ 0。
  • 工作机制：
    • 对于一个“简单”样本： 比如一个真实不点击的样本，模型很自信地预测其点击概率 p=0.01，那么 p_t = 1-p = 0.99。此时调制因子为 (1-0.99)^γ = 0.01^γ。如果我们取 γ=2，这个因子就是 0.0001。这意味着这个简单样本对总损失的贡献被急剧地降低了1万倍！模型被告知“你已经做得很好了，不用再管这个了”。
    • 对于一个“困难”样本： 比如一个真实点击的样本，模型却不自信地只预测其点击概率 p=0.1，那么 p_t = p = 0.1。此时调制因子为 (1-0.1)^γ = 0.9^γ。如果我们取 γ=2，这个因子是 0.81。可以看到，这个困难样本的损失基本没有被降低。模型被告知“你在这道题上还错得很，要继续学习！”。

总结：

问：“在CTR预估任务中，正负样本比例非常悬殊，你会如何处理？”

答： “这是一个在工业界非常普遍且关键的问题。传统的解决方法如下采样或上采样，但可能会丢失信息或引入噪音。在模型层面，一个更先进和有效的方法是使用 Focal Loss 作为损失函数。

Focal Loss 是对标准交叉熵损失的一种改进，它专门用于解决样本不均衡问题。其核心思想是引入了一个调制因子 (1-pt)^γ。这个因子可以动态地、大幅地降低海量‘易分类’样本（大部分是负样本）在损失计算中的权重，从而让模型能够聚焦于学习我们更关心的、数量稀少的正样本，以及那些难以区分的样本。

通过调整聚焦参数 γ，我们可以灵活地控制对简单样本的抑制程度。Focal Loss 几乎是处理CTR/CVR预估这类任务时，解决样本不均衡问题的标准和首选方案之一。”

2.3.2 对比学习损失：学习优质 Embedding 的核心

1. 为什么需要对比学习？——表征学习的目标

在“搜广推”系统中，我们需要处理各种各样的实体，如用户、商品、搜索词、广告等。为了让模型能够理解它们，我们首先需要将这些实体转化为计算机能够处理的低维稠密向量——Embedding。

一个“好”的 Embedding 应该具备语义上的几何结构，即：相似的样本在向量空间中距离近，不相似的样本距离远。

然而，像交叉熵这样的标准分类损失，其目标是“分对类别”，它并不会直接对 Embedding 在空间中的相对位置进行优化。对比学习（Contrastive Learning）就是专门为了解决这个问题而生的，它的目标就是学习出具有优良空间结构的 Embedding。

Contrastive Loss & Triplet Loss：基于“对”和“三元组”的度量学习

这是对比学习的经典方法，也称为度量学习（Metric Learning）。其核心思想是，学习信号不再来自于样本的固定标签，而是来自于样本之间的两两比较。

1. 对比损失 (Contrastive Loss)

• 学习单元： 样本对 (Pair)，即 (样本A, 样本B)。
• 数据构造： 需要构造两种样本对：
  • 正样本对 (Positive Pair): A和B是相似的。例如，在推荐中，是同一个用户点击过的两件不同商品。
  • 负样本对 (Negative Pair): A和B是不相似的。例如，一件用户点击过的商品和一件他曝光未点击的商品。
• 优化目标：
  • 对正样本对，拉近它们在向量空间中的距离。
  • 对负样本对，推远它们的距离，但并不要求无限远，只要它们的距离大于一个预设的间隔 (margin) m 即可。这相当于在不同类的样本之间划出一条“安全边界”。

2. 三元组损失 (Triplet Loss)

• 学习单元： 三元组 (Triplet)，即 (Anchor, Positive, Negative)。
• 数据构造：
  • Anchor (锚点)：一个基准样本，比如一个特定的用户 u。
  • Positive (正例)：与 Anchor 相似的样本，比如该用户 u 点击过的商品 i。
  • Negative (负例)：与 Anchor 不相似的样本，比如用户 u 未点击的商品 j。
• 优化目标：
  它进行的是一种相对比较。目标是让“锚点到正例的距离” 显著小于 “锚点到负例的距离”。
  • 即：D(Anchor,Positive) + margin < D(Anchor,Negative)
  • 损失函数会惩罚那些不满足这个条件的“坏”三元组，直到负例被推得比正例足够远（远出一个 margin 的距离）。Triplet Loss 通常比 Contrastive Loss 更常用，效果也更稳定。

N-pair Loss & InfoNCE Loss：更高效的多负例对比方法

Triplet Loss 一次只用一个负例，学习效率不高。如果我们能一次性让一个正例与多个负例进行对比，模型就会面临一个更难的挑战，从而学习到更具区分度的 Embedding。

核心思想转变： 从“度量距离远近”转变为“在众多候选中进行分类”。

1. N-pair Loss

• 核心思想： 将对比学习任务转化为一个 N 分类问题。它在一个 batch 中构造 N 个正样本对，对于其中一个 Anchor，它的 Positive 是它的正确答案，而 batch 中其他 N-1 个 Positive 样本则都成为它的负例。模型的目标就是为这个 Anchor 在 N 个选项中选出正确的那个 Positive。

2. InfoNCE Loss (现代对比学习的标准)

• 核心思想： InfoNCE 将“多负例对比”的思想发扬光大并系统化。它的任务可以被生动地描述为**“大海捞针”。给你一个嫌疑人（Anchor）的照片，然后给你一个有100人的广场，里面混着他的孪生兄弟（Positive）和99个路人（Negatives）。警察的要求是：“请你准确地从这100人里把他兄弟给我找出来**”。这是一个多选一的分类任务，难度显然大得多，对模型学习区分性特征的要求也更高。

$$L_{\text{InfoNCE}} = -\log \frac{\exp(\text{sim}(q, k_+)/\tau)}{\exp(\text{sim}(q, k_+)/\tau) + \sum_{i=1}^N \exp(\text{sim}(q, k_{i-})/\tau)}$$

• q 是 anchor 的 embedding，k+ 是 positive 的 embedding，k- 是 negative 的 embedding。
• sim() 是余弦相似度。τ 是温度超参，用于调节 Softmax 的锐利度。
• 优化目标： 在一个包含 1个正例 和 N个负例 的集合中，InfoNCE 的目标是让模型能够以最高的概率识别出那个唯一的正例。
• 公式本质： 其损失函数的形式，本质上就是一个在相似度（通常是点积或余弦相似度）上计算的多分类交叉熵损失(一个标准的 Softmax + 交叉熵损失)。它通过一个 Softmax 函数，将识别问题转化为了一个概率最大化问题。
• 优势： InfoNCE 可以非常高效地利用大量的负样本（比如一个 batch 内的所有其他样本），这提供了一个非常强的学习信号，使得模型必须学习到高度精细和鲁棒的特征，才能在众多干扰项中找出正确的正例。

在“搜广推”中的核心应用：双塔模型召回

对比学习损失，特别是 InfoNCE，是驱动现代推荐/搜索系统召回阶段的引擎。

1. 模型架构： 构建双塔模型。一个“用户塔”负责将用户信息和上下文处理成 User Embedding；一个“物品塔”负责将物品信息处理成 Item Embedding。
2. 训练： 使用海量的用户行为数据（如 (用户, 点击物品, 曝光未点物品)），通过 InfoNCE Loss 来端到端地训练双塔模型。
3. 线上服务（召回）：
   • 离线： 用训练好的“物品塔”计算好全量百万、千万甚至上亿个物品的 Item Embedding，存入向量数据库（如 FAISS）。
   • 在线： 当用户请求到来时，用“用户塔”实时计算出该用户的 User Embedding。
   • 匹配： 使用近似最近邻（ANN）搜索技术，在毫秒级别内，从海量物品库中，找出与用户 Embedding 最相似（点积最大）的几百或几千个候选物品。
4. 完成召回： 这几百上千个物品就构成了召回集，它们将被送入下一步更复杂的**排序（Ranking）**模型中进行精排。

2.3.3 Center Loss：提升特征的类内紧凑性

1. 问题背景：分得开，但不够“好”

标准的分类损失函数，如交叉熵 (Cross-Entropy)，其主要目标是让模型学习到可分性 (Separability)。也就是说，它会努力地将不同类别的样本特征在向量空间中推开，使得分类器能够画出一条清晰的决策边界。

然而，交叉熵并不关心同一类别内部的样本特征是否紧凑。这可能导致一个问题：虽然不同类别分开了，但每个类别内部的特征分布可能非常“松散”，像一盘散沙。这种高“类内方差 (Intra-class Variation)”会使得模型的决策边界非常脆弱，抗干扰能力差，学习到的特征也不够有代表性。

2. 核心思想：在“推开”的同时，也要“拉近”

Center Loss 的设计思想非常直观：它作为一种正则化项，与主要的分类损失（如交叉熵）协同工作，以实现两个目标：

1. 交叉熵损失 (主任务): 负责将不同类别的特征簇（Inter-class）推开。
2. Center Loss (辅助任务): 负责将相同类别内的样本特征（Intra-class）向该类的中心点拉近。

总损失函数公式：

$$L_{\text{Total}} = L_{\text{Softmax}} + \lambda \cdot L_{\text{Center}}\\L_{\text{Center}} = \frac{1}{2} \sum_{i=1}^{N} \| \mathbf{x}_i - \mathbf{c}_{y_i} \|_2^2$$

• $L_{Softmax}$ 就是我们熟悉的交叉熵损失。
• $L_{Center}$ 计算了每个样本的特征向量 x_i 到其对应类别（由标签 y_i 决定）的中心 c_yi 的距离的平方和。
• λ 是一个平衡超参数，用于控制“拉近”这个辅助任务的重要性。

3. 工作机制：双重更新的动态过程

为了实现“拉近”这个目标，Center Loss 在训练过程中引入了一个双重更新的机制：

1. 更新网络参数 θ： 在反向传播时，模型的权重不仅接收来自交叉熵损失的梯度，也接收来自 Center Loss 的梯度。Center Loss 的梯度会“指示”网络权重进行调整，使得下一次该样本输出的特征 x_i 会更靠近它的类别中心 c_yi。
2. 更新类别中心 c： 类别中心 c 本身也不是固定不变的。在每个 mini-batch 训练后，每个类别中心都会根据该 batch 中属于它的那些样本的特征，向它们的均值方向进行移动。

这个“模型权重更新”和“类别中心更新”交替进行的过程，就像一个动态的“捏面团”过程：网络努力地把“面”（特征）往“中心”送，而“中心”也在不断地移动到“面”最密集的地方。经过多轮迭代，最终每个类别的特征就会被“捏”成一个非常紧凑、密实的特征簇。

4. 对比其它方法

• 与 Contrastive/Triplet Loss 的区别： 对比学习关注的是样本之间的相对距离（比如A离B比离C更近）。而 Center Loss 关注的是每个样本与它所属的那个全局类别中心的绝对距离。Center Loss 的实现相对更简单，因为它不需要构造复杂的样本对或三元组。

5. 在“搜广推”中的应用
Center Loss 在“搜广推”中属于一个更精细化的“工具”，适用于对特征判别性要求高的场景。

• 细粒度分类： 当需要对商品或广告进行非常精细的类目划分时（比如“红色iPhone手机壳” vs "粉色iPhone手机壳”），使用 Center Loss 可以让学习到的 Embedding 更具区分度，边界更清晰。
• 用户/广告风格聚类： 对广告创意素材按风格进行分类时，Center Loss 可以让同种风格的素材在向量空间中聚合得更紧，有利于后续进行风格化的推荐或分析。
• 作为辅助损失： 在多任务学习模型中，可以引入 Center Loss 作为一个辅助任务，来提升模型中间共享层 Embedding 的质量，从而惠及所有下游任务。

总结：
“Center Loss 不是一个独立的损失函数，而是一个与交叉熵等主分类损失配合使用的正则化项。它的核心目标是通过最小化类内方差，来提升模型学习到的特征的判别性和鲁棒性。

它的工作机制是，在交叉熵负责推开不同类别特征的同时，Center Loss 会额外惩罚每个样本特征与其所属类别中心之间的距离，从而在训练中将同一类别的样本向其中心‘拉近’。这最终会使得学习到的特征不仅类别间可分，而且类别内高度紧凑，在一些细粒度分类或对特征质量要求高的任务中非常有价值。”

第三部分：理论深度：统计与优化原理 (Theoretical Depth: Statistical & Optimization Principles)

3.1 参数估计的两种视角：最大似然(MLE)与最大后验(MAP)

当我们训练一个模型时，本质上是在“估计”一组最能描述数据的参数 θ。对于如何找到“最好”的参数，统计学界主要有两种观点。

1. 最大似然估计 (Maximum Likelihood Estimation, MLE)

• 核心思想 (频率派观点)：
  MLE 认为模型的真实参数 θ 是一个未知的固定常量。它的目标是：找到这样一组参数 θ，使得我们已经观测到的这批训练数据 D 出现的概率最大。
  • 直观比喻： 你捡到一枚硬币，抛了10次，出现了7次正面。MLE会问：“这枚硬币的正面朝上概率 p 是多少时，‘10次抛出7次正面’这个结果出现的可能性最大？” 答案是 p=0.7。MLE完全相信数据，数据告诉我们什么，它就认为真相是什么。
• 数学表示： 目标是最大化似然函数 L(θ)=P(D∣θ)。

3.1.1 损失函数与 MLE 的血缘关系

我们日常使用的损失函数，正是 “最小化损失函数” 等价于 “最大化对数似然” 这一原则的体现。

• 核心转换：最大化 Likelihood ⇔ 最大化 log(Likelihood) (取对数不改变极值点，但将连乘变为连加，便于计算) ⇔ 最小化 -log(Likelihood)
  这个 负对数似然 log(Likelihood)，就是我们各种损失函数的“真身”。
• 交叉熵的推导 (分类问题):

  • 假设： 我们假设二分类问题的标签 y 服从伯努利分布。

  • 推导： 单个样本的似然是

    $$P(y|x) = p^y(1-p)^{1-y}$$

    取负对数似然，得到:

    $$-[y\log(p)+(1 - y) \log(1 - p)]$$

  • 结论： 这正是我们熟悉的二元交叉熵 (BCE) 损失！因此，当我们在分类任务中使用交叉熵损失时，我们实际上是在对一个假设输出服从伯努利/类别分布的模型进行最大似然估计。

• MSE的推导 (回归问题):
  • 假设： 我们假设真实值 y 等于模型预测值 f(x) 加上一个服从**正态分布（高斯分布）**的零均值噪声 ε。
  • 推导： 在这个假设下，y 的概率密度函数的负对数似然，其需要最小化的部分正比于 (y−f(x))^2。
  • 结论： 这正是均方误差 (MSE) 损失！因此，使用MSE等于在假设误差服从高斯分布的前提下进行最大似然估计。

2. 最大后验概率估计 (Maximum A Posteriori, MAP)

• 核心思想 (贝叶斯派观点):
  MAP 认为参数 θ 不是固定的，它本身也是一个随机变量，在看到数据之前，我们可能对它有一个先验的认知，记为 P(θ)。
  MAP的目标是：综合考虑“数据 D”和我们的“先验认知 P(θ)”，找到一个最合理的参数 θ。
• 数学表示（贝叶斯定理）： 目标是最大化后验概率 P(θ∣D)。

$$\underset{\theta}{\text{argmax}} P(\theta|D) \propto \underset{\theta}{\text{argmax}} \left[ P(D|\theta) \cdot P(\theta) \right]$$

MAP = 似然 × 先验, P(D∣θ)=似然, P(θ)=先验

3.1.2 正则化的贝叶斯解释：L1/L2 分别对应何种先验？

这揭示了正则化项的深刻本质：正则化 = 在损失函数中引入先验信念。

• 推导：最大化 Likelihood × Prior ⇔ 最大化 log(Likelihood) + log(Prior) ⇔ 最小化 [-log(Likelihood)] + [-log(Prior)]

  我们发现，MAP的目标函数变成了： 最小化 损失函数 + 参数的先验证罚项

  • log(Likelihood)： 就是我们从MLE推导出的损失函数（如交叉熵或MSE）。
  • log(Prior)： 就是我们要添加的正则化项！

• L1/L2 正则化与先验的对应关系 :

  • L2 正则化 (Ridge Regression): 如果我们对参数的先验信念是“参数 θ 应该比较小，并且集中在0附近”，这种信念可以用一个高斯先验 (Gaussian Prior) 来数学化描述。高斯分布的负对数正好是 θ 的二次方项。因此，MAP + 高斯先验 = 损失函数 + L2正则化。
  • L1 正则化 (Lasso Regression): 如果我们的先验信念是“参数 θ 应该非常稀疏，即很多参数值应该正好是0”，这种信念可以用拉普拉斯先验 (Laplace Prior) 来描述。拉普拉斯分布的负对数正好是 θ 的绝对值项。因此，MAP + 拉普拉斯先验 = 损失函数 + L1正则化。

• MLE 与 MAP 的统一：
  如果对参数没有任何先验信念，即认为所有参数取值的可能性都一样，这就是均匀分布先验。此时 P(θ) 是一个常数，log(P(θ)) 也是常数，在优化中可以忽略。MAP 就退化为了 MLE。所以，MLE 是 MAP 在“无信息先验”下的一种特例。

3.2 “分布”的核心概念解读

“分布”是用来描述数据整体面貌和内在规律的语言。理解了数据的分布，就等于掌握了它的“性格”。

3.2.1 什么是分布？（经验分布 vs. 理论分布）

• 直观定义： 分布描述了一组数据中，各个数值的疏密程度和排列模式。它告诉我们哪些值更常见，哪些值更稀有。
• 两种视角看分布：
  1. 经验分布 (Empirical Distribution):
     • 是什么： 这是我们通过直接观察手中有限的样本数据而得到的分布。它是对我们已有数据的最真实写照。
     • 怎么看： 最常用的方法就是画直方图 (Histogram)。直方图的形状，就是这批数据的经验分布。它很直观，但可能因为数据的随机性而不够平滑，且不具备很好的泛化性。
  2. 理论分布 (Theoretical Distribution):
     • 是什么： 这是一个用数学函数来描述的、理想化的、平滑的分布。
     • 为什么用： 当我们观察到经验分布的形状（比如直方图的“山包”）与某个经典的数学函数很像时，我们就可以用这个简洁的数学函数来**近似地“建模”**我们的数据。这样做的好处是，模型变得非常简洁，并且具有很好的统计性质和泛化能力。
     • 常见例子：
       • 正态分布（高斯分布）： 对称的“钟形”曲线，由均值μ和标准差σ决定。在自然界和工业界中极为常见。
       • 伯努利分布： 单次“是/否”试验的分布，由单次成功的概率p决定。是CTR预估等二分类问题的基础。
       • 均匀分布： 所有可能结果的发生概率都相等，如掷一枚均匀的骰子。

3.2.2 “求XX数据的分布”具体指什么？

这句话在实践中通常指一个两步走的过程：

1. 探索性分析： 首先，通过可视化（如画直方图）等手段，观察你手中这批数据的经验分布，了解它的实际形状、中心位置、离散程度等。
2. 模型拟合： 然后，根据观察到的形状，选择一个合适的理论分布去近似它。并利用手中的数据去估计这个理论分布的参数。
   • 例如： “求用户年龄的分布” -> 画出年龄的直方图，发现它呈现钟形 -> 假设它服从正态分布 -> 计算样本的平均年龄作为μ的估计值，计算样本的标准差作为σ的估计值 -> 得出结论：“用户年龄近似服从均值为32，标准差为8的正态分布”。

3.3 优化的“地形”：凸函数与非凸函数

机器学习的训练过程，就是在一个由损失函数定义的、高低不平的“地形”上，寻找最低点的过程。这个“地形”的形状，决定了寻找最低点（最优解）的难度。

3.3.1 为何凸优化是“理想型”？

• “地形”特征： 凸函数的“地形”像一个完美的碗。
• 核心优点：
  1. 全局唯一最优解： 在这个“碗”里，只存在一个最低点，任何局部最低点都必然是全局最低点。
  2. 保证收敛： 使用梯度下降等优化算法，无论从“碗”的哪个位置开始下滑，最终都保证能到达那个唯一的全局最优点。
• 结论： 拥有凸损失函数的模型（如逻辑回归、线性回归）进行优化是稳定、可靠且结果可复现的。这使得凸优化成为我们最希望遇到的“理想情况”。

3.3.2 深度学习中的非凸优化意味着什么？

• “地形”特征： 深度神经网络的损失函数是高度非凸的，其“地形”像一个极其复杂的山脉，充满了无数高低不同、大小不一的“山谷”（局部最优点）。
• 对训练的深刻影响：
  1. 无法保证全局最优： 我们通过梯度下降找到的解，几乎可以肯定只是众多局部最优点中的一个，无法保证它是全局最好的解。我们的目标是找到一个“足够好”的局部最优解。
  2. 对初始化高度敏感： 初始权重的位置，决定了你从哪个“山峰”开始往下走，最终可能落入完全不同的“山谷”，导致模型性能差异巨大。这就是 He 初始化 等方法至关重要的原因。
  3. 优化器至关重要： 简单的梯度下降法很容易在“山谷”间被困住。而 Adam 等更先进的自适应优化器，通过引入动量等机制，像一辆性能更强的越野车，能帮助我们更好地“探索”这个复杂的地形，有机会越过一些小的障碍，找到更深的“山谷”。
  4. 超参数决定路径： 学习率、batch size等超参数的选择，直接影响了下降的路径和速度，是深度学习“炼丹”的关键所在。

总结：
“优化是机器学习的核心。凸优化问题，如逻辑回归，因其拥有唯一的全局最优解而非常稳定。相比之下，深度学习是一个高度非凸的优化问题，这意味着我们无法保证找到全局最优解，且训练结果对参数初始化、优化器选择和超参数设定都高度敏感。因此，在深度学习中，我们的目标是找到一个泛化能力强的、足够好的局部最优解。”

第四部分：经典模型对比与数据预处理 (Classic Model Comparison & Data Preprocessing)

4.1 两大线性分类器：SVM vs. 逻辑回归(LR)

SVM 和 LR 都是监督学习中用于分类的强大算法，当面试官要求对比它们时，他想考察的是你是否理解两者在核心思想、损失函数和应用场景上的本质区别。

4.1.1 核心思想对比：最大间隔 vs. 最大似然

1. 支持向量机 (SVM) 的哲学：最大间隔 (Maximum Margin)
   • 核心思想： SVM 是一个“边境防御”模型。它只关心那些离决策边界最近的、最难区分的样本点，这些点被称为支持向量 (Support Vectors)。SVM 的目标是在这些“边境哨兵”之间，找到一个能使“军事缓冲区”（即间隔，Margin）最宽的决策边界。
   • 损失函数：Hinge Loss。这个损失函数的设计非常巧妙，它只对那些落在间隔内或者被分错的样本点进行惩罚。对于那些远离边界、被轻松正确分类的点，其损失为0。这完美体现了 SVM “只关心支持向量”的极简主义思想。
   • 动机： 几何驱动。它追求的是在特征空间中最“安全”、最鲁棒的划分。
2. 逻辑回归 (LR) 的哲学：最大似然 (Maximum Likelihood)
   • 核心思想： LR 是一个“民主投票”模型。它关心每一个样本点。它的目标是找到一个决策边界，使得在现有数据分布下，所有样本被正确分类的总概率最大。
   • 损失函数：Log Loss (交叉熵)。我们之前已经深入探讨过，这个损失函数源于最大似然估计。任何一个样本，只要其预测概率不为1，都会对总损失产生贡献。样本离决策边界越远，其贡献越小，但永远不会为0。
   • 动机： 概率驱动。它追求的是对数据整体分布的最佳概率拟合。

主要技术差异总结：

4.1.2 在“搜广推”场景下的选择与原因

结论： 在几乎所有的“搜广推”核心场景，如 CTR/CVR 预估中，逻辑回归（LR）及其深度学习的演进版本是绝对的主流选择。

核心原因：

1. 需要概率输出 (The Killer Feature): 这是最根本、最决定性的原因。
   • 排序 (Ranking): 无论是搜索结果、推荐列表还是广告排序，我们都需要一个连续的分数来对成百上千的候选项进行排序。LR 天然输出的点击概率 (CTR)，是完成这个任务最理想、最符合逻辑的度量。
   • 竞价 (Bidding): 在计算广告中，广告主的出价（e.g., eCPM = pCTR * pCVR * Bid）直接依赖于模型预测的概率值。
   • SVM 的输出是类别，无法直接用于排序和竞价，需要额外的校准处理，效果和解释性都不如 LR。
2. 可扩展性与训练效率：
   • LR 的损失函数光滑可导，非常适合使用随机梯度下降 (SGD) 及其变种进行优化。这使得 LR 能够非常方便地进行在线学习 (Online Learning) 和大规模并行化训练，完美契合了工业界海量数据、实时更新的需求。
   • SVM 的优化问题（求解一个二次规划问题）在数据量巨大时，训练复杂度通常高于 LR。
3. 模型演进的基石：
   • 现代“搜广推”领域主流的深度模型，如 DeepFM, DIN 等，都可以被看作是 LR 的扩展。它们通常包含一个负责学习特征交叉的深度部分（DNN），和一个负责记忆的浅层部分（如FM或LR），最后通过一个 Sigmoid 函数输出概率。理解 LR，是理解整个现代推荐广告体系的起点。

总结：
“对于 CTR 预估这类任务，我会毫不犹豫地选择逻辑回归或其深度学习变种。最核心的理由是，LR能直接输出一个校准良好的概率，这对于排序、竞价等下游商业任务至关重要，而 SVM 无法做到这一点。此外，LR 易于大规模并行化训练和在线学习的特性，也使它更适合处理工业界的海量数据流。”

4.2 特征缩放：归一化(Normalization) vs. 标准化(Standardization)

特征缩放是数据预处理中至关重要的一步。如果不同特征之间的数值范围（量纲）差距过大（例如，年龄在10-90之间，而年收入在30万-1000万之间），很多机器学习模型将无法正常工作。

为什么需要特征缩放？

1. 加速梯度下降： 对于使用梯度下降优化的模型（如逻辑回归、SVM、神经网络），特征缩放可以使损失函数的等高线图更接近于“圆形”，从而让梯度下降的过程更平顺、更快速地找到最优解。否则，瘦长的等高线会导致优化路径来回震荡，收敛缓慢。
2. 消除量纲影响： 对于依赖距离计算的模型（如K-Means、KNN），特征缩放可以防止数值范围大的特征在距离计算中占据主导地位，使得所有特征能够被公平地对待。

注意： 决策树、随机森林、GBDT等树模型通常不需要进行特征缩放，因为树的分裂是基于单个特征的阈值，不受其他特征尺度的影响。

4.2.1 对离群点的敏感度分析与选择策略

这是归一化和标准化最核心的区别所在。

1. 归一化 (Normalization)，又称 Min-Max Scaling

• 公式：

  $$X_{\text{norm}} = \frac{X - X_{\text{min}}}{X_{\text{max}} - X_{\text{min}}}$$

• 作用： 将数据的数值范围严格地“压缩”到 [0, 1] 区间内。

• 对离群点的敏感度：非常敏感！

  • 例子： 假设我们有一组商品价格数据 [100, 200, 300, 500]。归一化后，它们的值会均匀地分布在 [0, 1] 之间。但如果此时进来一个离群点，比如一个奢侈品价格为 50000，那么 X_max 就会变成 50000。
  • 后果： 此时，原来的 [100, 200, 300, 500] 这四个“正常”数据点，在归一化后会全部被挤压到 [0, 0.01] 这个极其狭小的区间内，彼此之间几乎失去了区分度。模型将很难从这些被“压扁”的数据中学到有用的信息。

2. 标准化 (Standardization)，又称 Z-score Scaling

• 公式： （μ 是均值，σ 是标准差）

  $$X_{\text{std}} = \frac{X-\mu}{\sigma}$$

• 作用： 将数据变换为均值为0，标准差为1的分布。变换后的数据没有固定的数值范围。

• 对离群点的敏感度：非常鲁棒 (Robust)！

  • 例子： 同样面对 [100, 200, 300, 500, 50000] 这组数据。那个 50000 的离群点虽然会影响 μ 和 σ 的计算，但它的影响是有限的。
  • 后果： 变换后，那四个“正常”的数据点依然会以0为中心，保持一个合理的相对分布，而那个 50000 的离群点则会变成一个绝对值很大的Z-score（比如 z=4 或 z=5），它本身成为了一个“异常”的数值，但不会破坏其他正常数据的结构。

选择策略总结：

“归一化和标准化是两种最常用的特征缩放方法。

• 归一化的优点是能将数据严格限定在 [0, 1]，在某些对数据范围有严格要求的场景（如图像处理中的像素值）非常有用。但它的致命缺点是对离群点极其敏感。
• 标准化将数据转换为均值为0、标准差为1的分布，它对离群点的鲁棒性要好得多。

因此，在绝大多数机器学习场景中，特别是当数据分布未知或我们怀疑可能存在离群点时，标准化是更安全、更通用、更被推荐的选择。 在‘搜广推’的深度学习模型中，处理像‘商品价格’、‘用户年龄’、‘历史点击次数’这类稠密数值特征时，我们通常都会采用标准化，以保证模型训练的稳定性和鲁棒性。”