2021年6月9日,CVTE NLP算法岗面试题9道

·  阅读 125

这是我参与11月更文挑战的第26天,活动详情查看:2021最后一次更文挑战

起了个大早来打卡,今天分享9道NLP算法面试题,每道都是用心整理、解答,仅供参考,希望能帮到正准备面试的XDM。欢迎评论区交流指正。

1.讲一下改进的tf-idf

TF-IDF中的IDF是一种试图抑制噪声的加权,单纯的以为文本频率小的单词就越重要,文本频率越大的单词就越无用,这一方式会在同类语料库中存在巨大弊端,一些同类文本的关键词容易被掩盖。例如:语料库 D 中教育类文章偏多,而文本 j 是一篇属于教育类的文化在那个,那么教育类相关词语的IDF值就会较小,使提取本文关键词的召回率更低。

改进方法:TF−IWF (Term Frequency-Inverse Word Frequency)

2.讲一下k-means与谱聚类

聚类算法属于无监督的机器学习算法,即没有类别标签y,需要根据数据特征将相似的数据分为一组。K-means聚类算法即随机选取k个点作为聚类中心,计算其他点与中心点的距离,选择距离最近的中心并归类,归类完成后计算每类的新中心点,重新计算每个点与中心点的聚类并选择距离最近的归类,重复此过程,直到中心点不再变化。

谱聚类的思想是将样本看作顶点,样本间的相似度看作带权的边,从而将聚类问题转为图分割问题:找到一种图分割的方法使得连接不同组的边的权重尽可能低(这意味着组间相似度要尽可能低),组内的边的权重尽可能高(这意味着组内相似度要尽可能高),从而达到聚类的目的。

3.蒸馏的思想,为什么要蒸馏?

知识蒸馏就是将已经训练好的模型包含的知识,蒸馏到另一个模型中去。具体来说,知识蒸馏,可以将一个网络的知识转移到另一个网络,两个网络可以是同构或者异构。做法是先训练一个teacher网络,然后使用这个teacher网络的输出和数据的真实标签去训练student网络。

在训练过程中,我们需要使用复杂的模型,大量的计算资源,以便从非常大、高度冗余的数据集中提取出信息。在实验中,效果最好的模型往往规模很大,甚至由多个模型集成得到。而大模型不方便部署到服务中去,常见的瓶颈如下:

  • 推断速度慢
  • 对部署资源要求高(内存,显存等),在部署时,我们对延迟以及计算资源都有着严格的限制。

因此,模型压缩(在保证性能的前提下减少模型的参数量)成为了一个重要的问题。而”模型蒸馏“属于模型压缩的一种方法。

4.有哪些蒸馏方式? 蒸馏中的学生模型是?

以Bert模型举例:

Logit Distillation

Beyond Logit Distillation:TinyBert

Curriculum Distillation:

Dynamic Early Exit:FastBert。

5.python在内存上做了哪些优化?

python通过内存池来减少内存碎片化,提高执行效率。主要通过引用计数来完成垃圾回收,通过标记-清除解决容器对象循环引用造成的问题,通过分代回收提高垃圾回收的效率。

6.怎么节省内存?

  • 手动回收不需要用的变量;
  • 将数值型数据转化为32位或16位(对数据类型进行限制)

代码示例如下:

def reduce_mem_usage(props):
    # 计算当前内存
    start_mem_usg = props.memory_usage().sum() / 1024 ** 2
    print("Memory usage of the dataframe is :", start_mem_usg, "MB")
    
    # 哪些列包含空值,空值用-999填充。why:因为np.nan当做float处理
    NAlist = []
    for col in props.columns:
        # 这里只过滤了object格式,如果你的代码中还包含其他类型,请一并过滤
        if (props[col].dtypes != object):
            
            print("**************************")
            print("columns: ", col)
            print("dtype before", props[col].dtype)
            
            # 判断是否是int类型
            isInt = False
            mmax = props[col].max()
            mmin = props[col].min()
            
            # Integer does not support NA, therefore Na needs to be filled
            if not np.isfinite(props[col]).all():
                NAlist.append(col)
                props[col].fillna(-999, inplace=True) # 用-999填充
                
            # test if column can be converted to an integer
            asint = props[col].fillna(0).astype(np.int64)
            result = np.fabs(props[col] - asint)
            result = result.sum()
            if result < 0.01: # 绝对误差和小于0.01认为可以转换的,要根据task修改
                isInt = True
            
            # make interger / unsigned Integer datatypes
            if isInt:
                if mmin >= 0: # 最小值大于0,转换成无符号整型
                    if mmax <= 255:
                        props[col] = props[col].astype(np.uint8)
                    elif mmax <= 65535:
                        props[col] = props[col].astype(np.uint16)
                    elif mmax <= 4294967295:
                        props[col] = props[col].astype(np.uint32)
                    else:
                        props[col] = props[col].astype(np.uint64)
                else: # 转换成有符号整型
                    if mmin > np.iinfo(np.int8).min and mmax < np.iinfo(np.int8).max:
                        props[col] = props[col].astype(np.int8)
                    elif mmin > np.iinfo(np.int16).min and mmax < np.iinfo(np.int16).max:
                        props[col] = props[col].astype(np.int16)
                    elif mmin > np.iinfo(np.int32).min and mmax < np.iinfo(np.int32).max:
                        props[col] = props[col].astype(np.int32)
                    elif mmin > np.iinfo(np.int64).min and mmax < np.iinfo(np.int64).max:
                        props[col] = props[col].astype(np.int64)  
            else: # 注意:这里对于float都转换成float16,需要根据你的情况自己更改
                props[col] = props[col].astype(np.float16)
            
            print("dtype after", props[col].dtype)
            print("********************************")
    print("___MEMORY USAGE AFTER COMPLETION:___")
    mem_usg = props.memory_usage().sum() / 1024**2 
    print("Memory usage is: ",mem_usg," MB")
    print("This is ",100*mem_usg/start_mem_usg,"% of the initial size")
