获取全部路径以及最短路径

代码

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
# -*- coding: utf8 -*-
#
import math
from typing import List


def trace_path(vec, pathes):
    if not vec:
        return pathes
    valid_pathes = []
    for item in vec[0]:
        for path in pathes:
            if item > path[-1]:
                valid_pathes.append([*path, item])

    return trace_path(vec=vec[1:], pathes=valid_pathes)


def get_all_valid_path(vec: List[List[int]]) -> List[List[int]]:
    if not vec: return []
    for v in vec:
        if not v:
            return []
    return trace_path(vec=vec[1:], pathes=[[i] for i in vec[0]])


def _sub_sum(path: List[int]) -> int:
    _sum = 0
    for index, item in enumerate(path):
        try:
            next_item = path[index + 1]
            _sum += (next_item - item)
        except IndexError:
            pass
    return _sum


def get_shortest_path(vec: List[List[int]]) -> List[int]:
    """
    输出最短的那个路径
    :param vec:
    :return:
    """
    pathes = get_all_valid_path(vec=vec)
    short_path, short_sum = [], math.inf

    for path in pathes:
        _sum = _sub_sum(path=path)
        if short_sum > _sum:
            short_path = path
            short_sum = _sum
    return short_path

测试

1
2
3
4
5
6
7
8
9
10
11
12
13
from unittest import TestCase

from path import get_all_valid_path, get_shortest_path


class TestPath(TestCase):
    def test_sample(self):
        self.assertEqual(get_all_valid_path([]), [])

        self.assertEqual(get_all_valid_path([[1, 3], [2, 5]]), [[1, 2], [1, 5], [3, 5]])

        self.assertEqual(get_shortest_path([[1, 3], [2, 5]]), [1, 2])

展开全文 >>

使用GAN思想进行纠错

引言

书接上文，上文在计算loss时一共分为两个。

  1. mlm loss(即macbert预测的loss)
  2. 二分类loss(即hidden states降维到1后与原始数据集的loss，即原始文本和正确文本相比，不同为1,相同为0)。

例如：

训练数据集 样本
original_text 我和你在一其
correct_text 我和你在一起
det_labels 0 0 0 0 0 1
  1. 将original_text输入到bert后，获得mlm_result，即我和你在一器。此为mlm loss。
  2. 在获得mlm_result同时，也可以获取hidden_states，将hidden_states输入到linear，再与det_labels做二分类。此为二分类loss。
  3. 分配两个loss不同的weight，作为最终loss，此为上篇文章的实现思路。

那这篇文章改动了什么？

实现思路

det_labels的获取方式更改了，怎么更改的？以mlm_result和correct_text进行对比进行获取。
如上例：即mlm_result输出我和你在一器，和correct_text我和你在一起进行对比。

即用GAN的思想来进行corrector!

实验结果

此处我将mlm预测称为generator（G）,二分类判别称为discriminator(D)。

分配G和D两者loss不同的weight。

1. 当weight分配是1和50

可以看到一个现象，不管dev_metric还是train_metric，在epoch2和epoch3的时候，它的准确度很突然下降，对应的loss也会比刚开始的大的许多。随后效果才会慢慢的提升。

2. 当weight分配是0.9和0.1

如果我把上图dev_metric展开下再和train_metric放到一起对比：

可以看到效果：

  1. 在epoch1出来时，效果基本就已经非常不错了。
  2. 在随后的epochs里，准确度的提升非常缓慢。

3. 当weight分配是0.1和0.9

4. 当weight分配是0.1和0.9，并且判别器添加GELU

分析

上面这些实验例子都有一个共同的现象：

  1. epoch1时准确率就已经不错了，相比上文。
  2. 都有抖动现象，就是在某个epoch时不管dev还是train都有抖动，随后再回到正常。

1. 当weight分配是1和50

首先解释为什么选择1和50,这个地方来自electra地方的思想，可看上文。

2. 当weight分配是0.9和0.1

整体很平滑，仿佛判别器没有起到作用似的或者作用很小。

3. 当weight分配是0.1和0.9

没什么大的意外。

但是让我意外的是下面4情况。

4. 当weight分配是0.1和0.9，并且判别器添加GELU

我在看《机器学习实战：基于Scikit-Learn和TensorFlow》第二版 时里面讲到训练GAN有些小trick，比如可以给判别器添加一个激活函数。

但是当添加后，发现其抖动的更为严重。。。

5. 为什么我选择0.1和0.9

这个是个实验值，没有具体理论依据哈，本身就是超参。看下图：

d_loss和g_loss分别是判别器和生成器各自的loss。

从上图可以看出，d_loss比g_loss小大概9~10倍，所以依据来源在此。

总结

当然还有一些其他的小技巧，就不做实验了，gan本来就难搞。。。

比如：

  1. 生成器的网络空间大小相比判别器调到1/4 ~ 1/2（来自electra）。具体做法就是减少层数或者降低每层的空间大小。
  2. 使用不一样的优化器。
  3. 改变训练技巧。生成器和判别器分别训练，当训练一个时，另外一个trainable=False。使其达到一个均衡。。

啥是模式崩溃？
就是当生成器学会苹果后，那判别器就会判别苹果。当生成器转头学会橘子后，那判别器会对橘子判别更准。
而对苹果和橘子共同存在的情况下效果不好。而达到一个纳什均衡。

参考

  1. 纳什均衡
  2. 模式崩溃

展开全文 >>

macbert4csc纠错

简介

此篇文章是对macbert4csc模型的一次尝试与思考，废话不多说，看内容。
[x180/macbert4csc-scalarmix-base-chinese]https://huggingface.co/x180/macbert4csc-scalarmix-base-chinese)。

模型结构

这个模型分成两部分：

  1. 使用BertForMaskedLM对预训练模型做mask训练。
  2. 对预测的结果输入linear，判断预测的结果和真实的结果是否相同，即二分类。

举例：
比如错句为我和你在一其，正确的句子为我和你在一起，错句输入MLM，得到的结果假设为我和你在一器。然后输入linear判别器，判断和正确的句子做二分类。最后两个loss进行相加。

思考

为什么选择macbert

首先看看什么是macbert,全称是(MLM as corrector)，它是哈工大和讯飞一起训练的模型。主要做的内容有两点：

  1. 修改bert mask预处理代码，将bert做[mask]的地方用同义词来替代。同时引入全词mask。
  2. 替换NSP任务，使用SOP来替代。

第一条的做法好处是下游任务一般不会有[mask]，那么就不会带来预训练模型和下游任务不匹配的问题。
第二条的做法好处是简单来讲就是更能理解句子的语义性（合理以及通顺）。

为什么代码没有在错字地方做mask

这个问题就是为什么选择macbert做微调，因为macbert对mlm中做mask替代的地方用了同义词替换。

和electra有什么关系

这个问题是我自己强行加进来的，哈哈。。

先来看下electra的结构图。

electra模型分成两部分：

  1. 生成器。例如上图，对the和painting做[MASK]，然后使用生成器进行训练获取结果, 其中the对了，painting对应了car。
  2. 将生成的结果送入判别器，和原句做二分类，发现painting生成错了。

其loss计算方式如下所示：

有木有发现，两者其实还蛮像的，哈哈。

下面是正经思考：

  1. 错字识别是否可以使用electra模型来训练？
  2. 其中 λ是否可以进行借鉴？

回答1：我觉得阔以，甚者我觉得结果要比macbert4csc更好，为什么？

  1. 实验结果，macbert4csc的训练结果没有electra的结果好，你可以说不是同一类型的任务。
  2. macbert做同义词替换，如果没有对应的同义词呢，或者说同义词替换更关注实体词呢，错字是有可能哪里都可能错的。
    但是，这些想法都是有些牵强的，只有自己跑出来才知道结果。

