其他分享
首页 > 其他分享> > 商汤实习面试准备（已上岸）

商汤实习面试准备（已上岸）

作者：互联网

关于BN层。可学习参数，BN层的作用，在训练阶段和预测阶段的有什么不同，了解GN吗。

import numpy as np
from PIL import Image
import matplotlib.pyplot as plt

kenel=np.array([
    [1,0,1],
    [0,1,0],
    [1,0,1]
])

# img=Image.open('C:/Users/Kaiser/Desktop/wlop1.jpg')
# plt.imshow(img)
# plt.show()
# img=np.array(img)

img=np.array([
    [1,1,1,0,0],
    [0,1,1,1,0],
    [0,0,1,1,1],
    [0,0,1,1,0],
    [0,1,1,0,0]
])

def conv(data,kenel):
    h,w=data.shape
    k=kenel.shape[0]
    conv_height=h-k+1
    conv_weight=w-k+1
    conv=np.zeros((conv_height,conv_weight),dtype=np.float64)
    for i in range(conv_height):
        for j in range(conv_weight):
                conv[i][j]=vaildpixel(np.sum(data[i:i+k,j:j+k]*kenel)/kenel.size)
    return conv

img_new=conv(img,kenel)
print(img_new)
#plt.imshow(img_new)
#plt.show()

PCA分解是怎么做的。

（1）栈内存分配运算内置于处理器的指令集中，一般使用寄存器来存取，效率很高，但是分配的内存容量有限。 一般局部变量和函数参数的暂时存放位置。

（2） 堆内存，亦称动态内存。如malloc和new申请的内存空间。动态内存的生存期由程序员自己决定，使用非常灵活。

（3）全局代码区：从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static变量。

（4）常量区：文字常量分配在文字常量区，程序结束后由系统释放。

（5）代码区：存放整个程序的代码，因为存储是数据和代码分开存储的。

STL 众多容器中，vector 是最常用的容器之一，其底层所采用的数据结构非常简单，就只是一段连续的线性内存空间。
通过分析 vector 容器的源代码不难发现，它就是使用 3 个迭代器（可以理解成指针）来表示的：
//_Alloc 表示内存分配器，此参数几乎不需要我们关心
template <class _Ty, class _Alloc = allocator<_Ty>>
class vector{
…
protected:
pointer _Myfirst;
pointer _Mylast;
pointer _Myend;
};
其中，_Myfirst 指向的是 vector 容器对象的起始字节位置；_Mylast 指向当前最后一个元素的末尾字节；_myend 指向整个 vector 容器所占用内存空间的末尾字节。
vector扩大容量的本质
另外需要指明的是，当 vector 的大小和容量相等（size==capacity）也就是满载时，如果再向其添加元素，那么 vector 就需要扩容。vector 容器扩容的过程需要经历以下 3 步：
完全弃用现有的内存空间，重新申请更大的内存空间；
将旧内存空间中的数据，按原有顺序移动到新的内存空间中；
最后将旧的内存空间释放。

class NodeList:
    def __init__(self,val):
        self.val=val
        self.next=None

def sort_nodeList_quicksort(head):
    '''sort a nodelist by quicksort method
    Args:
        head: the head node of the nodelist
    return:
        the head node of the sorted nodelist
    '''
    if not head:
        return None
    newhead = NodeList(-1)
    newhead.next=head
    return quicksort_fornodelist(newhead,None).next

def quicksort_fornodelist(head,end):
    '''用于链表快速排序的递归函数
    参数:
        head:排序列表头节点
        end:排序列表尾节点
    返回值：
        排序完成链表头节点
    '''
    if head == end or head.next == end or head.next.next == end:
        return head
    
    temp_node_head = NodeList(-1)
    temp_node=temp_node_head
    current_node = head.next
    partition_node = head.next

    #小于轴值节点的节点接在temp_node后
    while current_node.next != end:
        next_node=current_node.next
        if next_node.val < partition_node.val:
            current_node.next = next_node.next
            temp_node.next = next_node
            temp_node = temp_node.next
        else:
            current_node = current_node.next
    
    #print_nodelist(partition_node)
    #print_nodelist(temp_node_head)
    #合并temp链表和原链表
    temp_node.next = head.next
    head.next = temp_node_head.next
    quicksort_fornodelist(head,partition_node)
    quicksort_fornodelist(partition_node,end)

    return head