复制代码

7.pandas库怎么读取超大型文件?

可以采取分块读取数据的方式。

代码示例如下:

data_path = r'E:\python\Study\BiGData\demo.csv'
def read_bigfile(path):
    # 分块,每一块是一个chunk,之后将chunk进行拼接
    df = pd.read_csv(path, engine='python', encoding='gbk', iterator=True)  
    loop = True
    chunkSize = 10000
    chunks = []
    while loop:
        try:
            chunk = df.get_chunk(chunkSize)
            chunks.append(chunk)
        except StopIteration:
            loop = False
            print("Iteration is stopped.")
    df = pd.concat(chunks, ignore_index=True)
after_df = read_bigfile(path = data_path)
复制代码

8.无重复字符的最长子串

该题为leetcode-3,难度:【中等】

方法:双指针 + sliding window

定义两个指针 start 和 end 得到 sliding window

start 初始为0,用end线性遍历每个字符,用 recod 记录下每个字母最新出现的下标

两种情况:一种是新字符没有在 record 中出现过,表示没有重复,一种是新字符 char 在 record 中出现过,说明 start 需要更新,取 start 和 record[char]+1 中的最大值作为新的 start。

需要注意的是:两种情况都要对record进行更新,因为是新字符没在record出现过的时候需要添加到record中,而对于出现过的情况,也需要把record中对应的value值更新为新的下标。

代码:

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        record = {}
        start,res = 0,0
        for end in range(len(s)):
            if s[end] in record:
                start = max(start, record[s[end]] + 1)
            record[s[end]] = end
            res = max(res, end - start + 1)
        return res
复制代码

时间复杂度:O(n)

空间复杂度:O(1)

9.判断链表是否有环、链表环的入口

判断链表是否有环为leetcode-141题

提供两种解题方法,如下:

方法一:哈希表

遍历所有节点,每次遍历一个节点时,判断该节点此前是否被访问过。

如果被访问过,说明该链表是环形链表,并返回True,如果没有,则将该节点加入到哈希表中,遍历完成即可。

代码如下:

class Solution:
    def hasCycle(self, head: ListNode) -> bool:
        seen = set()
        while head:
            if head in seen:
                return True
            seen.add(head)
            head = head.next
        return False
复制代码

时间复杂度:O(n)

空间复杂度:O(n)

方法二:快慢指针

定义两个指针,一快一慢,满指针每一移动一步,快指针每次移动两步,由于快指针比慢指针慢,如果链表有环,则快指针一定会和慢指针相遇。

代码如下:

class Solution:
    def hasCycle(self, head: ListNode) -> bool:
        fast = slow = head
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
            if fast == slow:
                return True
        return False
复制代码

时间复杂度:O(N)

空间复杂度:O(1)

链表环的入口 为leetcode-142题

解题思路:使用快慢指针

首先,我们要做以下设定,设链表共有 a + b个节点,其中链表头部到链表入口(不计链表入口节点)有 a 个节点,链表环有 b 个节点,同时设快指针走了 f 步,慢指针走了 s 步;

显然,由于快指针是慢指针的两倍,因此有:f = 2s

如果两个指针第一次相遇,则满足:f = s + nb(n表示n个环),也就是 fast 比 slow 多走了 n 个环的长度;

由上可得:当两个指针第一次相遇,有s = nb, f = 2nb

现在需要解决的问题,我们如何知道 a 的大小?

假设现在两指针第一次相遇:

对慢指针来说,如果让慢指针走到链表入口节点,需要 a + nb步,而在相遇时,已经走了 nb 步了,因此,再让慢指针走 a 步就可以走到链表入口节点了;

对快指针来说,如果让快指针从头指针开始走 a 步,快指针也正好走到链表入口节点;

由此可见,两指针发生第二次相遇的时候,刚好都在链表入口处。

代码如下:

class Solution:
    def detectCycle(self, head: ListNode) -> ListNode:
        fast = slow = head
        while True:
            if not (fast and fast.next):return
            fast = fast.next.next
            slow = slow.next
            if fast == slow:break
        fast = head
        while fast != slow:
            fast = fast.next
            slow = slow.next
        return fast
复制代码

时间复杂度 O(N)

空间复杂度 O(1)

分类:
人工智能
标签:
收藏成功!
已添加到「」, 点击更改