回答2：我觉得阔以，因为对于多loss，一般没有好的解决方法，明明超参数，只能实验呗。作者在这里选择了50，因为他认为
二分类相比mlm的交叉熵更容易一些，所以给予了更大的权重。

但是我觉得还可以有另外一种思路来参考，即灾难性遗忘，它是说下游任务对预训练模型进行fine-tune，会对预训练模型造成干扰，那么loss计算时可以分成两部分，pretrained loss和fine-tune loss，一般按经验fine-tune loss权重为0.5。

改进

一. 调整λ值

作者这里使用0.7/0.3的权重分配给MLM和sigmoid二分类，这里我对其做了如下调整：

ID MLM weight sigmoid二分类 weight dev metric
1 1 0.5 epoch26:0.9168
2 1 5 epoch35:0.914
3 1 50

1. ID（1）

以macbert eval.py为准进行测试，记得把macbert_model_dir改成自己的。

以epoch 26的模型为准：

1
2
Sentence Level: acc:0.7040, precision:0.8545, recall:0.6087, f1:0.7109, cost time:5.35 s
Sentence Level: acc:0.7955, precision:0.8093, recall:0.7661, f1:0.7871, cost time:10.53 s

和”shibing624/macbert4csc-base-chinese”进行对比，发现recall要高了不少，结果效果更好了些～。

2. ID（2）

dev metric 在epoch 35的时候为0.914，相比ID（1）在epoch 26 0.9168的结果，发现收敛速度变的慢了。
故这个忽略。

3. ID（3）

dev metric 在epoch 35的时候为0.9112，虽说还有小量上涨可能，但是train metric已经过拟合了，这个结果让我觉得…，emmmm，这些超参没有达到想象中的区别哇。

2. 对hidden_states分配权重

作者在进行二分类的时候使用了最后一层的hidden_states，那么是否可以对所有的hiddeen_states分配不同的权重。为什么？前面的layer更偏向浅层语义信息，比如词法，句法等，越往后代表的含义可能更深层次，本来就是预测词对不对，搞那么深不一定适合。
所以下面对其进行尝试。

添加scalarmix层，代码如下:

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
class ScalarMix(nn.Module):
    def __init__(self, n_layers, dropout=0.):
        super(ScalarMix, self).__init__()
        self.n_layers = n_layers

        self.weights = nn.Parameter(torch.zeros(n_layers))
        self.gamma = nn.Parameter(torch.tensor([1.0]))
        self.dropout = nn.Dropout(dropout)

    def __repr__(self):
        s = f"n_layers={self.n_layers}"
        if self.dropout.p > 0:
            s += f", dropout={self.dropout.p}"

        return f"{self.__class__.__name__}({s})"

    def forward(self, tensors):
        r"""
        Args:
            tensors (list[~torch.Tensor]):
                :math:`N` tensors to be mixed.
        Returns:
            The mixture of :math:`N` tensors.
        """

        normed_weights = self.dropout(self.weights.softmax(-1))
        weighted_sum = sum(w * h for w, h in zip(normed_weights, tensors))

        return self.gamma * weighted_sum

结果如下：

ID MLM weight sigmoid二分类 weight dev metric
1 1 0.5 epoch12：0.9118

为啥epoch 12就停了，因为train metric基本已经达到1了。。。

由此可见，整个准确率的提升，更多是在mlm这个任务上，加了二分类判断其对不对，整体影响并没那个大。。。

后来我发现了一个地方，mlm weight和二分类weight我给的是1和0.5，压缩到1之内就分别是0.6666和0.3333，我嘞个去，这不基本和作者的0.7和0.3很相近了么。。下次需要提前注意下。

最后

当我对mlm loss weight分配了更高的权重，结果发现效果有提升。

总结

  1. 对mlm和二分类分配不同权重发现，mlm的权重应该更高一些。这个和electra中那个50稍微有点偏差。不过我觉得又可以理解，因为它上游是生成器，任务不同～。
  2. 添加了ScalarMix层给hidden_states分配不同的权重，其对结果并没有产生有效影响，其本质问题还是在于mlm loss还是应该占据更大的比例。
  3. 至于为什么不尝试Chinese-BERT-wwm，因为MacBERT在其个任务效果对比中比前者整体表现会偏更好一些，另外都是做wwm，所以本质没有区别。

展开全文 >>

腾讯TexSmart备忘

备忘一下～

之前在看腾讯开源的词向量时，Tencent AI Lab Embedding Corpus for Chinese Words and Phrases，在看到Simple Cases那里，瞬间感到震撼！！果然大公司就是大公司，有钱有地位。。。

跟着公司做了一些技术研究和项目后，发现目前nlp之所以发展没到位，最主要原因就是：算法和数据分家。算法层面，目前整个学术界没有大的进步，另外像GPT3这种，一般玩不起。数据层面，没人开源数据，即使开源了，标注质量参差不齐，标注标准也是如此。那大家比什么，比的只有算法喽，结果最后就是华而不实（工业上应用）～。

那回到开始，觉得震撼之余，就在想那腾讯肯定也有相应的分词，结果找了半天，没找到。今天突然发现了，窃喜之余，记录一下。

关于它的介绍，TexSmart: 文本理解工具与服务，以及它的Demo，整体效果看下来，要好于目前很多开源的（当然，你懂我意思），大家算法可能都差不多。

但是分为离线版和http api版，差距有多大，这个木有尝试，反正官方说有差距。

以后尝试尝试。

参考地址：

  1. https://ai.tencent.com/ailab/nlp/zh/embedding.html
  2. https://ai.tencent.com/ailab/nlp/texsmart/zh/index.html
  3. https://texsmart.qq.com/zh

展开全文 >>

联邦学习介绍与分享

最近应宋总提议，给各个部门的老大介绍联邦学习。

** 点进去可以正常显示，此处可能是hexo-pdf插件问题 **

把他们问的问题再记录下：

  1. 领导A关注是共同富裕，比如大企业不愿意跟小企业玩。
  2. 领导B只关注自己问问题，解决当下的问题。
  3. 领导C在数据融合那里（横向、纵向）问了迁移学习问题。
  4. 其他比如标注和不标注的问题，安全问题，联合模型是否能反推出他人数据。

整体下来我觉得没有达到预期的最大的问题是在规则和样本那里，还有就是可能我写的还是太复杂了😂😂😂。

所以还是把这个记录下来，当我某天站在另外一个高度时再回过头来看下，可能会有新的理解。

展开全文 >>

pycorrector源码阅读和纠错一些思考

介绍

这篇文章主要对pycorrector默认使用规则的代码进行debug和理解，不论怎样，应先读下作者的readme，有个充分的理解先。

初始化工作

初始化主要做了三件事：

  1. 初始化一些词典，用于后面纠错用。
  2. 加载kenlm模型。
  3. 初始化jieba分词器。

1. 初始化一些词典等

  • 加载常用的汉字列表、加载同音字列表、加载形似字
1
2
3
4
5
6
7
8
9
10
11
check_corrector_initialized()

def _initialize_corrector(self):
    # chinese common char 加载常用的汉字列表，这里大概3000多个常见的汉字。
    self.cn_char_set = self.load_set_file(self.common_char_path)
    # same pinyin 加载同音的列表，自定义
    self.same_pinyin = self.load_same_pinyin(self.same_pinyin_text_path)
    # same stroke 加载形似字，比如{坐:[座, ...]}， 自定义
    self.same_stroke = self.load_same_stroke(self.same_stroke_text_path)
    self.initialized_corrector = True

  • 转unicode
1
2
# 编码统一，utf-8 to unicode
text = convert_to_unicode(text)
  • 长句分短句