def build_nodelist(num_list):
    '''创建一个链表，值为num_list中元素值
    参数:
        num_list:新链表中的元素值列表
    返回:
        新建链表的头节点
    '''
    if not num_list:
        return None
    head = NodeList(num_list[0])
    current_node = head
    for i in range(1,len(num_list)):
        temp_node = NodeList(num_list[i])
        current_node.next = temp_node
        current_node=current_node.next
    
    return head

def print_nodelist(head):
    '''从头到尾打印链表
    参数：
        head：链表的头节点
    返回：
        无返回值，直接调用print函数输出
    '''
    res = []
    current_node = head
    while current_node:
        res.append(current_node.val)
        current_node = current_node.next
    print(res)
    return 

num_list = [5,4,3,2,1]
head = build_nodelist(num_list)

print_nodelist(head)
print_nodelist(sort_nodeList_quicksort(head))

简单介绍下你知道的 one stage目标检测算法

在这里插入图片描述

6.懂马尔科夫吗？
7.简单介绍下SIFT
11.手撕代码：

def reverse_nodelist(head):
    '''翻转输入链表
    参数：
        要翻转链表的头节点
    返回：
        翻转完成链表的头节点
    '''
    if not head:
        return None
    pre_node = None
    current_node = head

    while current_node:
        next_node=current_node.next
        current_node.next=pre_node
        pre_node=current_node
        current_node=next_node
    return pre_node

class TreeNode:
    def __init__(self,val):
        self.val=val
        self.left=None
        self.right=None

def print_binarytree_zhizixing(root):
    '''之字形打印二叉树
    参数：
        树的根节点
    返回值：
        按之字形顺序排列的节点值数组
    '''
    if not root:
        return None
    is_odd = False
    queue = [root]
    result_ary = []
    while queue:
        layer_output = []
        next_queue = []
        if is_odd:
            for i in range(len(queue)):
                layer_output.append(queue[i].val)
        else:
            for i in range(len(queue)-1,-1,-1):
                layer_output.append(queue[i].val)
        for node in queue:
            if node.left:
                next_queue.append(node.left)
            if node.right:
                next_queue.append(node.right)
        is_odd= not is_odd

        queue = next_queue
        result_ary.append(layer_output)
    
    return result_ary

def build_binarytree(num_list,treenode_index):
    '''按照num_list中的值建立新的二叉树
    输入：
        num_list:按照层序遍历的次序，存放二叉树节点的值，空节点使用None代替
        treenode_index:建立树节点所对应的值在数组中的索引
    返回值：
        root，新建树的根节点
    '''
    if not num_list:
        return None
    if treenode_index >= len(num_list):
        return
    if not num_list[treenode_index]:
        return
    else:
        root=TreeNode(num_list[treenode_index])

    root.left = build_binarytree(num_list,2 * treenode_index + 1)
    root.right = build_binarytree(num_list,2 * treenode_index + 2)

    return root

num_list=list(range(1,16))
root=build_binarytree(num_list,0)
print(print_binarytree_zhizixing(root))

编程：
7. 之子形打印二叉树
8. MxN的方格中有多少个正方形、多少个矩形、有多少种不同面积矩形

//x=min(m,n)-1 
//长方形里面数正方形的个数计算公式:m*n+(m-1)*(n-1)+.....+(m-x)*(n-x) 
// m*n表示长度为1的正方形的个数,(m-1)*(n-1)表示长度为2的正方形的个数。。。。。。
//长方形里面数长方形的个数计算公式(包含正方形):(1+2+3+...+m)*(1+2+3+...+n)=n*m(n+1)*(m+1)/4

【商汤2面】

编程：
15. 判断二叉树是否包含另一二叉树

class Solution {
    public boolean isSubtree(TreeNode s, TreeNode t) {
        if (t == null) return true;   // t 为 null 一定都是 true
        if (s == null) return false;  // 这里 t 一定不为 null, 只要 s 为 null，肯定是 false
        return isSubtree(s.left, t) || isSubtree(s.right, t) || isSameTree(s,t);
    }

    /**
     * 判断两棵树是否相同
     */
    public boolean isSameTree(TreeNode s, TreeNode t){
        if (s == null && t == null) return true;
        if (s == null || t == null) return false;
        if (s.val != t.val) return false;
        return isSameTree(s.left, t.left) && isSameTree(s.right, t.right);
    }
}
  1. 有序数组合并

分割的发展可能性
无监督学习在分割的应用

