百度计算机视觉算法工程师面试题(秋招)

1、对Transformer的理解

    Transformer本身是一个典型的encoder-decoder模型,Encoder端和Decoder端均有6个Block,Encoder端的Block包括两个模块,多头self-attention模块以及一个前馈神经网络模块;Decoder端的Block包括三个模块,多头self-attention模块,多头Encoder-Decoder attention交互模块,以及一个前馈神经网络模块;需要注意:Encoder端和Decoder端中的每个模块都有残差层和Layer Normalization层。

2、Leetcode—搜索旋转排序数组

    思路一:暴力解法

    直接遍历整个数组,找到目标值target

    代码如下:

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        for i,num in enumerate(nums):
            if num == target:
                return i
        return -1

    时间复杂度:O(n)

    空间复杂度:O(1)

    思路二:二分查找

    先要设置整个数组的左右两端端点:left = 0,right = len(nums) - 1

    1、若 target == nums[mid],直接返回

    2、若 nums[left] <= nums[mid],说明左侧区间 [left,mid]「连续递增」。此时:

    若 nums[left] <= target <= nums[mid],说明 target 位于左侧。令 right = mid-1,在左侧区间查找;否则,令 left = mid+1,在右侧区间查找

    3、否则,说明右侧区间 [mid,right]「连续递增」。

    此时:

    若 nums[mid] <= target <= nums[right],说明 target 位于右侧区间。令 left = mid+1,在右侧区间查找

    否则,令 right = mid-1,在左侧区间查找

    代码如下:

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        left = 0
        right = len(nums) -1
        while left <= right:
            mid = left + (right - left) // 2
            if nums[mid] == target:
                return mid
            elif nums[left] <= nums[mid]:
                if nums[left] <= target < nums[mid]:
                    right = mid - 1
                else:
                    left = mid + 1
            else:
                if nums[mid] < target <= nums[right]:
                    left = mid + 1
                else:
                    right = mid - 1
        return -1

    时间复杂度:O(logn)

    空间复杂度:O(1)

3、Leetcode—二叉树层序遍历

    思路:

    1、如果 root 为空,直接返回 [ ]

    2、定义一个数组queue,并将 root 添加到 queue中,再定义一个res 数组保存结果

    3、遍历 当前层 queue 的每个左子节点,右子节点,入队列,且要把 queue 更新成当前层的孩子节点列表,直到 queue 为空。

    代码如下:

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root:
            return []
        queue = [root]
        res = []
        while queue:
            res.append([node.val for node in queue])
            l1 = []
            for node in queue: 
                if node.left:
                    l1.append(node.left)
                if node.right:
                    l1.append(node.right)
            queue = l1
        return res

4、Coding: 最小标记代价(类似Leetcode的72题:编辑距离)

    参考:[leetcode/lintcode 题解] 百度面试题:最小调整代价 - LintCode领扣 - 博客园

    思路:动态规划

    已知每个整数范围[1,100],那么对于每个元素,为了调整到该元素和与之相邻的元素的差不大于target,该元素调整的范围就在[1,100]。所以对于数组A[]的每一位元素,我们都需要进行[1,100]范围内的可能状态的转移。

    令dp[i][j]表示元素A[i]=j时,A[i]与A[i-1]差值不大于target所需要付出的最小代价。

    当A[i]=j时,可行的A[i-1]的范围为[max(1, j - target),min(100, j + target)]。而dp[i][j]为所有可行的A[i-1]中,花费代价最小的一种可能,再加上A[i]调整到 j 所需花费abs(j - A[i])。

    当A[i]=j时,k在[max(1, j - target),min(100, j + target)]范围内时,我们可以写出以下式子:

    1.临界值:

     dp[0][j] = abs(j - A[0])

    2.状态转移方程:

    dp[i][j] = min(dp[i][j], dp[i - 1][k] + abs(j - A[i]))

    最后在所有最后一位的可能解dp[n-1][i]中的最小值,就是我们所求的最小代价。

    代码如下:

public class Solution {
/*
* @param A: An integer array
* @param target: An integer
* @return: An integer
*/
public int MinAdjustmentCost(List<Integer> A, int target) {
int n = A.size();
// dp[i][j]表示元素A[i]=j时,A[i]与A[i-1]差值不大于target所需要付出的最小代价
int[][] dp = new int[n][101];
for (int i = 0; i < n; i++) {
for (int j = 1; j <= 100; j++) {
// 初始化为极大值
dp[i][j] = Integer.MAX_VALUE;
}
}
for (int i = 0; i < n; i++) {
for (int j = 1; j <= 100; j++) {
if (i == 0) {
// 临界值:第一个元素A[0]调整为j的代价
dp[0][j] = Math.abs(j - A.get(0));
}
else {
// left为A[i]=j时,A[i-1]与A[i]差值不大于target的A[i-1]最小值
// right为A[i]=j时,A[i-1]与A[i]差值不大于target的A[i-1]最大值
int left = Math.max(1, j - target);
int right = Math.min(100, j + target);
for (int k = left; k <= right; k++) {
// 当A[i-1]=k时,答案为A[i-1]=k的代价dp[i-1][k],加上A[i]=j的调整代价abs(j-A[i])
dp[i][j] = Math.min(dp[i][j], dp[i - 1][k] + Math.abs(j - A.get(i)));
}
}
 
}
}
int mincost = Integer.MAX_VALUE;
for (int i = 1; i <= 100; i++) {
mincost = Math.min(mincost, dp[n - 1][i]);
}
return mincost;
}
}

    复杂度

    假设数组长度为n

    空间复杂度O(10000*n)

    时间复杂度O(n^2)

5、防止过拟合的方法

    降低模型复杂度

    增加更多的训练数据:使用更大的数据集训练模型

    数据增强

    正则化:L1、L2、添加BN层

    添加Dropout策略

    Early Stopping

6、数据不平衡问题处理

    欠采样:从样本较多的类中再抽取,仅保留这些样本点的一部分;

    过采样:复制少数类中的一些点,以增加其基数;

    生成合成数据:从少数类创建新的合成点,以增加其基数。

    添加额外特征:除了重采样外,我们还可以在数据集中添加一个或多个其他特征,使数据集更加丰富,这样我们可能获得更好的准确率结果。

  • 1
    点赞
  • 21
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

七月在线

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值