额外插句：单从re_han这里就可以看出，作者至少对jieba很熟悉。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
def split_2_short_text(text, include_symbol=False):
    """
    长句切分为短句
    :param text: str
    :param include_symbol: bool
    :return: (sentence, idx)
    """
    result = []
    blocks = re_han.split(text)
    start_idx = 0
    for blk in blocks:
        if not blk:
            continue
        if include_symbol:
            result.append((blk, start_idx))
        else:
            if re_han.match(blk):
                result.append((blk, start_idx))
        start_idx += len(blk)
    return result

2. 加载kenlm模型

关于kenlm，网上搜了下，除了纠错基本很少有人用到（而且还是针对pycorrector～），只有这篇文章说的还有点意思，而且看Github kenlm介绍，作者也是十分任性，只强调速度，没有强调用处。。。

简单来讲，kenlm是基于n-gram训练出来的一个预训练模型，它的更多用法可看Example。

3. 初始化jieba

  • 加载词频
    （这个我看了下，和jieba自带的那个dict.txt基本没关系，相当于作者自己训练了一个词频词典）
    ~~ * 自定义混淆集（空的，所以忽略这步）~~

  • 自定义切词词典
    （默认是空，个人感觉可以把jieba那个dict.txt加进去，哈哈哈）

  • 一些特定词典
    人名词典词频、place词典词频、停用词词典词频、将这些词典词频合并到一起

对于人名和place这种词典，不如使用现成了命名实体模型，这种词典的方式总之是无法完全枚举的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 # 词、频数dict, TODO: 这里虽然有，但是貌似没有用到
self.word_freq = self.load_word_freq_dict(self.word_freq_path)
# 自定义混淆集
self.custom_confusion = self._get_custom_confusion_dict(self.custom_confusion_path)
# 自定义切词词典
self.custom_word_freq = self.load_word_freq_dict(self.custom_word_freq_path)
self.person_names = self.load_word_freq_dict(self.person_name_path)
self.place_names = self.load_word_freq_dict(self.place_name_path)
self.stopwords = self.load_word_freq_dict(self.stopwords_path)
# 合并切词词典及自定义词典
self.custom_word_freq.update(self.person_names)
self.custom_word_freq.update(self.place_names)
self.custom_word_freq.update(self.stopwords)
self.word_freq.update(self.custom_word_freq) # TODO:这里
self.tokenizer = Tokenizer(dict_path=self.word_freq_path, custom_word_freq_dict=self.custom_word_freq,
                            custom_confusion_dict=self.custom_confusion)

错字识别

1. 基于word级别的错字识别

这部分使用jieba的search模式进行分词。

它的实现原理是：先使用hmm进行分词，比如少先队员因该为老人让坐，它的分词结果是["少先队员", "因该", "为", "老人", "让", "坐"]，然后对每个词再用2阶gram和3阶gram进行切分，在self.FREQ中进行查找是否存在，得到的结果如下：

1
2
3
4
5
6
7
8
('队员', 2, 4)
('少先队', 0, 3)
('少先队员', 0, 4)
('因该', 4, 6)
('为', 6, 7)
('老人', 7, 9)
('让', 9, 10)
('坐', 10, 11)

分完词后，按词粒度判断是否在词典里，符号，英文则跳过,否则则认为是可能错的。

到这里识别出因该是可能错误的。

2. 基于kenlm级别的错字识别

取bigram和trigram，通过kenlm获取对应的score，然后求平均获取和句子长度一致的score。

比如：

1
2
sent_scores = [-5.629326581954956, -6.566553155581156, -6.908517241477966, -7.255491574605306, -7.401519060134888, -7.489806890487671, -7.1438290278116865, -6.559153278668722, -6.858733296394348, -7.7903218269348145, -8.28114366531372]

然后通过这个sent_scores取判断哪些index是错的。

那作者是怎么判断的呢？

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
def _get_maybe_error_index(scores, ratio=0.6745, threshold=2):
    """
    取疑似错字的位置，通过平均绝对离差（MAD）
    :param scores: np.array
    :param ratio: 正态分布表参数
    :param threshold: 阈值越小，得到疑似错别字越多
    :return: 全部疑似错误字的index: list
    """
    result = []
    scores = np.array(scores)
    if len(scores.shape) == 1:
        scores = scores[:, None]
    median = np.median(scores, axis=0)  # get median of all scores
    margin_median = np.abs(scores - median).flatten()  # deviation from the median
    # 平均绝对离差值
    med_abs_deviation = np.median(margin_median)
    if med_abs_deviation == 0:
        return result
    y_score = ratio * margin_median / med_abs_deviation
    # 打平
    scores = scores.flatten()
    maybe_error_indices = np.where((y_score > threshold) & (scores < median))
    # 取全部疑似错误字的index
    result = [int(i) for i in maybe_error_indices[0]]
    return result
  1. 按照百度百科平均绝对离差的定义：平均绝对离差定义为各数据与平均值的离差的绝对值的平均数，那作者这里的计算方式貌似就不一样了。
  2. 作者这里的计算方式不是求平均值，而是每个值减去中位数，然后再求中位数，这样做的好处更多是防止数据分布比较大，就比如大家的平均工资都很高～
  3. 作者接着使用两个比较，（1）ratio * np.abs(score - median) / 平均绝对离差
    (2)scores 小于 中位数的，这地方看的迷迷糊糊，总有种凭经验的感觉。
  4. 获取对应的错字index。

至此获取到的可能错误列表是：

1
[['因该', 4, 6, 'word'], ['坐', 10, 11, 'char']]

纠错

1. 获取纠错候选集

假设当前输入word是因该：

  • 一、获取词粒度的候选集
  1. 获取相同拼音的（不包含声调） _confusion_word_set
  2. 自定义混淆集 _confusion_custom_set

他这个获取相同拼音的写法就让我觉得emo，直接在self.known(自定义词典)里找长度相同，然后判断拼音一样不就得了～

自定义混淆集就是自定义一些经验进行。比如{“因该”: “应该”}这种，增大候选集。

  • 二、获取基于字粒度的候选集

这地方分成三部分：

  1. 如果word的长度等于1。获取相同拼音的same pinyin 加载同音的列表，以及加载形似字same stroke 加载形似字。
  2. 如果word的长度等于2。截取第一个字符，如因，然后获取相同拼音的same pinyin 加载同音的列表，以及加载形似字same stroke 加载形似字，然后和该进行拼接，获取新的候选集。第二个字该执行相同操作。
  3. 如果word的长度大于2。同理上述操作，只不过粒度不同（此处忽略）。
  • 三、对候选集进行排序，以word_freq进行排序，然后只截取前K个候选集

2. 从候选集里面进行筛选

这个地方就有意思了，如何获取最正确的那个呢？看下面代码。

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
def get_lm_correct_item(self, cur_item, candidates, before_sent, after_sent, threshold=57, cut_type='char'):
    """
    通过语言模型纠正字词错误
    :param cur_item: 当前词
    :param candidates: 候选词
    :param before_sent: 前半部分句子
    :param after_sent: 后半部分句子
    :param threshold: ppl阈值, 原始字词替换后大于该ppl值则认为是错误
    :param cut_type: 切词方式, 字粒度
    :return: str, correct item, 正确的字词
    """
    result = cur_item
    if cur_item not in candidates:
        candidates.append(cur_item)
    # 对每个候选集进行拼接成新句子，然后进行计算ppl_score。
    ppl_scores = {i: self.ppl_score(segment(before_sent + i + after_sent, cut_type=cut_type)) for i in candidates}
    sorted_ppl_scores = sorted(ppl_scores.items(), key=lambda d: d[1])

    # 增加正确字词的修正范围，减少误纠
    top_items = []
    top_score = 0.0
    for i, v in enumerate(sorted_ppl_scores):
        v_word = v[0]
        v_score = v[1]
        if i == 0:
            top_score = v_score
            top_items.append(v_word)
        # 通过阈值修正范围
        elif v_score < top_score + threshold:
            top_items.append(v_word)
        else:
            break
    if cur_item not in top_items:
        result = top_items[0]
    return result