def fibona(n):
    '''计算 f(n)的值 f(n)=f(n-1)+f(n-2)
    输入：
        n：数列索引，从0开始
    返回：
        f(n)的值
    '''
    if n == 0:
        return 0
    if n == 1:
        return 1
    f1_f0 = [[1,0]]
    matrix_xishu = [
        [1,1],
        [1,0]
    ]
    fn_fn_1 = matrix_mutilply(f1_f0,matrix_mi(matrix_xishu,n-1))  #[[f_n,f_n_1]]
    return fn_fn_1[0][0]

def matrix_mi(matrix,mi):
    '''求矩阵的幂
    输入：
        matrix：底数矩阵
        mi：幂次
    返回：
        res:matrix的mi次结果
    '''
    if mi == 1:
        return matrix
    residual = mi%2
    oushu_mi = mi - residual
    matrix_dishu = matrix
    while oushu_mi>1:
        matrix_dishu = matrix_mutilply(matrix_dishu,matrix_dishu)
        oushu_mi = oushu_mi/2
    
    return matrix_dishu if residual == 0 else matrix_mutilply(matrix_dishu,matrix)

def matrix_mutilply(matrix_a,matrix_b):
    '''矩阵乘积运算
    输入：
        matrix_a：n*m矩阵
        matrix_b: m*k矩阵
    返回：
        res:n*k矩阵
    '''
    n,m,k = len(matrix_a),len(matrix_b),len(matrix_b[0])
    res=[[0] * k for i in range(n)]
    for i in range(n):
        for j in range(m):
            for z in range(k):
                res[i][z]+=matrix_a[i][j]*matrix_b[j][z]
    
    return res

print(fibona(100))

如何解决车道线分割有车阻拦视线导致分割结果断裂的问题
coding: 寻找数组中唯一/唯二只出现一次的数

class Solution:
    def singleNumber(self, nums: List[int]) -> List[int]:
        # xor 为特殊两个数的异或
        xor = 0
        for num in nums:
            xor = xor ^ num
        # bit 为xor 第一个为1的位
        bit = 1
        while xor & bit == 0:
            bit <<= 1
        # 通过和bit异或的结果，把数分为两组，两个数肯定在不同组，两个组异或出的结果就是两个数
        a = 0
        b = 0
        for num in nums:
            if num & bit == 0:
                a ^= num
            else:
                b ^= num
        return [b,a]

给了一个一维数组，给了一个行数和列数，要求我转换成二维数组

算法：
3. numpy写个batch norm 层。
4. 给出feature map和卷积核尺寸，求参数量。

一道算法题：迷宫的最短路径
二叉树中序遍历的非递归实现。
sigmoid和softmax的区别

detnet原理

在这里插入图片描述
L2损失函数的导数是动态变化的，所以x增加也会使损失增加，尤其在训练早起标签和预测的差异大，会导致梯度较大，训练不稳定。

L1损失函数的导数为常数，在模型训练后期标签和预测的差异较小时，梯度值任然较大导致损失函数在稳定值附近波动难以进一步收敛。

Smooth L1损失函数在x较大时，梯度为常数解决了L2损失中梯度较大破坏训练参数的问题，当x较小时，梯度会动态减小解决了L1损失中难以收敛的问题。

所以在目标检测的Bounding box回归上早期会考虑Smooth L1 Loss：

相比于L1 Loss，可以收敛得更快。
相比于L2 Loss，对离群点、异常值不敏感，梯度变化相对更小，训练时不容易跑飞。

BN、IN、LN、GN原理，BN为什么有效

Python有哪些常用的库报一遍

说一下使用Pytorch对cifar10数据集分类的整个代码流程，构建模型的过程是怎么样的

github的常用操作：上传、合并、分支之类的

linux的常用操作：查看文件大小、删除文件、查看文件行数、假如文件中有很多文件，每个文件中又有很多文件，如何删除全部文件

图像基础知识，如基础网络以及变体。

  1. 修饰器功能

  2. Yield

  3. 手写了很简单的代码，斐波那契数列及优化。

  4. Svm相关知识

top k问题
bfs

WGAN 有没有分析GAN的问题