核心的地方在self.ppl_score那里，代码如下：

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

def ppl_score(self, words):

    
    """
    words比如：['少', '先', '队', '员', '应', '该', '为', '老', '人', '让', '坐']
    取语言模型困惑度得分，越小句子越通顺
    :param words: list, 以词或字切分
    :return:
    """
    self.check_detector_initialized()
    return self.lm.perplexity(' '.join(words))

看作者注释，说的很明白了，如果这个句子越是流畅的，那么他的score就会更高。

1
2
3
4
5
6
7
8
9
10
pprint(sorted_ppl_scores)
[('应该', 144.39704182754554),
 ('因改', 236.80615502078768),
 ('因该', 284.14769660593794),
 ('听该', 357.8835799332408),
 ('因盖', 360.68106481988417),
 ('因核', 365.9438178618582),
 # 这里只截取一部分！！
]

最后一步，作者以score最高的那个加了一个threshold，如果得分在这个阈值内的，添加到候选的top_items里面。
如果当前的cur_item,即因该不在这个候选集里，那么取第一个top_items，如果在，那么就返回当前的cur_item。

这步的目的在于防止误判。

思考

  1. 对于时间日期、人名这种，个人感觉应该先用命名实体剔除掉。
  2. 自定义词典、形近词那里会是个问题，比如量少或者有歧义怎么解决，另外因该也是有可能作为一个单独的词，只是出现的可能性较小。
  3. 默认加载的是5-gram，关于这里为什么用5-gram没细研究。
  4. 关于字粒度纠错，那里我感觉真统计。。。
  5. 不过我喜欢纠错那里，方式简单直接。不过候选集那里可能会是个瓶颈。

展开全文 >>

SIFRank_zh与关键词提取

介绍

本文尝试从几个方面来介绍提取关键词所知的技术，以及关键词提取所遇到的问题，接着介绍SIFRank-zh算法，最后穿插下个人的理解与总结。

关键词提取技术

刚开始接触这个概念的时候，网上一大堆介绍TF-IDF和TextRank算法，这俩简直已经称为了关键词提取的baseline。
关于TF-IDF，的确在许多文档中已经作为了baseline来和其他技术相对比，是一种简单易行并且效果不差的无监督技术。
TextRank具体我没看，此处略过。

关键词提取步骤

  1. 候选词提取
  2. 排序

候选词提取所遇到的问题

那么，此处引入一个问题，什么叫关键词？换句话说，什么样的词我们认为是关键词？

比如一句话：从2021年11月1日起，南京各个社区将尝试采取网格化管理，增强人民群众安全。，不同分词器的结果如下：

  • lac的分词结果:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    [('从', 'p'),
     ('2021年11月1', 'TIME'),
     ('日起', 'q'),
     ('，', 'w'),
     ('南京', 'LOC'),
     ('各个', 'r'),
     ('社区', 'n'),
     ('将', 'd'),
     ('尝试', 'v'),
     ('采取', 'v'),
     ('网格化', 'vn'),
     ('管理', 'vn'),
     ('，', 'w'),
     ('增强', 'v'),
     ('人民群众', 'n'),
     ('安全', 'an'),
     ('。', 'w')]


  • ltpV3版本的分词结果:

    1
    2
    3
    4
    ['从', '2021年', '11月', '1日', '起', '，',
    '南京', '各个', '社区', '将', '尝试', '采取',
    '网格化', '管理', '，', '增强', '人民', '群众', '安全', '。'
    ]

这里我想突出一个问题，目前市面所见的所有分词器都是采用细粒度分词，那这就导致一个最直接的问题，就是关键信息词被拆开了。
这句话本质想突出网格化管理这个词，但是在两个分词器中都将其分成了两个词。

你可以说NER可以解决这个问题哇，从技术角度本身来讲，这的确是可行的。比如时间短语，机构短语，地址短语。
你也可以说数据标注标准不同，比如msra或者ptb数据集。
你也可以说粗粒度分词会更容易产生歧义。比如白天鹅在湖中游等等。这条不太认同。
你也可以说粗粒度分词下如果想获取更细粒度分词则无法获得。这条我认为可有可无。

但是我想说的是，那能不能有一个分词器，从使用效果上来讲更贴切人直观感受，不需要关注底层分词和NER这两种技术的。

可惜没有！

之前我看腾讯开源了一个训练好的word2vec模型，在Simple Cases那里，简直看到了希望！！

当时就在想，怎么根据word2vec反推出一个分词？

过程就是分词和word2vec训练放到一个任务中，但是只保存分词的模型。

然后在脑里想分词实现技术有哪些，首先肯定排除掉最长距离或者最短距离分词，那么能想到的只有HMM和CRF。
不管HMM还是CRF，本质都是计算状态概率转移矩阵和发射概率矩阵，HMM多了个初始概率矩阵，这个还好。

但是想了半天，貌似都不太可行，为什么？

  1. 每个句子到底有多少种切分方式，就决定了有多少训练可能性，数据集无法确定。比如商品和服务，有['商品', '和', '服务']以及['商品', '和服', '务']，仅仅这个例子，就有两种可能性，如果一个句子过长的话甚者有很多中语料的话，就无法估算那个语料才是真正正确的那个。那么在无法估计正确语料这条路来讲，crf就不可行。
  2. 对于hmm来讲，我记得使用统计的方式来做，印象中记得有一阶词频，还有二阶词频。。。emmmm，哈哈，忘完了，不管怎么说，会形成一个基于词的有向无环图。每次分词在这个图上使用vertbi算法进行迭代获取最终分词效果。但是问题是，怎么估算这些参数并应用于分词上且将其应用到word2vec训练预料并产生最终的word2vec模型。

emmmmm，但是我觉得可以换条思路来实现，那就是用于辅助标注人员的方式来重标数据集，或者对标注人员说，我更倾向于使用粗粒度分词的。

额，说了这么些，感觉貌似又回到了起点。

但是是一劳永逸的一种方式。

候选词提取可参考的方式

上面介绍了这么多，本质来讲是想提取更粗粒度的，那么我们基于现有的条件下，可以借鉴的实现方式：

  1. 基于词性进行聚合。比如名词和名词聚合，动名词和名词聚合，以及一些自定义情况则进行聚合，如果聚合后在一个粗粒度分词词典中，那么权重应更高。
  2. 添加自定义词典。在适用于自己产品的方向上添加自定义词典，也是比较合适的实现方式。

排序

排序的本质是正确代表语句或文本的真实意图或者需要涵盖的方面点。从无监督方式出发的话，我们能够利用的特征：

  1. 位置信息
  2. 预训练模型
  3. 领域信息

SIFRank以及SIFRank+的实现

SIFRank的实现主要分为以下步骤：

  1. 初始化elmo，thunlp（添加自定义词典）
  2. 分词，停用词处理，提取候选关键词，通过正则表达
  3. 分句，按句号和长度16来分。
  4. 获取elmo每层的输出。
  5. 对每个token取elmo第一层的平均值，取代掉elmo最后一层。
  6. 将不同句中elmo的hidden_size进行concat到一个维度上。
  7. 给予不同词不同的权重，比如停用词为0,符号为0,以及处理oov情况。
  8. 获取整段话的每层平均向量。
  9. 获取候选词的每层平均向量。
  10. 获取每个候选词与整段话的余弦距离。排序
  11. 获取positional score。 （SIFRank+）

接下来会对其实现做更具体说明。

关于elmo和ELMoForManyLangs

ELMoForManyLangs，SIFRank_zh作者指出的关于:

1
哈工大的elmoformanylangs 0.0.3中有个较为明显的问题，当返回所有层Embeddings的时候代码写错了，当output_layer=-2时并不是返回所有层的向量，只是返回了倒数第二层的。问题讨论在这里#31

已经解决，故可以忽略。

测试代码以官方test.py为准。

初始化elmo，thunlp（添加自定义词典）

1
2
3
4
5
#download from https://github.com/HIT-SCIR/ELMoForManyLangs
model_file = r'../auxiliary_data/zhs.model/'
# 初始化elmo
ELMO = word_emb_elmo.WordEmbeddings(model_file)
SIF = sent_emb_sif.SentEmbeddings(ELMO, lamda=1.0)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class SentEmbeddings():

    def __init__(self,
                 word_embeddor,
                 weightfile_pretrain='../auxiliary_data/dict.txt',
                 weightfile_finetune='../auxiliary_data/dict.txt',
                 weightpara_pretrain=2.7e-4,
                 weightpara_finetune=2.7e-4,
                 lamda=1.0,database="",embeddings_type="elmo"):

        self.word2weight_pretrain = get_word_weight(weightfile_pretrain, weightpara_pretrain)
        self.word2weight_finetune = get_word_weight(weightfile_finetune, weightpara_finetune)
        self.word_embeddor = word_embeddor
        self.lamda=lamda
        self.database=database
        self.embeddings_type=embeddings_type
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
def get_word_weight(weightfile="", weightpara=2.7e-4):
    """
    Get the weight of words by word_fre/sum_fre_words
    :param weightfile
    :param weightpara
    :return: word2weight[word]=weight : a dict of word weight
    """
    if weightpara <= 0:  # when the parameter makes no sense, use unweighted
        weightpara = 1.0
    word2weight = {}
    word2fre = {}
    with open(weightfile, encoding='UTF-8') as f:
        lines = f.readlines()
    # sum_num_words = 0
    sum_fre_words = 0
    for line in lines:
        word_fre = line.split()
        # sum_num_words += 1
        if (len(word_fre) >= 2):
            word2fre[word_fre[0]] = float(word_fre[1])
            sum_fre_words += float(word_fre[1])
        else:
            print(line)
    # 这地方效果：如果一个词出现的频率越高，那么它的权重就越低
    # 可看： https://github.com/sunyilgdx/SIFRank_zh/issues/14
    for key, value in word2fre.items():
        word2weight[key] = weightpara / (weightpara + value / sum_fre_words)
        # word2weight[key] = 1.0 #method of RVA
    return word2weight

这地方主要干了初始化elmo和以jieba分词统计的词频为主进行获取词的权重。

  1. 分词使用thunlp，但是以jieba同级的词频为主，这地方不合适。
  2. 这样获取词的权重，也不太合适。是否可以使用tf-idf呢。

分词，停用词处理，提取候选关键词，通过正则表达

1
2
3
zh_model = thulac.thulac(model_path=r'../auxiliary_data/thulac.models/',user_dict=r'../auxiliary_data/user_dict.txt')
elmo_layers_weight = [0.0, 1.0, 0.0]

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
class InputTextObj:
    """Represent the input text in which we want to extract keyphrases"""

    def __init__(self, zh_model, text=""):
        """
        :param is_sectioned: If we want to section the text.
        :param zh_model: the pipeline of Chinese tokenization and POS-tagger
        :param considered_tags: The POSs we want to keep
        """
        self.considered_tags = {'n', 'np', 'ns', 'ni', 'nz','a','d','i','j','x','g'}

        self.tokens = []
        self.tokens_tagged = []
        # self.tokens = zh_model.cut(text)
        word_pos = zh_model.cut(text)
        self.tokens = [word_pos[0] for word_pos in word_pos]
        self.tokens_tagged = [(word_pos[0],word_pos[1]) for word_pos in word_pos]
        assert len(self.tokens) == len(self.tokens_tagged)
        for i, token in enumerate(self.tokens): # 停用词处理
            if token.lower() in stopword_dict:
                self.tokens_tagged[i] = (token, "u")
            if token == '-':
                self.tokens_tagged[i] = (token, "-")
        self.keyphrase_candidate = extractor.extract_candidates(self.tokens_tagged, zh_model)


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
GRAMMAR_zh = """  NP:
        {<n.*|a|uw|i|j|x>*<n.*|uw|x>|<x|j><-><m|q>} # Adjective(s)(optional) + Noun(s)"""

def extract_candidates(tokens_tagged, no_subset=False):
    """
    Based on part of speech return a list of candidate phrases
    :param text_obj: Input text Representation see @InputTextObj
    :param no_subset: if true won't put a candidate which is the subset of an other candidate
    :return keyphrase_candidate: list of list of candidate phrases: [tuple(string,tuple(start_index,end_index))]
    """
    np_parser = nltk.RegexpParser(GRAMMAR_zh)  # Noun phrase parser
    keyphrase_candidate = []
    np_pos_tag_tokens = np_parser.parse(tokens_tagged)
    count = 0
    for token in np_pos_tag_tokens:
        if (isinstance(token, nltk.tree.Tree) and token._label == "NP"):
            np = ''.join(word for word, tag in token.leaves())
            length = len(token.leaves())
            start_end = (count, count + length)
            count += length
            keyphrase_candidate.append((np, start_end))

        else:
            count += 1

    return keyphrase_candidate
  1. 分词
  2. 处理停用词和特殊符号词性
  3. 根据目标词性通过正则匹配获取候选词

阶段小结

到这里位置作者完成了对候选词的处理，还是回到最上面讲候选词获取那里的问题，如果有一个更合适的分词器。

  1. 那么这里我们就可以重新获取dict.txt。
  2. 不需要这么复杂的正则表达式来获取候选词。
  3. 接下来的获取候选词词向量那里也会更适合。

另外一个方面，关于正则匹配那：

  1. 我们可以不局限于词性，也可以根据词的信息来合并，比如’和’，‘的’等字。
  2. 针对特定词进行对分词器做调整。

分句，按句号和长度16来分

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
def get_sent_segmented(tokens):
    """
    按照.和。进行分段
    但是这个分法很个性，只有大于16才分割，否则不分
    :param tokens:
    :return:
    """
    min_seq_len = 16
    sents_sectioned = []
    if (len(tokens) <= min_seq_len):
        sents_sectioned.append(tokens)
    else:
        position = 0
        for i, token in enumerate(tokens):
            if (token == '.' or token =='。'):
                if (i - position >= min_seq_len):
                    sents_sectioned.append(tokens[position:i + 1])
                    position = i + 1
        if (len(tokens[position:]) > 0):
            sents_sectioned.append(tokens[position:])

    return sents_sectioned

但是想不明白的是，干嘛不直接用一个更成熟的分句工具呢，比如ltp和hanlp中都有现成的。

这一步和获取elmo每层输出作者将其称为文档分割（document segmentation，DS），其作用如下：

1
DS：通过将文档分为较短且完整的句子（如16个词左右），并行计算来加速ELMo；

获取elmo每层的输出

注意，下面将不区分elmo和ELMoForManyLangs,如果不做说明，则统一为ELMoForManyLangs。

1
2
3
4
5
6
7
8
9
10
11
def get_tokenized_words_embeddings(self, sents_tokened):
    """
    @see EmbeddingDistributor
    :param tokenized_sents: list of tokenized words string (sentences/phrases)
    :return: ndarray with shape (len(sents), dimension of embeddings)
    """
    max_len = max([len(sent) for sent in sents_tokened])
    elmo_embedding = self.elmo.sents2elmo(sents_tokened,output_layer=-2)
    elmo_embedding = [np.pad(emb, pad_width=((0,0),(0,max_len-emb.shape[1]),(0,0)) , mode='constant') for emb in elmo_embedding]
    elmo_embedding = torch.from_numpy(np.array(elmo_embedding))
    return elmo_embedding