代码nms，含类别的，猫和狗两类是分开做nms吗？
代码 psnr
c++ 构造函数和析构函数是干嘛的，如果 在main函数外创建对象，先执行构造函数还是先执行main函数
类内如果没有使用delete，为什么会出现内存泄漏
指针在内存中的存储形式是什么
c++ 存一个二维数组，都会存什么信息 除了元素外 会存列指针
python list和tuple的区别 为什么一个可变一个不可变
写过cuda吗
Faster rcnn中roi pooling是怎么做的
参数量 计算量 dwconv的参数量
为什么dw可以work
用过mask rcnn做检测吗
focal loss的理解
作者：Neymarkim
链接：https://www.nowcoder.com/discuss/192689?type=post&order=time&pos=&page=2&channel=1009&source_id=search_post
来源：牛客网

常用的目标检测算法，one stage two stage的区别
3.比赛中如何解决样本不平衡，以及用了什么训练技巧，为什么能起作用，其原理是什么（回答的不是很好）

5.现在有些什么降低模型复杂的的方法，我说了两点，使用一些降低计算量的结构比如mobile net shuffle net，然后模型剪枝（这个就把自己坑了）
7. mobile net shuffle net具体结构，如何降低计算量，给了我一个DW卷积具体实例让我算降低了多少计算量
8.模型剪枝的方法，具体细节（没回答上）
9.SE介绍

问了Matlab / Python / tensorflow的一些操作
谈一谈深度学习的优化的具体措施（问的非常详细，如：常见的损失函数优化算法，二阶导在优化过程中的引入，参数压缩的算法，深度学习分布式部署）

  1. 详细介绍了batchNorm

首先介绍下实习的工作
介绍faster rcnn这个流程，faster rcnn有哪些缺点
ssd介绍，有哪些优点缺点
nms softnms softernms
任意四边形计算iou
mibilenet v1 v2介绍
resnet inception结构对比
se_resnet和non-local是否了解
开放题：
细粒度分类用inception好还是resnet好
类别不平衡用inception好还是resnet好
pca从特征值分解角度如何解释（这里应该要看下pca推导，可惜不会）
python里如何实现类似c++里引用（在函数里改变基础类型，这里回答可以用list传入，进行修改）
算法题
链表倒数第k个节点
多个数组，都是有序的，想求topk
多路归并
最大连续子串的区间
为什么ssd比faster rcnn慢，介绍r-fcn，介绍ohem

def minnum_of_reverse_array(reverse_array):
    '''得到升序数组旋转后的数组中的最小值
    参数：
        reverse_array:升序数组旋转后的数组 如[3,4,5,1,2]
    返回：
        数组中的最小值
    '''
    if not reverse_array:
        return None
    left = 0
    right = len(reverse_array) - 1
    while left<right:
        mid = left + (right-left) // 2
        if reverse_array[mid] > reverse_array[right]:
            left = mid + 1
        elif reverse_array[mid] < reverse_array[right]:
            right = mid
        elif reverse_array[mid] == reverse_array[right]:
            right = right - 1
    
    return reverse_array[right]

def minnum_of_reverse_array_digui(reverse_array):
    '''旋转数组的最小值，使用递归方法
    参数：
        reverse_array:旋转的有序数组
    返回：
        数组中的最小值
    '''
    if not reverse_array:
        return float("inf")
    left = 0
    right = len(reverse_array) - 1 
    mid = left + (right - left) // 2
    minnum_of_array = float("inf")
    if reverse_array[mid] < reverse_array[right]:
        minnum_of_array = minnum_of_reverse_array_digui(reverse_array[:mid])
    elif reverse_array[mid] > reverse_array[right]:
        minnum_of_array = minnum_of_reverse_array_digui(reverse_array[mid + 1:])
    elif reverse_array[mid] == reverse_array[right]:
        minnum_of_array = minnum_of_reverse_array_digui(reverse_array[:right-1])

    return min(reverse_array[mid],minnum_of_array)

reverse_array = [2,4,5,1,2,2]
print(minnum_of_reverse_array_digui(reverse_array))

如何解决multiscale问题
算法题：
sqrt(), log()如何求
求数组中出现次数超过一半的数字
四面（45分钟）
介绍实习项目，问目标检测的回归loss是什么，为什么这么用
介绍论文相关
softmax+celoss工程上如何防止上下溢出
SGD 使用mini batch优化和使用所有优化样本优化哪个更好，为什么

  1. 论文（细节）
  2. 实习（细节）

冲冲冲
两面技术面+hr面
准备的基本上都没有问。主要是问项目，做的方向比较契合，就通过了。实习三月，收获很大，也很辛苦。

标签：node,head,return,reverse,next,面试,商汤,实习,array
来源： https://blog.csdn.net/Kfdhfljl/article/details/109597023