elmo输出为三层结构，这个可以在ELMoForManyLangs中看到，

1
2
3
4
5
6
7
output_layer: the target layer to output.
0 for the word encoder
1 for the first LSTM hidden layer
2 for the second LSTM hidden layer
-1 for an average of 3 layers. (default)
-2 for all 3 layers

比如sents_tokened长度为[44, 110]，输出结果elmo_embedding为torch.Size([2, 3, 110, 1024])。

对每个token取elmo第一层的平均值，取代掉elmo最后一层

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
def context_embeddings_alignment(elmo_embeddings, tokens_segmented):

    """
    Embeddings Alignment
    :param elmo_embeddings: The embeddings from elmo
    :param tokens_segmented: The list of tokens list
     <class 'list'>: [['今', '天', '天气', '真', '好', '啊'],['潮水', '退', '了', '就', '知道', '谁', '没', '穿', '裤子']]
    :return:
    """
    token_emb_map = {}
    n = 0
    for i in range(0, len(tokens_segmented)):
        # 一词多义，将相同词的emb append到一起
        for j, token in enumerate(tokens_segmented[i]):
            # 获取第一层的embedding, 1 for the first LSTM hidden layer
            emb = elmo_embeddings[i, 1, j, :]
            if token not in token_emb_map:
                token_emb_map[token] = [emb]
            else:
                token_emb_map[token].append(emb)
            n += 1
    # 求每个token的平均值
    anchor_emb_map = {}
    for token, emb_list in token_emb_map.items():
        average_emb = emb_list[0]
        for j in range(1, len(emb_list)):
            average_emb += emb_list[j]
        average_emb /= float(len(emb_list))
        anchor_emb_map[token] = average_emb
    # 替换掉elmo最后一层的词对应的词向量
    for i in range(0, elmo_embeddings.shape[0]):
        for j, token in enumerate(tokens_segmented[i]):
            emb = anchor_emb_map[token]
            elmo_embeddings[i, 2, j, :] = emb

    return elmo_embeddings

这地方做了三件事情：

  1. 获取每个词对应的词向量，将相同词的向量append到一起。
  2. 求每个词的平均词向量
  3. 替换掉elmo最后一层的词对应的词向量

这一步作者叫做词向量对齐（embeddings alignment，EA）,其作用如下：

1
EA：同时利用锚点词向量对不同句子中的相同词的词向量进行对齐，来稳定同一词在相同语境下的词向量表示。

将不同句中elmo的hidden_size进行concat到一个维度上

1
2
3
4
5
6
7
def splice_embeddings(elmo_embeddings,tokens_segmented):
    new_elmo_embeddings = elmo_embeddings[0:1, :, 0:len(tokens_segmented[0]), :]
    for i in range(1, len(tokens_segmented)):
        emb = elmo_embeddings[i:i + 1, :, 0:len(tokens_segmented[i]), :]
        new_elmo_embeddings = torch.cat((new_elmo_embeddings, emb), 2)
    return new_elmo_embeddings

比如tokens_segmented长度为[44, 110]，elmo_embeddingsshape为:torch.Size([2, 3, 110, 1024])。
那么new_elmo_embeddings的shape为：torch.Size([1, 3, 154, 1024])。

给予不同词不同的权重，比如停用词为0,符号为0,以及处理oov情况

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def get_weight_list(word2weight_pretrain, word2weight_finetune, tokenized_sents, lamda, database=""):
    weight_list = []
    for word in tokenized_sents:
        word = word.lower()

        if(database==""):
            weight_pretrain = get_oov_weight(tokenized_sents, word2weight_pretrain, word, method="max_weight")
            weight=weight_pretrain
        else:
            weight_pretrain = get_oov_weight(tokenized_sents, word2weight_pretrain, word, method="max_weight")
            weight_finetune = get_oov_weight(tokenized_sents, word2weight_finetune, word, method="max_weight")
            weight = lamda * weight_pretrain + (1.0 - lamda) * weight_finetune
        weight_list.append(weight)

    return weight_list
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def get_oov_weight(tokenized_sents,word2weight,word,method="max_weight"):
    try:
        word=wnl.lemmatize(word)
    except:
        nltk.download('wordnet')
        nltk.download('omw-1.4')

    if(word in word2weight):#
        return word2weight[word]

    if(word in stop_words):
        return 0.0

    if(word in english_punctuations or word in chinese_punctuations):#The oov_word is a punctuation
        return 0.0

    if(method=="max_weight"):#Return the max weight of word in the tokenized_sents
        max=0.0
        for w in tokenized_sents:
            if(w in word2weight and word2weight[w]>max):
                max=word2weight[w]
        return max
    return 0.0

就是根据dict.txt计算出每个词的权重，所获取到的.

获取整段话的每层平均向量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def get_weighted_average(tokenized_sents, sents_tokened_tagged,weight_list, embeddings_list, embeddings_type="elmo"):
    # weight_list=get_normalized_weight(weight_list)
    assert len(tokenized_sents) == len(weight_list)
    num_words = len(tokenized_sents)
    e_test_list=[]
    if (embeddings_type == "elmo" or embeddings_type == "elmo_sectioned"):
        # assert num_words == embeddings_list.shape[1]
        sum = torch.zeros((3, 1024))
        for i in range(0, 3):
            for j in range(0, num_words):
                if(sents_tokened_tagged[j][1] in considered_tags):
                    e_test=embeddings_list[i][j]
                    e_test_list.append(e_test)
                    sum[i] += e_test * weight_list[j]

            sum[i] = sum[i] / float(num_words)
        return sum
    else:
        print('其他的忽略。')
  1. 初始化一个shape为(3, 1024)的矩阵，因为elmo为3层，1024为输出的hidden_size。
  2. 和上面获取不同词权重结合，并且只计算考虑的词性。比如(n,np,ns)等。
  3. 将elmo每层的计算的平均结果保存。

注意这里哦，这里有两点需要注意的：

  1. elmo第三层不是原来第三层的结果了，是作者称为词向量对齐的给替代了。
  2. 他计算的是只考虑的词性，而不是所有词的平均向量。

获取候选词的每层平均向量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def get_candidate_weighted_average(tokenized_sents, weight_list, embeddings_list, start,end,embeddings_type="elmo"):
    """获取候选词在每一层的平均向量"""
    # weight_list=get_normalized_weight(weight_list)
    assert len(tokenized_sents) == len(weight_list)
    # num_words = len(tokenized_sents)
    num_words =end - start
    e_test_list=[]
    if (embeddings_type == "elmo" or embeddings_type == "elmo_sectioned"):
        # assert num_words == embeddings_list.shape[1]
        sum = torch.zeros((3, 1024))
        for i in range(0, 3):
            for j in range(start, end):
                e_test=embeddings_list[i][j]
                e_test_list.append(e_test)
                sum[i] += e_test * weight_list[j]
            sum[i] = sum[i] / float(num_words)

        return sum

整个计算过程和上一步基本一致。

阶段小结

到这一步作者完成了对文档向量的计算，以及候选词向量的计算。

不难看出，第一还是词权重的问题。第二是文档向量只考虑了目标词性。第三是候选词一般是复合词，那么在计算复合词权重的时候是词权重 * 词向量求平均的方式。

那如果我们有一个更合适的分词器，训练一个自己的词权重文件，以及训练一个更适合自己的elmo模型，那是否可以讲整套技术上是更为完整的。

获取每个候选词与整段话的余弦距离。排序

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

def get_dist_cosine(emb1, emb2, sent_emb_method="elmo",elmo_layers_weight=[0.0,1.0,0.0]):
    sum = 0.0
    assert emb1.shape == emb2.shape
    if(sent_emb_method=="elmo"):

        for i in range(0, 3):
            a = emb1[i]
            b = emb2[i]
            sum += cos_sim(a, b) * elmo_layers_weight[i]
        return sum

计算每个候选词与整段话的余弦距离，但是这里默认每层的权重是[0.0,1.0,0.0]，那这就导致作者声称的词向量对齐（embeddings alignment，EA）技术并没有用到～

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

def get_all_dist(candidate_embeddings_list, text_obj, dist_list):
    '''
    :param candidate_embeddings_list:
    :param text_obj:
    :param dist_list:
    :return: dist_all
    '''

    dist_all={}
    for i, emb in enumerate(candidate_embeddings_list):
        phrase = text_obj.keyphrase_candidate[i][0]
        phrase = phrase.lower()
        phrase = wnl.lemmatize(phrase) # 词形还原
        if(phrase in dist_all):
            #store the No. and distance
            dist_all[phrase].append(dist_list[i])
        else:
            dist_all[phrase]=[]
            dist_all[phrase].append(dist_list[i])
    return dist_all

def get_final_dist(dist_all, method="average"):
    '''
    :param dist_all:
    :param method: "average"
    :return:
    '''

    final_dist={}

    if(method=="average"):

        for phrase, dist_list in dist_all.items():
            sum_dist = 0.0
            for dist in dist_list:
                sum_dist += dist
            if (phrase in stop_words):
                sum_dist = 0.0
            final_dist[phrase] = sum_dist/float(len(dist_list))
        return final_dist

产生的结果比如:{“技术”: [0.8432613915568461, 0.8243992563094531, 0.8120348604031394]}，那么又做了一次平均。

阶段总结

  1. 如果我们有一个更合适的分词器，训练一个自己的词权重文件，以及训练一个更适合自己的elmo模型，那是否可以讲整套技术上是更为完整的。
  2. 计算候选词和整段的余弦距离时，其本质是否可以理解成是候选词和只考虑的词性组成的能代表整段文本向量进行排序呢。
  3. 作者声称的词向量对齐（embeddings alignment，EA）技术默认没有用到。

到这里作者完成了SIFRank_zh算法，的确是受限于目前的成果，整体流程也是具备参考价值的。

突出的问题，到这里为止，并没有利用到位置信息特征，比如行首或者行尾可能更具备代表含义。那么作者在此基础上，提供了SIFRank+算法。

获取positional score。 （SIFRank+）

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

def get_position_score(keyphrase_candidate_list, position_bias):
    length = len(keyphrase_candidate_list)
    position_score ={}
    for i,kc in enumerate(keyphrase_candidate_list):
        np = kc[0]
        p = kc[1][0]
        np = np.lower()
        np = wnl.lemmatize(np)
        if np in position_score:

            position_score[np] += 0.0
        else:
            position_score[np] = 1/(float(i)+1+position_bias)
    score_list=[]
    for np,score in position_score.items():
        score_list.append(score)
    score_list = softmax(score_list)

    i=0
    for np, score in position_score.items():
        position_score[np] = score_list[i]
        i+=1
    return position_score


我原本以为作者会用到词在原文中的索引位置，结果是候选词之间的索引位置。emmmm，但反过来想这其实也不正是原文中的相对索引位置嘛。
作者这里用到了两个技术点让我觉得很nice，一个是wnl.lemmatize,其作用是词性还原的，对于英文来说有用。还有一个是softmax，是用于归一化的。都能看出作者的扎实底子。

总结与思考

从作者这地方可以看出，整套流程是提取复合词的候选词，然后使用elmo计算候选词和以只考虑的目标词性所组成的句向量进行余弦计算其排序。

可提升点

在不改变整体流程和技术的方式上

  1. 如果使用thunlp，那么就训练一个以thunlp为结果的dict.txt，但是也可以训练一个tf-idf，个人觉得使用后者来表示词权重是更合适。
  2. 不局限于现有的正则表达，可以在分词的基础上增添自己的理解，另外可以训练自己ner。
  3. elmo越深其代表的含义更复杂，比如第一层可能代表词向量，第二层到第三层可能代表语义，句法等。作者把第三层替换掉，但是并没有使用，以及第一层，那么是否可以给予不同权重，但是这又属于超参问题，另外效果怎么样也不敢保证。
  4. 位置信息。根据业务来，有的业务有title和content，那么title可给予更高的权重。

参考资料

ELMoForManyLangs
SIFRank_zh

展开全文 >>

信息提取中分块或表达式

介绍

什么是表达式，用一组规则来进行信息表示与提取。

这个名字起的有点绕，本质来讲他是做下面这个事情的。

假设分词结果如下所示：

1
2
3
4
5
6
7
8
[
    ('现在', 'time'),
    ('社区', 'n'),
    ('在', 'p'),
    ('进行', 'v'),
    ('网格化', 'n'),
    ('管理', 'n')
]

表达式

演变1

如果从这句话中进行关键词提取，分词粒度太低，那么我们首先会想着聚合。

1
2
[('社区', 'n'), ('网格化', 'n'), ('管理', 'n')]

网格化管理更能体现出比管理更具体的含义，那么你会接着使用2阶的n-gram，那么网格化管理会提取出来。

演变2

现在社区也是2阶n-gram，他们应该聚合吗？显然是不应该的，那么我们认识到：
n-gram是必须的，但是配置出来的规则不止n-gram。

那么我们尝试添加进去词性特征。

伪代码如下：

1
2
if before_token.pos == 'n' and cur_token.pos == 'n':
    print('那么就聚合')

演变3

假设到此我们都可以用一堆hardcode来解决了，如果我们允许自定义配置，那么上面的hardcode就要换一种方式来表达。

演变4

此方法自行实现。我们可以定义每个token的判断逻辑。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def token_match(token, element):
    # ！开头表示词性
    if element.startswith('!'):
        return token.pos == element[1:]
    # @表示词
    elif element.startswith('@'):
        return token.word == element[1:]
    raise # 自行实现其他的

# 每个表达式判断
for element in express:
    for index，token in enumerate(tokens):
        if token_match(token, element):
            # 最终构成一个DAG

演变5

到这里为止，我们认为实现了一个可自定义配置的表达式，但是问题来了，上面这个准确来讲是实现了硬匹配的，只能一个token一个token的来写表达式规则，比如我想实现[‘!n’, ‘!n’, ‘!n’, ‘!n’]这种,那就要写4遍这个。而不是!n+这种。

那么自行实现正则表达式会是更优的方式。

那先转换下思路，有没有现成的实现方式或者相关术语，可以拿来参考。

分块（chunk）

根据Nature Language Processing with Python第七章Extracting Information from Text中介绍到分块概念。

我们将用于实体检测的基本技术是分块，它分割和标记多令牌序列，如下图所示。

那么由此可见，我们可以看到用于分块的正则表达式和n-gram方法。

例子1

1
2
3
4
5
6
7
8
9
10
11
>>> sentence = [('the', 'DT'), ('little', 'JJ'), ('yellow', 'JJ'), ('dog', 'NN'), ('barked', 'VBD'), ('at', 'IN'), ('the', 'DT'), ('cat', 'NN')]
>>> grammar = "NP: {<DT>?<JJ>*<NN>}"
>>> cp = nltk.RegexpParser(grammar)
>>> result = cp.parse(sentence)

>>> result.pretty_print()
                            S                                       
     _______________________|______________________________          
    |        |              NP                             NP       
    |        |      ________|_________________        _____|____     
barked/VBD at/IN the/DT little/JJ yellow/JJ dog/NN the/DT     cat/NN

由这个例子可见，grammer中：

  1. NP为自定义的名字，nonterminal，表示为这个grammer应该对应的label是什么。这个可自行参考constituency tree parser。
  2. {}表示一套表达式的范围，rule。
  3. <>对应token的表示。
  4. ?, *, +就对应正常的正则。

更多例子可参考。

搜了些资料，貌似没有根据词特征来进行patten匹配的。
通过源码可看出的确是不支持词匹配的。

基于这个的应用，可看SIFRank_zh算法的应用。

结论

如果需要其他特征，可以先词性匹配，后续加规则来实现。
自己实现一个更高级的😂😂😂。

参考资料

Nature Language Processing with Python

展开全文 >>

torch使用tensorboard简明备忘录

tensorboard是让torch可以使用tensorflow的web可视化工具，之前叫tensorboardX。
至于其他的介绍以及为什么需要，可自行百度。

简单的完整代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# -*- coding: utf8 -*-
#

import math

from torch.utils.tensorboard import SummaryWriter

writer = SummaryWriter('./run')

epochs = 100
data_loader = range(1000)

total_loss = 0
for epoch in range(epochs):
    for i, data in enumerate(data_loader):
        loss = math.sin(i)
        total_loss += loss
        # 打印每一个batch下的总loss
        writer.add_scalar('train_loss', total_loss, epoch * len(data_loader) + i)
    total_loss = 0


终端跑下面这条命令：

1
tensorboard --logdir=./runs

更完整的demo

其中数据集加载没有添加进来，引用代码可参考lstm_sent_polarity。

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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
# Defined in Section 4.6.7

import torch
from torch import nn, optim
from torch.nn import functional as F
from torch.nn.utils.rnn import pad_sequence, pack_padded_sequence
from torch.utils import tensorboard
from torch.utils.data import Dataset, DataLoader
# tqdm是一个Python模块，能以进度条的方式显式迭代的进度
from tqdm.auto import tqdm

from utils import load_sentence_polarity

summary = tensorboard.SummaryWriter('./runs')

class LstmDataset(Dataset):
    def __init__(self, data):
        self.data = data

    def __len__(self):
        return len(self.data)

    def __getitem__(self, i):
        return self.data[i]


def collate_fn(examples):
    lengths = torch.tensor([len(ex[0]) for ex in examples])
    inputs = [torch.tensor(ex[0]) for ex in examples]
    targets = torch.tensor([ex[1] for ex in examples], dtype=torch.long)
    # 对batch内的样本进行padding，使其具有相同长度
    inputs = pad_sequence(inputs, batch_first=True)
    return inputs, lengths, targets


class LSTM(nn.Module):
    def __init__(self, vocab_size, embedding_dim, hidden_dim, num_class):
        super(LSTM, self).__init__()
        self.embeddings = nn.Embedding(vocab_size, embedding_dim)
        self.lstm = nn.LSTM(embedding_dim, hidden_dim, batch_first=True, bidirectional=True, num_layers=3)
        self.output = nn.Linear(hidden_dim * 6, num_class)

    def forward(self, inputs, lengths):
        embeddings = self.embeddings(inputs)
        x_pack = pack_padded_sequence(embeddings, lengths, batch_first=True, enforce_sorted=False)
        hidden, (hn, cn) = self.lstm(x_pack)
        outputs = self.output(hn.permute(1, 0, 2).reshape(-1, 6 * 256))
        log_probs = F.log_softmax(outputs, dim=-1)
        return log_probs


embedding_dim = 128
hidden_dim = 256
num_class = 2
batch_size = 32
num_epoch = 20

# 加载数据
train_data, test_data, vocab = load_sentence_polarity()
train_dataset = LstmDataset(train_data)
test_dataset = LstmDataset(test_data)
train_data_loader = DataLoader(train_dataset, batch_size=batch_size, collate_fn=collate_fn, shuffle=True)
test_data_loader = DataLoader(test_dataset, batch_size=1, collate_fn=collate_fn, shuffle=False)

# 加载模型
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = LSTM(len(vocab), embedding_dim, hidden_dim, num_class)
model.to(device)  # 将模型加载到GPU中（如果已经正确安装）

# 训练过程
nll_loss = nn.NLLLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)  # 使用Adam优化器
scheduler = optim.lr_scheduler.StepLR(optimizer, 15, gamma=0.99)

model.train()
for epoch in range(num_epoch):
    total_loss = 0
    for i, batch in tqdm(enumerate(train_data_loader), desc=f"Training Epoch {epoch}"):
        inputs, lengths, targets = [x.to(device) for x in batch]
        lengths = lengths.cpu()
        log_probs = model(inputs, lengths)
        loss = nll_loss(log_probs, targets)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        total_loss += loss.item()
        # 对每一个batch记录loss变化
        summary.add_scalar('train_batch_loss', total_loss, epoch * len(train_data_loader) + i)
    scheduler.step()
    print(f"Loss: {total_loss:.2f}, lr: {scheduler.get_last_lr()[0]}")
    # 对每一个epoch记录loss变化
    summary.add_scalar('train_epoch_loss', total_loss, epoch)
    # 对每一个epoch记录lr变化
    summary.add_scalar('train_epoch_lr', scheduler.get_last_lr()[0], epoch)

# 测试过程
acc = 0
for batch in tqdm(test_data_loader, desc=f"Testing"):
    inputs, lengths, targets = [x.to(device) for x in batch]
    lengths = lengths.cpu()

    with torch.no_grad():
        output = model(inputs, lengths)
        acc += (output.argmax(dim=1) == targets).sum().item()

# 输出在测试集上的准确率
print(f"Acc: {acc / len(test_data_loader):.2f}")

展开全文 >>

预训练思考与基于预训练模型的应用例子

介绍

本篇文章主要讲基于bert预训练模型的一些例子，希望可以从不同角度理解与应用基于bert的一些应用。

nlp发展了这么多年，经历了规则，统计，模型等阶段，目前预训练模型基本算是一统天下了。

大公司有更多资源，可以联合一些科研机构与组织搞一些事情，比如微软和nvidia利用更多的资源来探测模型的边界。
这个就很有意思，思考一个问题，什么叫意识？什么情况下产生了意识？

什么是意识，这个可以尝试用两个词来理解，计算和算计。计算很好理解，比如计算机，计算器，本质来讲是人输入指令，获得一个预期结果，不会产生任何歧义。而算计呢，它是一个综合体，它的输出是多样的，有可能不可预知的。它具有自己的思考。

那什么情况下产生了意识？这个问题就是这些大佬们所想要尝试认知的东西。比如人类有30亿碱基对，蚊子才几千万，单细胞生物可能更少可能就被认为不具备意识？如此看来的话，那我可以尝试扩充网络容量，更多的训练数据集，等到了某个程度下，突然机器就具备了某种智能。

这是个有意思的研究！

不过扯了这么多，小公司的话，更多是基于预训练模型的微调。

为什么要基于预训练模型微调呢，严格意义来讲就是预训练模型已经学习到了语义，一个认知大脑。基于此，给定一个具体任务，来对其进行微调，使其具备更快的收敛能力和更好的泛化能力。

所以掌握下还是很重要滴😂😂😂。

下面介绍四个应用示例，每一种大致介绍下，更具体的实现可以自行实现。

不过作者在这里使用了Trainer，这是transformers出的一套工具，可以让你更快的训练，但是封装太高，懒得折腾了，不如自己从头写😂😂😂。

命名实体任务

代码.

这个是个ner任务，不知道ner的自行百度，模型后面接了一个linear，如果想要更深入，可以看看crf。

不过这个任务如果用于分词，词性标注还是很nice的。

句子对相似度

代码.

这个任务还是蛮有意思的，之前也有类似的比赛。比如天池 疫情相似句对判定大赛 线上第一名方案。

整体实现思路基本一致，不过作者加入了对抗训练这些东西，感兴趣可以看看。

句子分类

代码.

这个就是多分类任务，也是比较常见的场景。

阅读理解

代码.

这个我没看😂😂😂。

总结

好吧，这本书快让我水了一波，感兴趣的需要基础的老铁们可以多翻翻。

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

探索世界美好的存在。