最近想做一个基金的标注工具，用echarts开发了前端部分，顺便看到fluid这个主题可以很方便的在博客中插入echarts图表，做一个记录。

教程参见: 使用 ECharts 插件绘制炫酷图表

第一步是安装插件

npm install hexo-tag-echarts --save

基础图表的例子

{% echarts 400 '85%' %}option = {  xAxis: {    type: 'category',    data: ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']  },  yAxis: {    type: 'value'  },  series: [    {      data: [150, 230, 224, 218, 135, 147, 260],      type: 'line'    }  ]};{% endecharts %}

标注工具代码

let base = +new Date(2010, 1, 1);let oneDay = 24 * 3600 * 1000;let date = [];let s = Math.random() * 300;let data = [[s, s, s, s]];for (let i = 1; i < 365*12; i++) {  var now = new Date((base += oneDay));  date.push([now.getFullYear(), now.getMonth() + 1, now.getDate()].join('/'));  var v = ((Math.random() - 0.5) * 0.05 + 1)*data[i - 1][1];  // 开盘价、收盘价、最低价、最高价  data.push([v*(1 + (Math.random() - 0.5)*0.01), v, v*0.995, v*1.005]);}option = {  toolbox: {    feature: {      dataZoom: {        yAxisIndex: false      },      brush: {        type: ['lineX', 'clear']      }    }  },  brush: {    xAxisIndex: 0,    throttleType: 'debounce',    throttleDelay: 600,    inBrush: {      symbolSize: 4,      color: '#FF3333'    },    outOfBrush: {      colorAlpha: 0.1    }  },  dataZoom: [    {      type: 'inside',      start: 0,      end: 100    },    {      start: 0,      end: 100    }  ],  xAxis: {    type: 'category',    data: date  },  yAxis: {    type: 'value'  },  series: [    {      data: data,      type: 'candlestick',      lineStyle: {        normal: {          width: 2,        }      }    }  ]};myChart.on('brushSelected', function (params) {  var brushed = [];  var target = params.batch[0]['selected'][0]['dataIndex'];  if(target.length>0){    console.log(target);    console.log(target.length);  }    });

这里需要注意的是：

如果直接把上述所有代码放入{% echarts 400 '85%' %} {% endecharts %}里是无法显示的。因为hexo-tag-echarts这个插件在生成js代码的时候是将里面的东西均作为配置来用模板套用。比如上面的那个简单的折线图，生成的结果如下：

<script type="text/javascript">        // 基于准备好的dom，初始化echarts实例        var myChart = echarts.init(document.getElementById('echarts8038'));        // 指定图表的配置项和数据        var option = option = {  xAxis: {    type: 'category',    data: ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']  },  yAxis: {    type: 'value'  },  series: [    {      data: [150, 230, 224, 218, 135, 147, 260],      type: 'line'    }  ]};        // 使用刚指定的配置项和数据显示图表。        myChart.setOption(option);</script>

正则表达式有[正反]向[肯否]定预查四种预查形式，结论是正向只能放置于末尾，反向只能放置于开头。

参考手册：https://tool.oschina.net/uploads/apidocs/jquery/regexp.html

只看以上手册，比较难搞清楚使用范围和使用姿势，以下对这四种预查分别做单元测试。

1. 正向肯定

测试用例

def setUp(self) -> None:  self.cases = [    '123',    'a123',    'abc123',    'ad123',    'ac123',    'ae123',    'abcac123',    'abcae123',    '123abc',    '123ad',    '123ac',    'abc'  ]def test_forward_positive(self):    """正向肯定预查，在任何匹配pattern的字符串开始处匹配查找字符串。"""    p1 = '(?=abc|ad)123'  # 不能处理正则的最开头    p2 = '123(?=abc|ad)'  # 只能处于末尾，必须匹配预查的字符，只是不捕获，    p3 = '(123)(abc|ad)'  # 取group1后等价于p2    p4 = 'a(?=bc|d)123'  # 不能处于正则的中间    for c in self.cases:      print(c)      print(p1, re.search(p1, c))      print(p2, re.search(p2, c))      print(p3, re.search(p3, c))      print(p4, re.search(p4, c))      print()

输出为如下，可以看到只有放于最后的才有效，放于最前面的p1捕获不了abc123，放置于中间的p4捕获不了abc123和ae123。而且正确放置在最后的p2，完全等价于p3（对p3的匹配取group1），无法捕获123，不实用，不如直接用p3。

123(?=abc|ad)123 None123(?=abc|ad) None(123)(abc|ad) Nonea(?=bc|d)123 Nonea123(?=abc|ad)123 None123(?=abc|ad) None(123)(abc|ad) Nonea(?=bc|d)123 Noneabc123(?=abc|ad)123 None123(?=abc|ad) None(123)(abc|ad) Nonea(?=bc|d)123 Nonead123(?=abc|ad)123 None123(?=abc|ad) None(123)(abc|ad) Nonea(?=bc|d)123 Noneac123(?=abc|ad)123 None123(?=abc|ad) None(123)(abc|ad) Nonea(?=bc|d)123 Noneae123(?=abc|ad)123 None123(?=abc|ad) None(123)(abc|ad) Nonea(?=bc|d)123 Noneabcac123(?=abc|ad)123 None123(?=abc|ad) None(123)(abc|ad) Nonea(?=bc|d)123 Noneabcae123(?=abc|ad)123 None123(?=abc|ad) None(123)(abc|ad) Nonea(?=bc|d)123 None123abc(?=abc|ad)123 None123(?=abc|ad) <re.Match object; span=(0, 3), match='123'>(123)(abc|ad) <re.Match object; span=(0, 6), match='123abc'>a(?=bc|d)123 None123ad(?=abc|ad)123 None123(?=abc|ad) <re.Match object; span=(0, 3), match='123'>(123)(abc|ad) <re.Match object; span=(0, 5), match='123ad'>a(?=bc|d)123 None123ac(?=abc|ad)123 None123(?=abc|ad) None(123)(abc|ad) Nonea(?=bc|d)123 Noneabc(?=abc|ad)123 None123(?=abc|ad) None(123)(abc|ad) Nonea(?=bc|d)123 None

2. 正向否定

def test_forward_negative(self):    """正向否定预查，在任何不匹配pattern的字符串开始处匹配查找字符串。"""    p1 = '(?!abc|ad)123'  # 放在最前面不起作用    p2 = '123(?!abc|ad)'  # 只能放置于最后，后面能为空    p3 = 'a(?!bc|d)123'  # 无效，只能匹配a123    p4 = 'a(?!b|d)123'  # 无效    for c in self.cases:        print(c)        print(p1, re.search(p1, c))        print(p2, re.search(p2, c))        print(p3, re.search(p3, c))        print(p4, re.search(p4, c))        print()

放在最前面的p1捕获了abc123不符合预期，放在中间的p3和p4写了等于没写，只有放在最后的p2正确匹配了，并且后面可以为空（匹配了123）。

123(?!abc|ad)123 <re.Match object; span=(0, 3), match='123'>123(?!abc|ad) <re.Match object; span=(0, 3), match='123'>a(?!bc|d)123 Nonea(?!b|d)123 Nonea123(?!abc|ad)123 <re.Match object; span=(1, 4), match='123'>123(?!abc|ad) <re.Match object; span=(1, 4), match='123'>a(?!bc|d)123 <re.Match object; span=(0, 4), match='a123'>a(?!b|d)123 <re.Match object; span=(0, 4), match='a123'>abc123(?!abc|ad)123 <re.Match object; span=(3, 6), match='123'>123(?!abc|ad) <re.Match object; span=(3, 6), match='123'>a(?!bc|d)123 Nonea(?!b|d)123 Nonead123(?!abc|ad)123 <re.Match object; span=(2, 5), match='123'>123(?!abc|ad) <re.Match object; span=(2, 5), match='123'>a(?!bc|d)123 Nonea(?!b|d)123 Noneac123(?!abc|ad)123 <re.Match object; span=(2, 5), match='123'>123(?!abc|ad) <re.Match object; span=(2, 5), match='123'>a(?!bc|d)123 Nonea(?!b|d)123 Noneae123(?!abc|ad)123 <re.Match object; span=(2, 5), match='123'>123(?!abc|ad) <re.Match object; span=(2, 5), match='123'>a(?!bc|d)123 Nonea(?!b|d)123 Noneabcac123(?!abc|ad)123 <re.Match object; span=(5, 8), match='123'>123(?!abc|ad) <re.Match object; span=(5, 8), match='123'>a(?!bc|d)123 Nonea(?!b|d)123 Noneabcae123(?!abc|ad)123 <re.Match object; span=(5, 8), match='123'>123(?!abc|ad) <re.Match object; span=(5, 8), match='123'>a(?!bc|d)123 Nonea(?!b|d)123 None123abc(?!abc|ad)123 <re.Match object; span=(0, 3), match='123'>123(?!abc|ad) Nonea(?!bc|d)123 Nonea(?!b|d)123 None123ad(?!abc|ad)123 <re.Match object; span=(0, 3), match='123'>123(?!abc|ad) Nonea(?!bc|d)123 Nonea(?!b|d)123 None123ac(?!abc|ad)123 <re.Match object; span=(0, 3), match='123'>123(?!abc|ad) <re.Match object; span=(0, 3), match='123'>a(?!bc|d)123 Nonea(?!b|d)123 Noneabc(?!abc|ad)123 None123(?!abc|ad) Nonea(?!bc|d)123 Nonea(?!b|d)123 None

3. 反向肯定

def test_backward_positive(self):    """反向肯定"""    # p1 = '(?<=abc|ad)123'  # 报错, re.error: look-behind requires fixed-width pattern    p1 = '((?<=abc)|(?<=ad|ac))123'  # 只能处于最前面，等价于(abc|ad|ac)123    p2 = '123((?<=abc)|(?<=ad))'  # 无效    p3 = 'a((?<=bc)|(?<=d))123'  # 错误用法    p4 = '123(?<=abc)'  # 无效    for c in self.cases:        print(c)        print(p1, re.search(p1, c))        print(p2, re.search(p2, c))        print(p3, re.search(p3, c))        print(p4, re.search(p4, c))        print()

反向的时候需要注意，如果预查多个，不能之前那样写(?<=abc|ad)，同一个预查里的长度必须是相等的。若想处理多个，得写过个预查((?<=abc)|(?<=ad|ac))。

此外，反向只能放置在最前面，放置在中间完全不符合预期，放在后面也未生效。但正确的写法p1也等价于(abc|ad|ac)123，用预查写起来还麻烦，不如直接group筛选。

123((?<=abc)|(?<=ad|ac))123 None123((?<=abc)|(?<=ad)) Nonea((?<=bc)|(?<=d))123 None123(?<=abc) Nonea123((?<=abc)|(?<=ad|ac))123 None123((?<=abc)|(?<=ad)) Nonea((?<=bc)|(?<=d))123 None123(?<=abc) Noneabc123((?<=abc)|(?<=ad|ac))123 <re.Match object; span=(3, 6), match='123'>123((?<=abc)|(?<=ad)) Nonea((?<=bc)|(?<=d))123 None123(?<=abc) Nonead123((?<=abc)|(?<=ad|ac))123 <re.Match object; span=(2, 5), match='123'>123((?<=abc)|(?<=ad)) Nonea((?<=bc)|(?<=d))123 None123(?<=abc) Noneac123((?<=abc)|(?<=ad|ac))123 <re.Match object; span=(2, 5), match='123'>123((?<=abc)|(?<=ad)) Nonea((?<=bc)|(?<=d))123 None123(?<=abc) Noneae123((?<=abc)|(?<=ad|ac))123 None123((?<=abc)|(?<=ad)) Nonea((?<=bc)|(?<=d))123 None123(?<=abc) Noneabcac123((?<=abc)|(?<=ad|ac))123 <re.Match object; span=(5, 8), match='123'>123((?<=abc)|(?<=ad)) Nonea((?<=bc)|(?<=d))123 None123(?<=abc) Noneabcae123((?<=abc)|(?<=ad|ac))123 None123((?<=abc)|(?<=ad)) Nonea((?<=bc)|(?<=d))123 None123(?<=abc) None123abc((?<=abc)|(?<=ad|ac))123 None123((?<=abc)|(?<=ad)) Nonea((?<=bc)|(?<=d))123 None123(?<=abc) None123ad((?<=abc)|(?<=ad|ac))123 None123((?<=abc)|(?<=ad)) Nonea((?<=bc)|(?<=d))123 None123(?<=abc) None123ac((?<=abc)|(?<=ad|ac))123 None123((?<=abc)|(?<=ad)) Nonea((?<=bc)|(?<=d))123 None123(?<=abc) Noneabc((?<=abc)|(?<=ad|ac))123 None123((?<=abc)|(?<=ad)) Nonea((?<=bc)|(?<=d))123 None123(?<=abc) None

4. 反向否定

def test_backward_negative(self):    """反向否定"""    p1 = '((?<!abc)|(?<!ad|ac))123'  # 错误写法，只要满足不等于其中一个即可    p2 = '123((?<!abc)|(?<!ad))'  #    p3 = 'a((?<!bc)|(?<!d))123'  # 错误写法，只能匹配a123    p4 = '123(?<!abc)'  # 无效    p5 = '(?<!abc)123'  #    p6 = '(?<!abc)(?<!ad|ac)123'  # 正确写法，必须满足全部不等于    for c in self.cases:        print(c)        print(p1, re.search(p1, c))        print(p2, re.search(p2, c))        print(p3, re.search(p3, c))        print(p4, re.search(p4, c))        print(p5, re.search(p5, c))        print(p6, re.search(p6, c))        print()

同上，只有放置在最前面的是正确的，这里需要注意的事p1和p6。p1只要不等于其一都可匹配，比如abc123不匹配ad|ac，这明显不符合预期。这个时候需要取并集，只需要拆开写过个就好，顺序无关，如见p6。

123((?<!abc)|(?<!ad|ac))123 <re.Match object; span=(0, 3), match='123'>123((?<!abc)|(?<!ad)) <re.Match object; span=(0, 3), match='123'>a((?<!bc)|(?<!d))123 None123(?<!abc) <re.Match object; span=(0, 3), match='123'>(?<!abc)123 <re.Match object; span=(0, 3), match='123'>(?<!abc)(?<!ad|ac)123 <re.Match object; span=(0, 3), match='123'>a123((?<!abc)|(?<!ad|ac))123 <re.Match object; span=(1, 4), match='123'>123((?<!abc)|(?<!ad)) <re.Match object; span=(1, 4), match='123'>a((?<!bc)|(?<!d))123 <re.Match object; span=(0, 4), match='a123'>123(?<!abc) <re.Match object; span=(1, 4), match='123'>(?<!abc)123 <re.Match object; span=(1, 4), match='123'>(?<!abc)(?<!ad|ac)123 <re.Match object; span=(1, 4), match='123'>abc123((?<!abc)|(?<!ad|ac))123 <re.Match object; span=(3, 6), match='123'>123((?<!abc)|(?<!ad)) <re.Match object; span=(3, 6), match='123'>a((?<!bc)|(?<!d))123 None123(?<!abc) <re.Match object; span=(3, 6), match='123'>(?<!abc)123 None(?<!abc)(?<!ad|ac)123 Nonead123((?<!abc)|(?<!ad|ac))123 <re.Match object; span=(2, 5), match='123'>123((?<!abc)|(?<!ad)) <re.Match object; span=(2, 5), match='123'>a((?<!bc)|(?<!d))123 None123(?<!abc) <re.Match object; span=(2, 5), match='123'>(?<!abc)123 <re.Match object; span=(2, 5), match='123'>(?<!abc)(?<!ad|ac)123 Noneac123((?<!abc)|(?<!ad|ac))123 <re.Match object; span=(2, 5), match='123'>123((?<!abc)|(?<!ad)) <re.Match object; span=(2, 5), match='123'>a((?<!bc)|(?<!d))123 None123(?<!abc) <re.Match object; span=(2, 5), match='123'>(?<!abc)123 <re.Match object; span=(2, 5), match='123'>(?<!abc)(?<!ad|ac)123 Noneae123((?<!abc)|(?<!ad|ac))123 <re.Match object; span=(2, 5), match='123'>123((?<!abc)|(?<!ad)) <re.Match object; span=(2, 5), match='123'>a((?<!bc)|(?<!d))123 None123(?<!abc) <re.Match object; span=(2, 5), match='123'>(?<!abc)123 <re.Match object; span=(2, 5), match='123'>(?<!abc)(?<!ad|ac)123 <re.Match object; span=(2, 5), match='123'>abcac123((?<!abc)|(?<!ad|ac))123 <re.Match object; span=(5, 8), match='123'>123((?<!abc)|(?<!ad)) <re.Match object; span=(5, 8), match='123'>a((?<!bc)|(?<!d))123 None123(?<!abc) <re.Match object; span=(5, 8), match='123'>(?<!abc)123 <re.Match object; span=(5, 8), match='123'>(?<!abc)(?<!ad|ac)123 Noneabcae123((?<!abc)|(?<!ad|ac))123 <re.Match object; span=(5, 8), match='123'>123((?<!abc)|(?<!ad)) <re.Match object; span=(5, 8), match='123'>a((?<!bc)|(?<!d))123 None123(?<!abc) <re.Match object; span=(5, 8), match='123'>(?<!abc)123 <re.Match object; span=(5, 8), match='123'>(?<!abc)(?<!ad|ac)123 <re.Match object; span=(5, 8), match='123'>123abc((?<!abc)|(?<!ad|ac))123 <re.Match object; span=(0, 3), match='123'>123((?<!abc)|(?<!ad)) <re.Match object; span=(0, 3), match='123'>a((?<!bc)|(?<!d))123 None123(?<!abc) <re.Match object; span=(0, 3), match='123'>(?<!abc)123 <re.Match object; span=(0, 3), match='123'>(?<!abc)(?<!ad|ac)123 <re.Match object; span=(0, 3), match='123'>123ad((?<!abc)|(?<!ad|ac))123 <re.Match object; span=(0, 3), match='123'>123((?<!abc)|(?<!ad)) <re.Match object; span=(0, 3), match='123'>a((?<!bc)|(?<!d))123 None123(?<!abc) <re.Match object; span=(0, 3), match='123'>(?<!abc)123 <re.Match object; span=(0, 3), match='123'>(?<!abc)(?<!ad|ac)123 <re.Match object; span=(0, 3), match='123'>123ac((?<!abc)|(?<!ad|ac))123 <re.Match object; span=(0, 3), match='123'>123((?<!abc)|(?<!ad)) <re.Match object; span=(0, 3), match='123'>a((?<!bc)|(?<!d))123 None123(?<!abc) <re.Match object; span=(0, 3), match='123'>(?<!abc)123 <re.Match object; span=(0, 3), match='123'>(?<!abc)(?<!ad|ac)123 <re.Match object; span=(0, 3), match='123'>abc((?<!abc)|(?<!ad|ac))123 None123((?<!abc)|(?<!ad)) Nonea((?<!bc)|(?<!d))123 None123(?<!abc) None(?<!abc)123 None(?<!abc)(?<!ad|ac)123 None

记录spark使用过程中的一些常用点，不定期更新~

pyspark环境打包

先本地构建虚拟环境，打包后提交到集群，已conda为例

conda create -n py37 python=3.7 pipsource activate py37pip install -r requirements.txt# install conda packpip install conda-pack# Pack environment my_env into out_name.tar.gzconda pack -n py37 -o py37_env.tar.gz

打包完成后，可重现环境检查下

mkdir -p test_envtar -xzf py37_env.tar.gz -C test_envsource py37_env/bin/activate# 查看安装包是否一致pip list

这里插一个，如果想看conda环境安装的包，路径为~conda_path/envs/py37/lib/python3.7/site-packages

采用spark-submit

/opt/tiger/spark_deploy/spark-stable/bin/spark-submit \    --master yarn \    --deploy-mode cluster \    --queue ${queue_name} \    --conf spark.driver.memory=4g \    --conf spark.dynamicAllocation.enabled=true \    --conf spark.dynamicAllocation.minExecutors=10 \    --conf spark.dynamicAllocation.initialExecutors=10 \    --conf spark.dynamicAllocation.maxExecutors=20 \    --conf spark.executor.memory=4g \    --conf spark.executor.cores=4 \    --name spark_test_env \    --conf spark.hadoop.yarn.cluster.name=${cluster_name} \    --conf spark.pyspark.python=./py37_env/bin/python3 \    --conf spark.pyspark.driver.python=./py37_env/bin/python3 \    --archives hdfs_path/py37_env.tar.gz#py37_env    main.py

参考

• spark-submit提交任务到集群，分发虚拟环境和第三方包

• pyspark打包依赖包&使用python虚拟环境

工程打包

pyspark主程序依赖的文件比较少的时候，可以通过--py-files逐个添加，但当依赖的比较多，甚至是整个工程，有比较复杂的目录结构的时候，就需要打包了，打包成.zip,.egg等格式也可通过--py-files传入，这些文件会加入PYTHONPATH中。

这里需要注意的是，打成zip包的时候，必须是一级目录，这里给出一种正确的打包方式

cd project_homezip -r ../project_home.zip .

常用参数

Spark Conf

{  "spark.dynamicAllocation.minExecutors": "200",  "spark.dynamicAllocation.initialExecutors": "200",  "spark.dynamicAllocation.maxExecutors": "500",  "spark.driver.memory": "2g",  "spark.executor.memory": "4g",  "spark.driver.cores": "4",  "spark.yarn.executor.memoryOverhead": "4g",  "spark.sql.adaptive.enabled": "true",  "spark.sql.adaptive.skewedJoin.enabled": "true",  "spark.sql.adaptive.skewedJoinWithAgg.enabled": "true",  "spark.sql.adaptive.multipleSkewedJoin.enabled": "true"}

其中倒数三个参数是Spark AE SkewedJoin优化的一般参数，应对数据偏斜（处理偏斜优先分析key的取值是否均匀，比如空值等异常值需要被提前先移除掉）。

依赖资源

资源大多通过以下几种方式引入

• files: 逗号分隔的文件，这些文件放在每个executor的工作目录下面
• py-files: 逗号分隔的”.zip”,”.egg”或者”.py”文件，这些文件放在python app的PYTHONPATH下面
• jars: 逗号分隔的本地jar包，包含在driver和executor的classpath下
• archives: 指定压缩文件地址，压缩文件被分发到 executor 上，并且解压，解压路径可通过#指定

对于以上几个的区别主要是是否会被加入classpath和pythonpath，一般来说数据文件通过--files和--archives来添加，代码文件通过--py-files来添加，后者能被直接import。

详情参见What’s the difference between —archives, —files, py-files in pyspark job arguments

跑模型

通过spark跑深度学习模型时（当然是cpu啦），要想充分利用高并发并且减少模型加载时间的影响，可以使用mapPartitions。

先看官方给的例子

>>> rdd = sc.parallelize([1, 2, 3, 4], 2)>>> def f(iterator): yield sum(iterator)>>> rdd.mapPartitions(f).collect()[3, 7]

传入和穿出都是迭代器，一条一条的计算。但是如果我们想一个batch一个batch的预测，显然有三个做法

• 还是迭代器一条一条，攒一批过模型，再把结果迭代器传出
• 利用处理流数据的dataset，如pytorch的IterableDataset
• 直接把一个partition全部转成list来处理，需要注意是否会爆内存

分别给出前两种写法的例子

方式一：攒数据

def infer_batch_by_partition(partition):    batch_size = 16    count = 0    row = partition    data_batch = []    while True:        try:            content = next(row)            if count < batch_size:                count += 1                data_batch.append(content)            if count >= batch_size:                count = 0                # 过模型                predicts = model_predict(data_batch)                for p in predicts:                    yield p                data_batch = []        except StopIteration:            # 最后一个batch，数据量不一定是batch_size            if data_batch:                predicts = model_predict(data_batch)                for p in predicts:                    yield p                    rdd_pair_pred = rdd_pair.repartition(2000).mapPartitions(infer_batch_by_partition)

方式二：IterableDataset

Iterabledataset 的一个例子

class MyIterableDataset(torch.utils.data.IterableDataset):...     def __init__(self, your_args):...         super(MyIterableDataset).__init__()...         # this depends on your dataset, suppose your dataset contains ...         # images whose path you save in this list...         self.dataset = # something for load the path of images ......     def __iter__(self):...         for image_path in self.dataset:...             sample, label = read_single_example(image_path) # read an individual sample and its label...             yield sample, label

def seq_padding(seq, max_len, value=0):    x = [value] * max_len    x[:len(seq)] = seq[:max_len]    return xclass DedupePairDatasetV2Iter(IterableDataset):    def __init__(self, text_data_iter, tokenizer, max_len=128, max_sen=16, mode='test'):        super(DedupePairDatasetV2Iter, self).__init__()        self.max_len = max_len        self.max_sen = max_sen        self.tokenizer = tokenizer        self.text_data_iter = text_data_iter    def gen_doc_input(self, doc):        sentences = doc['summary']        sentences = sentences[:self.max_sen]        # 构造每个句子的bert输入        input_ids_list, token_type_ids_list, attention_mask_list = [], [], []        for sen in sentences:            token_type_ids = [0] * self.max_len            input_ids, attention_mask = [], []            for ch in sen[:self.max_len - 2]:                token_idx = self.tokenizer.encode(ch)                if len(token_idx) != 3:                    # 空格等，转为[UNK]                    input_ids.append(100)                else:                    input_ids.append(token_idx[1])                attention_mask.append(1)            input_ids = [101] + input_ids + [102]            attention_mask = [1] + attention_mask + [1]            input_ids_list.append(seq_padding(input_ids, self.max_len))            token_type_ids_list.append(seq_padding(token_type_ids, self.max_len))            attention_mask_list.append(seq_padding(attention_mask, self.max_len))        # pad doc sentence        for i in range(len(input_ids_list), self.max_sen):            input_ids_list.append([101] + [0] * (self.max_len - 2) + [102])            token_type_ids_list.append([0] * self.max_len)            attention_mask_list.append([1] * self.max_len)        # 增加句子长度，每一个字段分开batch        n_sen = min(len(sentences), self.max_sen)        sen_mask = [1] * n_sen + [0] * (self.max_sen - n_sen)        inputs = {            'input_ids': torch.tensor(input_ids_list, dtype=torch.long),            'token_type_ids': torch.tensor(token_type_ids_list, dtype=torch.long),            'attention_mask': torch.tensor(attention_mask_list, dtype=torch.long),            'sen_mask': torch.tensor(sen_mask, dtype=torch.long)        }        return inputs    def __iter__(self):        for item in self.text_data_iter:            left = self.gen_doc_input(item['left'])            right = self.gen_doc_input(item['right'])            yield left, right, json.dumps(item, ensure_ascii=False)def infer_duplicate_pair_iter(model,                               tokenizer,                               pair_list,                               batch_size=16,                               max_sen=16,                               max_seq_len=128,                              sent_hidden_size=64):    device = torch.device('cpu')    # test_set = DedupePairDatasetV2(pair_list, tokenizer, mode='test', max_sen=max_sen, max_len=max_seq_len)    test_set = DedupePairDatasetV2Iter(pair_list, tokenizer, mode='test', max_sen=max_sen, max_len=max_seq_len)    test_params = {'batch_size': batch_size,                   'shuffle': False,                   'num_workers': 0,                   }    testing_loader = DataLoader(test_set, **test_params)    model.eval()    with torch.no_grad():        for _, inputs in enumerate(testing_loader, 0):            left, right, items = inputs            for k in left:                left[k] = left[k].to(device, dtype=torch.long)            for k in right:                right[k] = right[k].to(device, dtype=torch.long)            logits = model(left, right)            logits = logits.cpu().detach().numpy()            score = softmax(logits, axis=1).tolist()            for pair, pred in zip(items, score):                pair = json.loads(pair)                pair['left'].pop('summary', '')                pair['right'].pop('summary', '')                pair['score'] = pred[1]                yield json.dumps(pair, ensure_ascii=False)def infer_batch_by_partition(partition):    return infer_duplicate_pair_iter(model_path, tokenizer, partition, batch_size=8)rdd_pair_pred = rdd_pair.repartition(2000).mapPartitions(infer_batch_by_partition)

参考：

• Spark原理 | 关于 mapPartitions 的误区

基本操作

读取json

from pyspark.sql import SparkSessionspark = SparkSession.builder.config("spark.sql.warehouse.dir", "file:///C:/temp").appName("readJSON").getOrCreate()readJSONDF = spark.read.json('Simple.json')readJSONDF.show(truncate=False)

参考：用pyspark读取json数据的方法汇总

读取csv

df = spark.read.csv(hdfs_path, header=True, inferSchema="true")df = df.select('doc_id', 'title')df = df.withColumnRenamed('title', 'doc_title')df = df.withColumn('doc_id', df['doc_id'].cast(StringType()))

写入hive分区

# 指定分区进行重写，而不会重写整张表df.createOrReplaceTempView('tmp_push')query = 'INSERT OVERWRITE TABLE aaa.bbb PARTITION(date="${date}") SELECT * FROM tmp_push'spark.sql(query)

多个rdd的联合

rdd_list.append(rdd1)rdd_list.append(rdd2)rdd_union = sc.union(rdd_list)

join

能用dataframe尽量用dataframe，有性能优化

left_anti只有dataframe有接口

df_a_not_in_b = df_a.join(df_b, on=['key'], how='left_anti')

udf

def make_pair_key(id1, id2):  id1, id2 = str(id1), str(id2)  if id1 > id2:    id1, id2 = id2, id1  return id1 + '-' + id2udf_make_pair_key = F.udf(make_pair_key, StringType())df = df.withColumn('key', udf_make_pair_key(df_hist.id1, df_hist.id2))

骚操作

运行过程中安装依赖包

有一些包的安装比较麻烦，比如spacy的模型zh_core_web_md，正常的安装方式为

pip install -U pip setuptools wheelpip install -U spacypython -m spacy download zh_core_web_md

最后一步我们没有办法写到requirements中，一个骚操作是把模型文件上传，然后在代码中解压，亲测有效

def load_spacy_model(env='local'):    import zipfile    def unzip_model(zip_file, out_path='.'):        zFile = zipfile.ZipFile(zip_file, "r")        for fileM in zFile.namelist():            zFile.extract(fileM, out_path)        zFile.close()     zip_file = 'zh_core_web_md-3.0.0.zip'  out_path = '.'    unzip_model(zip_file, out_path)    NLP = spacy.load(out_path + '/zh_core_web_md-3.0.0')

但其实并不需要这么麻烦，更好的做法是直接加载模型

from pyspark.sql import SparkSessionimport osimport sysimport zipfilespark = SparkSession.builder.enableHiveSupport().getOrCreate()def test_load_model():    sys.path.insert(0, 'zh_core_web_md-3.0.0.zip')  # 通过py-files引入，作为一个路径    files = os.listdir('./')    print('x'*60, sys.stderr)    print('\n'.join(files), sys.stderr)    import spacy    nlp = spacy.load('zh_core_web_md-3.0.0.zip/zh_core_web_md-3.0.0')    text = '风寒三友即岁寒三友，指松、竹、梅三种植物。'    doc = nlp(text)    for token in doc:        # info = [token.text, token.lemma_, token.pos_, token.tag_, token.dep_,        #             token.shape_, token.is_alpha, token.is_stop]        print(token.text, file=sys.stdout)

zh_core_web_md-3.0.0的文件内容为：

accuracy.jsonattribute_rulerconfig.cfgmeta.jsonnerparsersentertaggertok2vectokenizervocab

使用pycharm远程连接repo并远程运行。

配置

1. 本地新建repo（可以先clone远程repo），并用Pycharm（pycharm-professional-2019.3.2）打开
2. 选择pycharm中，Tools > Deployment > Configuration，点击左上角的+，添加配置
3. 配置信息说明
   1. Connection
      1. Type: SFTP
      2. Host: 远程ip地址
      3. User name: 远程机器用户名
      4. Password: 远程机器密码
      5. Root path: 远程根目录，需要自己选择（更新：最好选择根目录，防止后面mapping出问题）
   2. Mappings
      1. Local path: 本地repo地址
      2. Deployment path: 远程repo地址
      3. Web path: 暂时不用设置，貌似 Web 相关的程序会用到
   3. Excluded Paths: 可以设置一些不想同步的目录，例如软件的配置文件目录等，可忽略
4. 以上弄完，点击确认，接着配置解释器
   1. 打开Pycharm > Preferences > Project > Project Interpreter
   2. 点击project Interpreter右边的齿轮，点击Add
   3. 选择SSH Interpreter，由于之前（第3步）配置过远程连接，直接选择Existing server configuration即可
   4. 3点击后，下方会出现一个Create，点击后，点击Next
   5. 在最上面的Interpreter中选择远程的python解释器，注意是绝对路径
   6. 在下面的Sync floder中选择要同步的远程repo即可

使用

上传文件

新版默认是及时同步，手动同步选择Tools > Deployment > Upload to

运行程序

直接右键运行即可，与本地运行没有使用上差异，实际上从控制台可以看出，是ssh远程执行

ssh://user@rempte_ip:22/home/user/anaconda3/envs/nlp3/bin/python3 -u /home/user/test_repo_path/test.py

虽然ssh能解决大部分问题，但是有时也需要远程桌面。为此，可能大家都采用teamviewer和anydesk来完成。

但是不久前teamviewer出了问题，anydesk在使用过程中经常出现连接中断、连接慢等毛病。尝试发现通过vnc在局域网环境下连接异常稳定，基本不掉，键盘映射也比anydesk好，做个记录。

ubuntu配置

安装x11vnc

sudo apt-get install x11vnc

设置vnc密码

x11vnc -storepasswd

回车，在提示下输入和确认密码。保存在默认位置$HOME/.vnc/passwd

启动vnc服务

x11vnc -forever -shared -rfbauth ~/.vnc/passwd

当然也可以放在后台运行

将上诉命名放在sh脚本中

nohup sh ./start.sh &

可以在nohup.out中最后几行查看其vnc运行的端口号：PORT=5900

mac连接

mac自带一个vnc客户端：

/System/Library/CoreServices/Applications/Screen Sharing.app

打开后，输入ubuntu的局域网ip即可（试过貌似不需要端口号），然后输入之前设置的密码就可以了。

可能会发现页面缩放的问题，点击Screen Sharing左上角的scaling即可。

MathGraph: A Knowledge Graph for Automatically Solving Mathematical Exercises

一个用于解决高中数学练习题的知识图谱。

MathGraph提出了一种有效的算法，将数学问题与MathGraph对齐，并使用对齐的子图来解决数学练习。

Overview

MathGraph, a knowledge graph aiming to solve high school mathematical exercises.

一个用于解决高中数学练习题的知识图谱。

数学知识图谱与其他领域的知识图谱不一样，需要被特别的设计，原因有如下几点：

1. 数学知识图谱中的知识属于非常特定的领域：需要数学知识，一般基于广泛语义（维基百科等）构建的知识图谱很难获取数学问题中的语义信息。
2. 数学知识图谱中存储的知识应该定义在class-level上，而不是instance-level：一般知识图集中于提取实例，类别以及实例之间的关系。例如，一个三元组（北京，isCaptialOf，中国）显示了两个实例之间的关系。但是，在MathGraph中，原始图中没有实例，只有许多类级别的数学对象（例如，复数，椭圆等）。仅当遇到具体的练习时，才会相应地创建实例。
3. 数学知识图谱应该支持数学推导和计算：数学问题的推理过程不同于其他问题，因为除了逻辑关系外，知识图中还必须包含数学推导来解决数学练习。

对于前两条毋庸置疑，对于第三条，MathGraph是提供了几个推理算法，具体的实操性有待商榷。但是我们在构建数学知识图谱的时候，也应该有这样的念头，我的图谱怎样支持推理？仅仅提供知识点之间的前后依赖关系？大小概念关系？仅仅只提供信息查询我觉得是不够的，支持推理是知识图谱的灵魂。

MathGraph提出了一种有效的算法，将数学问题与MathGraph对齐，并使用对齐的子图来解决数学练习。

这个过程就很符合STC-AOG的理念，构建的MathGraph是完备的AOG，具体的习题过来生成的实例就是一个具体的PG，在PG上做推理，比如代数问题中让所有约束条件得以解决，就解了这个题。

MathGraph

要理解这部分，需要保持面向对象的思想，注意这里的笔记并不完全符合原文，根据我自己的理解做了取舍和修改，感兴趣的可以阅读原文。

定义

数学对象和实例

一个数学概念是一个抽象对象，它有具体的定义、一些属性，可以用作某些运算或派生的目标。

注意，可以根据其他对象来定义数学对象（也就是可以嵌套，比如分数的分子和分母都是有理数）。满足数学对象定义的具体对象称为实例。

不同的数学对象应该有不同的结构，在MathGraph中，数学对象用关键属性（key properties） (p1, p2, · · · , pn)的元组来表示。数学对象的关键属性是可以一起形成和描述该对象实例的所有信息的那些属性。这里列举了几个数学对象：

以复数来说

• 定义：A complex number is a number that can be in the form $a + bi$, where $a$ and $b$ are both real numbers and $i$ is the imaginary unit which satisfies $i^2 = −1$.
• 属性： 复数$a + bi$ 的属性有三个，实部$a$，虚部$b$和$i$。
• 运算：例如，$(a_1 + b_1i) · (a_2 + b_2i) = (a_1a_2 − b_1b_2) + (a_1b_2 + a_2b_1)i$
• 推导：例如，如果$a_1 + b_1 i$和$a_2 + b_2 i$是共轭关系，那么$a_1 = a_2, b_1+b_2=0$

Operation(运算)

通常，运算是一种操作或过程。在给定一个或多个数学对象作为输入（称为操作数）的情况下，该操作或过程产生一个新的对象。简单的例子包括加，减，乘，除和求幂。

Constraint(限制条件)

约束是对一个或多个实例的描述或条件，其中至少一个是不确定的实例。具体有4中限制：

1. 描述限制：比如，复数$x$和$y$共轭
2. 相等限制：$a+2=b$
3. 不等限制：$a^2<5$
4. 集合限制：$a \in N$

对于确定与不确定实例，根据实例是否包含某些不确定值作为其关键属性，可以将实例分为某些实例和不确定实例。如果所有关键属性都是确定的，那么实例就是确定的实例。否则情况不确定。

For example, a real number 2.3 and a function f(x) = x+sin(x) are certain; a complex number 3+ai (where a ∈ R) and a random triangle △ABC are uncertain.

MathGraph结构

MathGraph是一个有向图$G = ⟨V, E⟩ $, 其中$v \in V$是一个数学对象、操作或者限制。边为它们之间的关系。

MathGraph is a directed graph $G = ⟨V, E⟩$, in which each node $v ∈ V $denotes a mathematical object, an operation or a constraint, and each edge $e ∈ E$ is the relation of two nodes.

Nodes

有三种nodes: object nodes, operation nodes and constraint nodes.

Object Nodes An object node $v_o = (t,P,C)$ represents a mathematical object, 其中

• $t$: an instance template of this mathematical object, 实例模板，也就是schema
• $P = (P_1, P_2, \cdots , P_n) $：关键属性（key properties）
• $C$：a set of constraints。根据该定义或某些定理，该数学对象必须满足的一组约束。

Operation Nodes An operation node $v_p = (X_1, X_2, · · · , X_k, Y, f)$ represents a k-ary operation ,其中

• $X_i(i = 1, 2, · · · , k)$ and $Y$ are object nodes representing the domain of the ith operand xi and the result of the operation y respectively,
• $f$：is a function that implements the operation and can be finished by a series of symbolic execution process using a symbolic execution library (e.g. SymPy[10], Mathematica[7]) even if some operands are uncertain instances.

比如获得复数的模就一个Operation，$X_1 = ⟨Complex Number⟩$, $Y = ⟨Real Number⟩$, and $f 4can be implemented by the following symbolic execution process: (1) Get the real part of x1; (2) Get the imaginary part of x1; (3) Return the squared root of the sum of (1) squared and (2) squared.

Constraint Nodes A constraint node $v_c = (d, X_1, X_2, · · · , X_k, f)$ represents a descriptive constraints of k instances, 其中，

• $d$：描述
• $X_i(i = 1, 2, · · · , k)$，涉及的Object
• $f$ : a function which maps this descriptive constraint into several equality constraints, inequality constraints and set constraints.

例如，a constraint node represents that $x_1$ and $x_2$ are a conjugate pair, where $X1 = X2 = ⟨Complex Number⟩$, and f can be implemented by the following process: (1) Get the real part of x1 as a1; (2) Get the real part of x2 as a2; (3) Get the imaginary part of x1 as b1; (4) Get the imaginary part of x2 as b2; (5) Return two equality constraints: a1 = a2 and b1 + b2 = 0.

我觉得Object节点是必须的，但是Operation节点和Constraint节点，在当前我们构建的数学知识图谱中并必须要。

但是，相应的，我们可以有正对性的设计成Object节点这个class的子对象字段。

Edges

有两种边，the derive edges and the flow edges.

The derive edges $E_{derive} = (X,Y,f) $是一种general-special关系，比如从三角形到等腰三角形。 其中f为定义在其两端的限制条件，满足条件才返回true，也就是可以将general节点替换成special节点。

在解决练习时，将实例重新分配给更特定的对象节点将带来对该对象的更多约束，并有助于找到答案。

The flow edge 练习求解过程中实例的流向，这些实例只能从对象节点到操作节点，从操作节点到对象节点或从对象节点到约束节点存在。

我觉得derive edges是必须的，flow edge反而在目前不需要。derive edges的定义加上节点的定义，让我感觉这很像一个概率图模型，边上定义有function，表示节点之间的转移关系。

解题

解题第一步，将文本的题目parse到MathGraph上。

First, we use a semantic parser mapping exercise text to the instances, operations and constraints respectively. Then, we solve the constraints and update uncertain instances. Finally, we return the answer of this exercise.

parse得到的图其实就是一个pg

这块我们完全可以替换成我们自己的STC-AOG算法，这篇文章提出的解法也并不是很通用，实操性也待商榷，不是我关注的重点，就不做介绍。

实验结果

We collect four real-world datasets of mathematical exercises of Chinese high schools, namely Complex, Triangle, Conic and Solid. The exercises are stored in plain text, and the mathematical expressions are stored in the LaTeX format.

思考

我们的数学知识图谱该怎样建，这篇文章又能给我们什么样的启发。总结下来有如下几点

• 数学知识图谱由于其学科的特殊性、逻辑的严密性、知识点的多样性，采用常规的信息查询方式构建图谱的话，如果不细心处理，估计也就只能查信息了，无法进行推理。
• 推理是知识图谱的灵魂
• 节点的属性可以打开思路，其属性不仅仅只能是干巴巴的文本描述，我们可以放入更多的东西，比如数学性质、定义中的约束，甚至是运算方式。这有点类似复写对象中的比较器、toString等方法。
• 图谱的边也可以打开思路。目前的边只是一个字符串，但是也可以在边上定义属性，甚至是约束条件。比如，一般三角形—->等腰三角形的边上可以有约束条件，比如，两边相等/两角相等。用一个array of string就可以。

巧妇难为无米之炊，NLP任务也需好的数据来作为支撑。这里就有两个方面：

1. 完全没有数据
2. 有大量未标注脏数据，标注极少甚至没有

这个问题我打算用几篇博客一一讨论，本篇针对完全没数据的场景，介绍使用chatito来生成数据。

Chatito简介

Chatito使用简单易上手的DSL语法来为几类场景的NLP任务生成数据。原话是

Generate datasets for AI chatbots, NLP tasks, named entity recognition or text classification models using a simple DSL!

亲测确实方便生成一定量的数据，但是生成的训练集和测试集都是一个模板（构成规则）出来的，训练测试数据同源同构，很容易造成严重的过拟合。典型的表现是在测试集上的准确率和F1等指标会接近1，在未知数据上的泛化性会不好。

显然，采用这种方式生成数据并不是最好的方式。但在实在没有数据的情况下，怎样去解决同源的问题呢？想到的解决方式有几点：

1. 生成的过程中，只填入几条典型的场景，同类型的采用词典，并后续任务上构造词典特征
2. 生成后采用一些数据增强方式（同义词替换、位置交换等），增加训练数据的多样性。

本文不具体介绍这两种方式，会另外用实际的例子和博客分别进行记录，包括本文的例子都放在repo: DataGeneratorForNLP

使用前准备

安装node.js

首先需安装node.js >= v8.11

1. 官网下载编译好的包
2. 解压
3. 设置软连接

ln -s /usr/software/nodejs/bin/npm   /usr/local/bin/ ln -s /usr/software/nodejs/bin/node   /usr/local/bin/

在mac上直接采用homebrew安装即可

brew install nodebrew install npm

npm配置

npm config set registry https://registry.npm.taobao.org --globalnpm config set disturl https://npm.taobao.org/dist --global# 更新npm install -g npm

安装chatito npm package

npm i chatito --save

编写构成脚本

因为一个脚本只能生成一个类型的，比如在分类问题中要生成多个类的数据，最好一个类一个生成文件。所以，最好新建一个文件夹，存放所有脚本，比如chatito

下面以对话中介绍新朋友这样一个场景为例，介绍脚本的写法，完整的语法参见DSL。

新建一个以.chatito结尾文件，命名为intro_new_user.chatito，内容为：

import ./common.chatito%[intro_new_user]('training': '100', 'testing': '50')    *[60%] ~[hi?]，~[pre1?]~[pre2]~[pre3]，~[indicate?]@[username]    *[20%] ~[hi?]，~[indicate]@[username]    *[20%] ~[indicate]@[username]~[pre1]    给你~[pre2]    介绍    认识    了解~[pre3]    一个新朋友    一位新朋友    个新朋友    位新朋友    一个朋友    一位朋友    个朋友    位朋友    一下    下~[indicate]    这是    他是    她是    他叫    她叫    我是    我叫@[username]    小红    小花    大黄    小明

其中common.chatito为另外一个提供通用组成部分的脚本，内容为

~[hi]    你好    嗨    嘿    哈喽    hi    hello~[please]    请~[thanks]    谢谢    谢了    thx    谢谢你

比如hi，import后就可以采用~[hi]直接引用了。

因为chatito初衷是给对话生成数据，所以脚本里的概念有三个：意图（%[intent_name]）、槽值（@[slot_name]）和别称（~[alias_name]）。意图可以视为分类问题的类别，槽值可视为NER问题的实体，别称只是为了方便组合，随机选取，有点像正则的里中括号里的内容（如[a-zA-Z]）。p.s. 别称里的内容不会被认为是实体。

在上面的例子中%[intro_new_user]('training': '100', 'testing': '50')，表明想生成的意图是intro_new_user。并且训练集生成100个样本，测试集50个。

接下来的一行, *[60%] ~[hi?]，~[pre1?]~[pre2]~[pre3]，~[indicate?]@[username]

• *[60%]： 表示这一行的构成规则在最好生成数据中占的比例
• ~[hi?]：随机选择别称hi的一个（比如，选择你好），?表示可以不选，这个与正则中的概念相似
• @[username]：随机选取槽username中的一个，在生成的数据中，选取的槽值会被标记为实体，可用于实体识别，有位置信息。

这里需要注意的是：各个部分之间如果有空格，生成的结果中也会有空格。生成结果只是替换~[hi?]，~[hi?]和其后面的~[pre1?]之间的任何内容都会原封不动保留，比如这里的逗号。所以，对于要考虑分词的误差的场景下，建议各个部分之间不要采用空格分隔的方式，保持中文的自然连接。

基本这些内容就够用了，其他用法可以自行探索DSL。

生成数据

生成语法为

npx chatito <pathToFileOrDirectory> --format=<format> --formatOptions=<formatOptions> --outputPath=<outputPath> --trainingFileName=<trainingFileName> --testingFileName=<testingFileName> --defaultDistribution=<defaultDistribution> --autoAliases=<autoAliases>

• <pathToFileOrDirectory> path to a .chatito file or a directory that contains chatito files. If it is a directory, will search recursively for all *.chatito files inside and use them to generate the dataset. e.g.: lightsChange.chatito or ./chatitoFilesFolder
• <format> Optional. default, rasa, luis, flair or snips.
• <formatOptions> Optional. Path to a .json file that each adapter optionally can use
• <outputPath> Optional. The directory where to save the generated datasets. Uses the current directory as default.
• <trainingFileName> Optional. The name of the generated training dataset file. Do not forget to add a .json extension at the end. Uses ``_dataset_training.json as default file name.
• <testingFileName> Optional. The name of the generated testing dataset file. Do not forget to add a .json extension at the end. Uses ``_dataset_testing.json as default file name.
• <defaultDistribution> Optional. The default frequency distribution if not defined at the entity level. Defaults to regular and can be set to even.
• <autoAliases> Optional. The generaor behavior when finding an undefined alias. Valid opions are allow, warn, restrict. Defauls to ‘allow’.

可以生成Rasa、Flair、LUIS、Snips NLU格式的数据，以Rasa为例。

npx chatito ./chatito --format=rasa --outputPath=./data

生成的结果放在data文件夹下

rasa_dataset_testing.jsonrasa_dataset_training.json

生成的文件是一行的json，采用pbcopy < rasa_dataset_testing.json, 粘贴在http://www.totootool.com/json.html。

训练集会多两项

"regex_features":[],"entity_synonyms":[]

具体跟rasa有关，这里不再赘述。

接下来，会介绍如何使用snorkel做NLP数据增强和弱监督训练数据生成。

hexo采用LiveRe(来必力)添加评论系统，不蒜子添加访客统计。

评论系统

本来之前采用的是gittalk，想着照顾没有github账号和想匿名留言的同学。调查了一通，发现了一个比较好的工具：LeanCloud。不仅有匿名留言，还有访客统计。满怀期待，最后发现还要实名认证，弃！

逛了一圈，综合稳定性和美观性，选用了LiveRe(来必力)。去注册一个账号，选择社区，复制data-uid，填到主题的_config.yml中的livere=your id即可。

<div id="lv-container" data-id="city" data-uid="you id">

需要注意的是，需要在管理页面中设置社交平台和评论提醒邮件地址。

不蒜子

参考不蒜子官网的介绍，使用只需

<script async src="//busuanzi.ibruce.info/busuanzi/2.3/busuanzi.pure.mini.js"></script><span id="busuanzi_container_site_pv">本站总访问量<span id="busuanzi_value_site_pv"></span>次</span>

但是默认，默认开启后，发现前端不显示，进一步查发现display:none。

解决方案如下

1. post.pug

找到不蒜子部分，删掉span#busuanzi_container_page_pv= ' | '中的#busuanzi_container_page_pv，完整的不蒜子部分

if theme.busuanzi == true        //- script(src='https://dn-lbstatics.qbox.me/busuanzi/2.3/busuanzi.pure.mini.js', async) // 老版，不蒜子已更换域名        <script async src="//busuanzi.ibruce.info/busuanzi/2.3/busuanzi.pure.mini.js"></script>        span= ' | '          span#busuanzi_value_page_pv          span= ' ' + __('Hits')

2. footer.pug

maupassant-hexo默认主题下是没有在footer中做站点统计的，只有篇章统计。添加如下

#footer  if theme.busuanzi == true      <script async src="//busuanzi.ibruce.info/busuanzi/2.3/busuanzi.pure.mini.js"></script>      <span>本站总访问量<span id="busuanzi_value_site_pv"></span>次</span>      <span>总访客<span id="busuanzi_value_site_uv"></span>人</span>      <br>  = 'Copyright © ' + date(Date.now(), 'YYYY') + ' '  a(href=url_for('.'), rel='nofollow')= config.title + '.'  |  Powered by  a(rel='nofollow', target='_blank', href='https://hexo.io')  Hexo.  a(rel='nofollow', target='_blank', href='https://github.com/tufu9441/maupassant-hexo')  Theme  |  by  a(rel='nofollow', target='_blank', href='https://github.com/pagecho')  Cho.

这里也填了一个坑。

如果按照其他家博客的介绍，

<span id="这里是有id的（busuanzi_container_site_pv）">本站总访问量<span id="busuanzi_value_site_pv"></span>次</span>

同理，这里也两个span的id删掉了。

大工告成。

看板娘

多说一句，如果想使用自己的看板娘，参考: Hexo 博客利用 live2d 插件放置一个萌萌哒看板娘

简单做法

1. 在您博客根目录下创建一个 live2d_models 文件夹2. 在此文件夹内新建一个子文件夹, 如 **mymodel**3. 将你的 Live2D 模型复制到这个子文件夹中，自有模型应当有一个 .model.json 文件 (例如 mymodel.model.json)4. 将子文件夹的名称输入 _config.yml 的 model.use 中

重新hexo g就好

考虑这样一个场景，我们要处理一个多分类问题，由于目标的空间是开放的，我们无法穷举所有的类别。目前我们制定了K类去训练一个多分类模型，在预测未知数据时，有可能出现未识别的类型，此时我们的多分类模型会赋予它k类中的一类。然鹅，这个赋予是错误的。那怎样去避免和处理这样的现象呢？

方案思考

遇到这个问题，很多人的第一直观想法是，分别给没类训练一个one-class classifier（比如one-class svm）不就好了。

这确实是一个看起来很不错的想法。但是one-class classifer本质上是做异常检测的，如果某一类的样本空间分布很分散，并没有聚成团，此时可能正确的样本都会被判断成错误的类别。实际中遇到各种乱七八糟的数据，我对one-class classifier的性能是打问号的。当然如果能精心设计，以上当我扯淡。

除了one-class classifer外，我粗略考虑到的两种稍微靠谱一点的做法，这里做一下记录。（貌似找到了这方面的paper，比如Unseen Class Discovery in Open-world Classification，之后找时间再写一篇学习下这类做法）

1. 将multi-class改成multi-label任务
2. 设计一个pipline，第一个分类器判断是否见过，第二就是常规的多分类

第二个做法中第一个分类器的设计，见仁见智。可以设计成one-class分类器，也可以计算与已知样本/类别的距离等这样简单的做法。

目前实践了第一种做法，做一下记录

multi-label

Multi-label指的是，一个样本可能有多个标签，不再是单一标签。比如一副海滩的图片，我们对其进行分类，其可能同时具备标签，白云、大海、沙滩、山、树。将其只分给其中一个比如大海，是不合适的。

扯个题外话，分类问题我觉得可以分为四类

1. Binary classification
2. Multi-class classification
3. Multi-label classification
4. Multi-target classification

提供两个工具：scikit-multilearn、meka

Multi-label算法的核心其实是想利用label和label之间的相关性，我们这里处理未见类别其实没有利用到这个思想。

具体算法可以分为如下几类

1. Binary Relevance：每个标签看作一个单独的类分类问题。
2. Classifier Chain：单独分类每个类别，但是前面得分类伪标签会作为后面分类的特征。（利用相关性，需要组合不同的链）
3. Label Powerset：组合类别做多个多分类问题
4. Adaptive：这类就比较丰富了，MLKNN、神经网络、集成学习

在本次考虑的场景下，我们并没有考虑类别之间的关系，所以采用BR做一个测试，本次没有使用scikit-multilearn，仅仅用了sklearn的multi-label工具。

from sklearn.feature_extraction.text import CountVectorizerfrom sklearn.model_selection import ShuffleSplit, train_test_splitfrom sklearn.linear_model import LogisticRegressionfrom sklearn.svm import SVCfrom sklearn.metrics import classification_reportfrom sklearn.preprocessing import LabelBinarizer, LabelEncoderfrom sklearn.multiclass import OneVsRestClassifierimport numpy as npdef train_one_vs_rest(self):    all_data_file = 'data.txt'    data_all, labels_all = self.process_data(all_data_file)    # lb = LabelEncoder()    lb = LabelBinarizer()    y = lb.fit_transform(labels_all)    print(lb.classes_)    text_train, text_test, y_train, y_test = \        train_test_split(data_all, y, test_size=0.33, random_state=0)    count_vect = CountVectorizer()    train_vec = count_vect.fit_transform(text_train)    clf = OneVsRestClassifier(LogisticRegression())    clf.fit(train_vec, y_train)    print(len(clf.estimators_))    test_vec = count_vect.transform(text_test)    pred = clf.predict(test_vec)    print(classification_report(y_test, pred))    self.model = clf    self.vectorizer = count_vect    pred = self.pred_multi_label(test_vec)    print(pred)    def pred_multi_label(self, vectors):    preds = []    for i in range(len(self.model.estimators_)):        preds.append(            self.model.estimators_[i].predict_proba(vectors)[:, 1])    return np.column_stack(tuple(preds))

这里需要注意的是，在预测过程中，如果采用OneVsRestClassifier默认的predictproba，得到的没类的概率是归一化的。我想得到的就是具体属于每一类的概率，不要归一化。所以，这里采用了其属性`estimators`来计算具体的概率。

实验发现，效果贼好。对于已知类别，对应类上的概率基本大于80%，而对于未见类别，最高也在57%左右。

此时我们完全可以采用70%去截断，如果一个类别未达到，那就是未知类别了。

当然，这种做法还有一些问题，接下来梳理下更好的做法。

使用booststrap-vue和FileReader做文件读取、file-saver做文件下载

文件读取

1. 选取本地文件

参考bootstrap-vue的form-file，来选取本地文件

<b-form-file  v-model="dataFile"  :state="Boolean(dataFile)"  placeholder="选择文件"  drop-placeholder="拖拽到这里"  style="text-align: left;"  size="sm"></b-form-file>

选取到的文件存放在compenent data的dataFile中。

2. 读取文件内容

loadFile () {  const reader = new FileReader();  const _this = this;  reader.readAsText(_this.dataFile);  reader.onload = function () {    // this.result为读取到的json字符串，需转成json对象    _this.importJSON = JSON.parse(this.result);  }},

文件下载

比如我们在前端编辑了一些数据，希望将这些数据下载为json文件，查了一圈发现还是file-saver最好用。

安装

npm i file-saver

不需要在头部import，采用require的方式

saveData(){    var FileSaver = require('file-saver');    var data = JSON.stringify(this.graph, null, 2);    var blob = new Blob([data], {type: "application/json;charset=utf-8"});    FileSaver(blob, "output.json");}

注意：这里的api与github上readme上写的已经不一样了，我目前的最新版本号2.0.2。这里不再采用FileSaver.saveAs(file)

[TOC]

业务场景：小样本数据上的任务型对话理解。

对话领域三类

1. 问答类
2. 任务类
3. 闲聊类

1. 规则方法

1.1 意图识别

• 词典法
• CFG（上下文无关语法）
• JSGF（JSpeech Grammar Format）

参考资料：

• CFG原理
• 自然语言处理之CFG句法分析
• JSpeech Grammar Format (JSGF) compiler, matcher and parser package for Python.

1.2 命名实体识别

需要构造词典

• AC自动机算法（Aho–Corasick算法）
• Aho Corasick自动机结合DoubleArrayTrie极速多模式匹配
• 基于规则的模型

参考：

• Review on Intent Classification and Slot Filling
• 基于Rasa_NLU的微信chatbot

2. 模型方法

A dataset survey about task-oriented dialogue, including recent datasets and SoA results & papers.

2.1 pipeline

pipeline方法将意图识别和槽填充分为两个独立的部分，分别进行训练。

2.1.1 意图识别

本质上是短文本分类任务，一般的文本分类算法都可以处理

传统算法：

• LR
• SVM
• KNN
• RF
• GBDT
• …

深度学习方法

• Fasttext
• TextCNN
• GRU
• LSTM
• IDCNN
• TextRNN

经调研，预训练fasttext词向量+单层textcnn从分类效果和速度上都相对较优，作为优先选择。

TextCNN的改进：

• K-max pooling
• DPCNN
• …

2.1.2 槽填充

• CRF
• RNN/LSTM/CNN+CRF
• BiLSTM+CRF
• BiLSTM+CNN+CRF

2.2 joint model

• A TensorFlow implementation of Recurrent Neural Networks for Sequence Classification and Sequence Labeling

• Attention-Based Recurrent Neural Network Models for Joint Intent Detection and Slot Filling

• https://www.coursera.org/lecture/language-processing/intent-classifier-and-slot-tagger-nlu-RmVnE

• Task-Oriented Dialogue Dataset Survey

其中第三条提到的模型: Convolutional Sequence to Sequence Learning

3. 企业做法

3.1 阿里小蜜

Arxiv: AliMe Assist: An Intelligent Assistant for Creating an Innovative E-commerce Experience

note: 经内部人员考证，这套框架太老已弃用

• business rule parser: 大量的样式(patterns)组成的前缀树匹配结构(trie-based)
• Intention classifier: 场景分类，pre-train采用fasttext，分类采用单层cnn
  • requesting for assistance
  • asking for information or solution
  • chaŠtting
• Semantic Parser: a trie-based, 匹配知识图谱中的实体

3.2 美团

参考：美团对话理解技术及实践

上下文无关文法，工具，规则的写法

4. 数据

• 【语料】百度的中文问答数据集WebQA
• SophonPlus/ChineseNlpCorpus
• candlewill/Dialog_Corpus: 用于训练中英文对话系统的语料库 Datasets for Training Chatbot System
• brightmart/nlp_chinese_corpus: 大规模中文自然语言处理语料 Large Scale Chinese Corpus for NLP

5. 开源工具

5.1 ChatterBot

github 9.1k

没有NLU模块，做法是匹配式，训练的输入是一系列完整的对话过程，数据库存储。

通过Logic adapters来获取输出结果

• BestMatch
• TimeLogicAdapter
• MathematicalEvaluation

这个框架主要对问题文本 使用相似度匹配，找出库中预定好的答案。 比较适合，知识问答类的情形。

5.2 rasa

• rasa 6.8k
• Rasa_NLU_Chi 848

数据

• 语料标注工具：rasa-nlu-trainer
• 数据生成工具：chatito

意图识别

• KeywordIntentClassifier：This classifier is mostly used as a placeholder. It is able to recognize hello and goodbye intents by searching for these keywords in the passed messages.
• MitieIntentClassifier： This classifier uses MITIE to perform intent classification. The underlying classifier is using a multi-class linear SVM with a sparse linear kernel 。
• SklearnIntentClassifier： The sklearn intent classifier trains a linear SVM which gets optimized using a grid search.需要前置feature extractor
• EmbeddingIntentClassifier： The embedding intent classifier embeds user inputs and intent labels into the same space. Supervised embeddings are trained by maximizing similarity between them. This algorithm is based on StarSpace.

实体识别

• MitieEntityExtractor：The underlying classifier is using a multi class linear SVM with a sparse linear kernel and custom features
• SpacyEntityExtractor：Using spaCy this component predicts the entities of a message. spacy uses a statistical BILOU transition model.
• EntitySynonymMapper： Maps synonymous entity values to the same value. 通过数据中的value来提供
• CRFEntityExtractor：spaCy has to be installed. 貌似用的spaCy的实现
• DucklingHTTPExtractor： Duckling lets you extract common entities like dates, amounts of money, distances, and others in a number of languages.

槽填充

官方文档：slot的使用

参考：

• GaoQ1/rasa-nlp-architect: 采用nlp-architect实现rasa-nlu中文意图提取和槽填充
• Building contextual assistants with Rasa Forms: 原文, 译文

均可自定义component: Enhancing Rasa NLU models with Custom Components

5.3 DeepPavlov

deepmipt/DeepPavlov: 3.6k

An open source library for deep learning end-to-end dialog systems and chatbots. https://deeppavlov.ai

支持英文和俄语。功能全面，可作为学习参考。

基本概念

• Agent is a conversational agent communicating with users in natural language (text).
• Skill fulfills user’s goal in some domain. Typically, this is accomplished by presenting information or completing transaction (e.g. answer question by FAQ, booking tickets etc.). However, for some tasks a success of interaction is defined as continuous engagement (e.g. chit-chat).
• Model is any NLP model that doesn’t necessarily communicates with user in natural language.
• Component is a reusable functional part of Model or Skill.
• Rule-based Models cannot be trained.
• Machine Learning Models can be trained only stand alone.
• Deep Learning Models can be trained independently and in an end-to-end mode being joined in a chain.
• Skill Manager performs selection of the Skill to generate response.
• Chainer builds an agent/model pipeline from heterogeneous components (Rule-based/ML/DL). It allows to train and infer models in a pipeline as a whole.

Models:

• NER model [docs]: BERT-based and Bi-LSTM+CRF.
• Slot filling models [docs]:
• Classification model [docs]
• Automatic spelling correction model [docs]
• Ranking model [docs]
• TF-IDF Ranker model [docs]
• Question Answering model [docs]
• Morphological tagging model [docs]
• Frequently Asked Questions (FAQ) model [docs]

意图识别

• BERT classifier (see here) builds BERT 8 architecture for classification problem on Tensorflow.
• Keras classifier (see here) builds neural network on Keras with tensorflow backend.
• Sklearn classifier (see here) builds most of sklearn classifiers.

模型很丰富

NER

• standard RNN based and BERT based.
• Multilingual BERT Zero-Shot Transfer
• Few-shot Language-Model based

槽填充

官方文档: Neural Named Entity Recognition and Slot Filling

This model solves Slot-Filling task using Levenshtein search and different neural network architectures for NER.

Slotfiller will perform fuzzy search through the all variations of all entity values of given entity type. The entity type is determined by the NER component.

使用博客：DeepPavlov articles with Python code

规则编写

只见到了对话规则的编写，通过PatternMatchingSkill，使用正则编写pattern和response

有一个包装rasa的Rasa Skill

DeepPavlov存在的问题

1. 环境依赖
   • DeepPavlov是基于TensorFlow和Keras实现的，不能继承其他计算框架的模型实现（如PyTorch）。
2. 语言支持
   • Pre-train模型和评测数据集主要基于英文和俄文，不支持中文。
3. 生产环境部署
   • DeepPavlov在运行时需要依赖整个框架源码，开发环境对框架修改后，生产环境需要更新整个框架。
   • 也不能直接将功能Component作为服务独立导出，不适合在生产环境的部署和发布。

5.4 Snips-nlu

snipsco/snips-nlu: 3k

Snips Python library to extract meaning from text https://snips-nlu.readthedocs.io

不支持中文

Tutorial： 意图和槽值都放在训练数据中了

# turnLightOn intent---type: intentname: turnLightOnslots:  - name: room    entity: roomutterances:  - Turn on the lights in the [room](kitchen)  - give me some light in the [room](bathroom) please  - Can you light up the [room](living room) ?  - switch the [room](bedroom)'s lights on please

This parser parses text using two steps: first it classifies the intent using an IntentClassifier and once the intent is known, it using a SlotFiller in order to extract the slots.

IntentClassifier

• Logistic Regression
• Feature extractor for text classification relying on ngrams tfidf and optionally word cooccurrences features
• scikit-learn TfidfVectorizer
• Featurizer that takes utterances and extracts ordered word cooccurrence features matrix from them

SlotFiller

• Linear-Chain Conditional Random Fields

5.5 其他

• 基于金融-司法领域(兼有闲聊性质)的聊天机器人
• 基于最新版本rasa搭建的对话系统demo
• 使用 RASA NLU 来构建中文自然语言理解系统
• crownpku/Awesome-Chinese-NLP

参考：

1. 2019-06-17问答系统项目落地调研
2. YSSNLP2019 人机对话研究热点及前沿技术概述
3. 美团对话理解技术及实践
4. 对话系统 NLU/DM 任务详解
5. NLP笔记 - NLU之意图分类
6. 自然语言理解中的槽位填充

使用configparser解析ini格式的配置文件

• lib: https://pypi.org/project/configparser/
• doc: https://docs.python.org/3/library/configparser.html

  pip install configparser

get的时候，如果key在DEFAULT段中，get设置的deflault无效，总是返回DEFAULT段中的值

ini格式的config文件示例

[DEFAULT]ServerAliveInterval = 45Compression = yesCompressionLevel = 9ForwardX11 = yes[bitbucket.org]User = hg[topsecret.server.com]Port = 50022ForwardX11 = no

处理csv文件的时候，有时文本中有一些不可打印的字符，影响诸如文件分行和excel的解析。
主要需要去除文本中的换行符和制表符。

方法一：用CLEAN函数

CLEAN函数可以删除文本中不能打印的字符。

假如A1单元格包含换行符，可在B1单元格中输入公式：

"=CLEAN(A1)"

方法二：查找替换法(不好用)

1. 按快捷键Ctrl+H，打开“查找和替换”对话框；
2. 选择“查找内容”后的文本框，按住Alt键，在数字键盘中输入“0010”。需要注意的是这样输入后，在“查找内容”后的文本框中不会显示任何内容，但实际上是有的；
3. 单击“全部替换”按钮，换行符将被全部替换。

参考文献:
如何快速批量删除Excel单元格中的“换行符”

git常用小结

配置

获取配置信息

git config --system --listgit config --local --list

git config --global user.name "Your Name"git config --global user.email "email@example.com"

1. 本地生成ssh密钥对

   ssh-keygen -t rsa

2. 密钥对生成完成后存放于当前用户 ~/.ssh 目录中，查看 id_rsa.pub

   cat ~/.ssh/id_rsa.pub

3. 添加入github的setting中

常用命令

git diff --cached  # 查看已经暂存起来的文件和上次提交时的快照之间的差异git diff --staged  # Git 1.6.1及更高版本，效果同上git commit -a -m 'comment'  # 自动把所有已经跟踪过的文件暂存起来一并提交git commit --amend  # 撤销操作重新提交    # 只生成一个commit    git commit -m 'initial commit'    git add forgotten_file    git commit --amendgit rm --cached filename  # 移除跟踪但不删除文件git log     --pretty=oneline  # 每个提交放在一行显示, 其他：short，full 和 fuller    --pretty=format:"%h %s"  # 更加简洁的信息     --graph  # oneline 或 format 时结合 --graph 选项    - p  # 显示每次提交的内容差异    - 2  # 显示最近的两次更新git log --graph --pretty=oneline  # 常用查看loggit reset HEAD <file>  # 已经add, 把暂存区的修改撤销掉git checkout -- <file>  # 还未add, 撤销工作区的修改# git log 查看版本号，再版本回退，若想再次恢复到新版本，git reflog 查看版本号git reset --hard [commit id]  git checkout branchname  # 切换分支git checkout -b brachname  # 创建并切换分支git branch -d branchname  # 删除分支# 强制禁用Fast forward模式，Git就会在merge时生成一个新的commitgit merge --no-ff -m 'comment' branch  git stash  # bug 分支    1. 在当前分支git stash，工作区恢复到最近一次commit    2. 处理完其他分支问题    3. 在当前分支git stash list查看stash内容    4. git stash pop，恢复并删除stashgit remote -v  # 查看远程库分支git push origin master/dev  # 推送分支git checkout -b dev origin/dev  # 创建远程origin的dev分支到本地，需先创建本地dev分支git pull  # 拉取远程到本地，遇到推送有冲突的时候，先 git pull，本地解决冲突，再pushgit remote add origin git@github.com:xxx/xxx.git  # 关联远程库

信息抽取是一个常见的nlp任务，为经常一起提到的知识图谱的基础。

这里有一份比较好的知识图谱入门资料:
Mining Knowledge Graphs from Text

信息抽取分为有监督和无监督方法。实际中监督信息往往是缺失的，所以本文主要提无监督方法。

在无监督方法中，一个广泛采用的工具是句法依存树，或者叫句法解析树（Dependency Tree）。

可视化工具：

• conllu.js
• Dependency Viewer

工作中总结出来的一种基于句法解析树的信息提取的一般方法（尚未完善）：

1. 从CONLL格式的句法依存解析结果，生成具备孩子节点和父节点索引的树，并获取根结点root_id；
2. 自上而下递归的进行解析，孩子节点的解析结果上传到父节点进行汇总；
   1. 如果当前节点为叶子节点（无孩子节点），判断当前节点类型，返回dict，上传给父节点；
   2. 如果当前词为动词（一般句子的核心是动词，一般方法也都是从动词开始扩展）或者用户指定的目标词，根据制定的规则提取指定关系类型的孩子，如定中关系、状中关系、动宾关系、主谓关系等，这里需要注意的是并列关系，有可能是补充，有可能是同级并列；
   3. 如果当前词非动词，先判断其所属信息类型，若能判断，关系向孩子传递，如不能判断，等待孩子节点上传的结果；
   4. 合并所有孩子的信息，按原始句子顺序排序
3. 修正后处理

以提取文本中，关于道路信息的（时间、原因、地点、时间）四元组为例，输入句子：

黄石高速:因交通管制,晋州站、辛集站、藁城东站双向关闭。因沧州服务区附近K81处黄骅方向发生交通事故,沧州服务区附近K81处黄骅方向车辆缓慢通行约4公里

句法解析树：

1黄石黄石nhnr_3SBV__2高速高速dd_3ADV__3::vv_0HED__4因因pp_14ADV__5交通管制交通管制vv_4POB__6,,wpw_4WP__7晋州站晋州站nsns_14SBV__8、、wpw_9WP__9辛集站辛集站nn_7COO__10、、wpw_12WP__11藁城藁城nsns_12ATT__12东站东站nn_7COO__13双向双向dd_14ADV__14关闭关闭vv_3COO__15。。wpw_3WP__16因因pp_24ADV__17沧州沧州nsns_18ATT__18服务区服务区nn_19ATT__19附近附近ndf_21ATT__20K81K81wsnx_21ATT__21处处nn_22ATT__22黄骅黄骅nsns_23ATT__23方向方向nn_16POB__24发生发生vv_3COO__25交通事故交通事故nn_24VOB__26,,wpw_24WP__27沧州沧州nsns_28ATT__28服务区服务区nn_29ATT__29附近附近ndf_31ATT__30K81K81wsnx_31ATT__31处处nn_34ATT__32黄骅黄骅nsns_33ATT__33方向方向nn_34ATT__34车辆车辆nn_36SBV__35缓慢缓慢aad_36ADV__36通行通行vv_24COO__37约约dd_38ATT__3844mm_39ATT__39公里公里qq_36CMP__40。。wpw_3WP__

核心代码如下：

class WordBean(object):   ''' 扩展conllword，存储父节点与孩子节点索引 '''       def __init__(self):           self.lemma = None           self.postag = None           self.relation = None           self.head_id = None           self.flag = True  # 是否还处于树中标志位，已合并的ATT将置为False           self.child = []          def set_word(self, conll_word):           self.lemma = conll_word.LEMMA           self.postag = conll_word.POSTAG           self.relation = conll_word.DEPREL           self.head_id = conll_word.HEAD.ID - 1          def add_child(self, child_id, child_relation):           self.child.append((child_id, child_relation))             def extract_entity_tuple(self, dependency_tree, seed_id, head_type=''):       '''自上而下解析树'''       res_entity_tuple_list = []       res_dict = dict()       res_dict['time'] = []       res_dict['reason'] = []       res_dict['place'] = []       res_dict['status'] = []       # 判断是否是叶子节点       if len(dependency_tree[seed_id].child) == 0:           if dependency_tree[seed_id].lemma in self.status_set:               res_dict['status'].append((seed_id, dependency_tree[seed_id].lemma))           elif self.check_is_time(dependency_tree, seed_id):               res_dict['time'].append((seed_id, dependency_tree[seed_id].lemma))           elif head_type == 'reason':               res_dict['reason'].append((seed_id, dependency_tree[seed_id].lemma))           elif head_type == 'time':               res_dict['time'].append((seed_id, dependency_tree[seed_id].lemma))           else:               if not dependency_tree[seed_id].lemma in self.discard_word_set:                   res_dict['place'].append((seed_id, dependency_tree[seed_id].lemma))           res_entity_tuple_list.append(res_dict)           return res_entity_tuple_list       # 非叶子节点需要向下递归解析       if dependency_tree[seed_id].lemma in self.status_set:           # 当前节点为状态节点           status_merge_list = []           for c_id, c_relation in dependency_tree[seed_id].child:               child_bean = dependency_tree[c_id]               if c_relation in ('COO', '并列关系'):                   # 假设状态下不存在嵌套状态，有视为补充                   if dependency_tree[c_id].postag == 'v' and len(dependency_tree[c_id].child) == 0:                       res_dict['status'].append((c_id, dependency_tree[c_id].lemma))                   else:                       child_dict_list = self.extract_entity_tuple(dependency_tree, c_id)                       for child_dict in child_dict_list:                           self.merge_two_tuple_dict(res_dict, child_dict)               elif c_relation in ('ADV', '状中结构'):                   # 处理状中结构                   if child_bean.lemma in ('因', '受', '由于'):                       # 处理原因                       child_dict_list = self.extract_entity_tuple(dependency_tree, c_id)                       for child_dict in child_dict_list:                           self.merge_two_tuple_dict(res_dict, child_dict)                   elif child_bean.lemma == '处' or child_bean.postag == 'p':                       child_dict_list = self.extract_entity_tuple(dependency_tree, c_id)                       for child_dict in child_dict_list:                           self.merge_two_tuple_dict(res_dict, child_dict)                   elif child_bean.postag in ('a', 'ad', 'd'):                       self.merge_att(dependency_tree, c_id)                       status_merge_list.append(c_id)                   elif self.check_is_time(dependency_tree, c_id):                       self.merge_att(dependency_tree, c_id)                       res_dict['time'].append((c_id, dependency_tree[c_id].lemma))               elif c_relation in ('POB', '介宾关系') and                        child_bean.lemma in ('因', '受', '由于'):                   self.merge_att(dependency_tree, c_id)                   res_dict['reason'].append((c_id, dependency_tree[c_id].lemma))               elif c_relation in ('CMP', '动补结构'):                   self.merge_att(dependency_tree, c_id)                   status_merge_list.append(c_id)               elif c_relation in ('SBV', '主谓关系'):                   # 处理主谓关系，解析具体地点                   child_dict_list = self.extract_entity_tuple(dependency_tree, c_id)                   for child_dict in child_dict_list:                       self.merge_two_tuple_dict(res_dict, child_dict)               elif c_relation in ('VOB', '动宾关系'):                   if len(dependency_tree[c_id].child) == 0:                       res_dict['status'].append((c_id, dependency_tree[c_id].lemma))                   else:                       child_dict_list = self.extract_entity_tuple(dependency_tree, c_id)                       for child_dict in child_dict_list:                           self.merge_two_tuple_dict(res_dict, child_dict)           status_buffer = []           status_merge_list.append(seed_id)           status_merge_list.sort()           for id in status_merge_list:               status_buffer.append(dependency_tree[id].lemma)           res_dict['status'].append((seed_id, ''.join(status_buffer)))           res_entity_tuple_list.append(res_dict)           return res_entity_tuple_list       else:           # 当前节点为非状态节点           pre_head_type = head_type           if self.check_is_time(dependency_tree, seed_id):               # 为时间节点               head_type = 'time'               res_dict['time'].append((seed_id, dependency_tree[seed_id].lemma))           elif dependency_tree[seed_id].lemma in ('因', '受', '由于') or head_type == 'reason':               # 为原因节点               head_type = 'reason'               res_dict['reason'].append((seed_id, dependency_tree[seed_id].lemma))           else:               if not dependency_tree[seed_id].lemma in self.discard_word_set:                   res_dict['place'].append((seed_id, dependency_tree[seed_id].lemma))           child_dict_list = []           coo_list = []           for c_id, c_relation in dependency_tree[seed_id].child:               # if c_relation in ('COO', '并列关系'):               #     coo_list.append(c_id)               if c_relation in ('WP', '标点符号'):                   continue               else:                   if head_type == 'reason' and not pre_head_type == 'reason':                       if c_relation in ('POB', '介宾关系'):                           child_dict_list.extend(self.extract_entity_tuple(dependency_tree, c_id, head_type))                           if dependency_tree[c_id].lemma in self.status_set:                               res_dict['reason'].append((c_id, dependency_tree[c_id].lemma))                   else:                       child_dict_list.extend(self.extract_entity_tuple(dependency_tree, c_id, head_type))           # 先合并非状态           status_dict_list = []           for child_dict in child_dict_list:               if len(child_dict['status']) > 0:                   status_dict_list.append(child_dict)               else:                   self.merge_two_tuple_dict(res_dict, child_dict)           # 再合并存在状态的           if len(status_dict_list) == 0:               res_entity_tuple_list.append(res_dict)           else:               for child_dict in status_dict_list:                   # tmp_dict = res_dict.copy()                   tmp_dict = copy.deepcopy(res_dict)                   self.merge_two_tuple_dict(tmp_dict, child_dict)                   res_entity_tuple_list.append(tmp_dict)           return res_entity_tuple_list   def extract_information(self, line):       segs = self.nlp_tokenizer.seg(line)       # fix segs       self.fix_seged_postag(segs)       conll_words = self.parser.parse(segs).getWordArray()       dependency_tree, root_id = self.construct_dependency_tree(conll_words)       res_entity.append(self.extract_entity_tuple(dependency_tree, i))       res_entity = self.extract_entity_tuple(dependency_tree, root_id)       # print entity tuples       for entity in res_entity:           entity['time'].sort()           entity['place'].sort()           entity['reason'].sort()           entity['status'].sort()           self.fix_entity_tuple_dict(entity)           print(entity)       return res_entity

实验结果：

# 输入句子'黄石高速:因交通管制,晋州站、辛集站、藁城东站双向关闭。因沧州服务区附近K81处黄骅方向发生交通事故,沧州服务区附近K81处黄骅方向车辆缓慢通行约4公里。'# 信息提取结果{'time': [], 'reason': ['因交通管制'], 'place': ['黄石高速:, 晋州站, 辛集站, 藁城东站'], 'status': ['交通管制, 双向关闭']}{'time': [], 'reason': ['因沧州服务区附近K81处黄骅方向'], 'place': ['黄石高速:, 发生交通事故, 沧州服务区附近K81处黄骅方向'], 'status': ['缓慢通行约4公里']}

可以看到，第一句的解析没问题，但是第二句原因的解析边界出错。当前的解析方法仍然比较依赖于句法依存树的准确性，实体的边界的准确性不够，也是需要改进的地方。

分类任务中样本类别不均衡是常有的事，当样本之间的不均衡程度较小的时候，可以不作处理，当正负样本比例较大（比如10:1）且训练数据较少的时候，就需要做不均衡的处理。常见的处理方式可以分为如下几类：

• 采样方法
  • 下采样（或欠采样，under-sampling）
  • 上采样（或过采样，over-sampling）
  • 混合采样
• 数据增强
  • 收集更多的数据
  • 造数据
• 更改评价指标
• cost sensitive（代价敏感，class weight）
• 模型集成
• one-class classifier

采样方法

对于下采样，最简单方便的是随机采样。以两分类为例，这里涉及两个问题：

1. 应该采样哪些样本？
2. 采样比例应该采样为1:1么？

理想情况下，我们希望采样的样本能反应实际的数据空间分布。所以可以通过对多数类进行聚类，然后挑选中心。imblearn中的ClusterCentroids就是这种思想。imblearn还提供了其他几种样本挑选方式：

1. NearMiss-1：到少数类样本的n近邻的平均距离的最小的多数样本
2. NearMiss-2：到n个最远的少数类样本的平均距离的最小的多数样本
3. NearMiss-3：对于每个少数类样本，先保留其多数类M近邻，再从中挑选N近邻平均距离最大的
4. EditedNearestNeighbours：通过近邻，移除与邻居差异较大的样本

还有几种EditedNearestNeighbours的扩张不再赘述。以上几种方法的本质是挑选分类边界附近的样本。这一部分其实可以参考半监督学习，可参考周志华老师的一篇经典paper:Active Learning by Querying Informative and Representative Examples，挑选最具信息量和最具代表性的样本。

对于上采样，这一部分与数据增强有一部分重叠，因为其本质是生成新样本。

简单copy少数样本，新生成的样本也就是数据集中样本的一个复制，这样对有些算法是无效的。

其次，可以通过简单差值的方式生成新样本。
最后，常用的两个方法：

1. the Synthetic Minority Oversampling Technique (SMOTE)
2. the Adaptive Synthetic (ADASYN)

更改评价指标

一般分类问题的评价指标为，准确率和p、r、f值。当类别失衡时，准确率就不太可信。
这是还可以使用AUC和ROC，但是AUC在类别不均衡时也不太可信，一般还要综合看一下PR曲线。

代价敏感

我使用代价敏感这个词，最开始是在贝叶斯中学习得来的，有个最小风险贝叶斯估计。其中会指定一个风险矩阵，调整loss function。

一般机器学习方法的损失函数为交叉熵、log损失、最小二乘、指数损失、hinge损失等。
下面以深度学习中的交叉熵为例。

常用计算方式如下

losses = tf.nn.softmax_cross_entropy_with_logits(logits=self.scores, labels=self.input_y)

答案是可以的。tf中有一个API可以帮忙解决来，tf.losses.softmax_cross_entropy。
其中有一个参数为：weights。反映的是batch中每个样本的权重，我们可以通过生成这个weights来变相实现class_weight。具体方式如下：

self.class_weight = tf.placeholder(tf.float32, shape=[1, num_classes], name='class_weight')sample_weights = tf.reduce_sum(tf.multiply(self.input_y, self.class_weight), 1) # size of class_weights: [1, num_classes]losses = tf.losses.softmax_cross_entropy(onehot_labels=self.input_y, logits=self.scores,                                                     weights=sample_weights)

这里的class_weight可以手工指定，也可以通过训练数据计算得出。

categoris = np.argmax(y_train, axis=1)train_class_weight = n_train_samples / (n_classes * np.bincount(categoris))train_class_weight = train_class_weight.reshape(1, n_classes)

模型集成

模型集成也分为两种

1. 单纯的集成方法，比如adboost、gbdt、random forest等；
2. 通过数据采样来造成训练样本差异

第一种方法就不用说了，树模型天生对数据不均衡不敏感。
第二种方法，通过不同的采样率生成不同正负样本比例的数据集进行训练，然后再集成这些模型。

比如：

• 分别设置采样率为1:1, 1:2, 1:3等的采样数据集
• 保留n个少数类样本，并随机抽取10*n 个多数类样本。然后，只需将 10*n个样本分成10份，并训练10个不同的模型。

one-class classifier

转为一分类问题，one-class classifier本身为一种异常检查算法，尽量学得目标类别的边界。

我们在分析文本时，比如命名实体识别，可能想将不同的实体词文本用不同的颜色高亮标识出来，那么采用html自定义标签就是一个比较轻量的方法。

给出一个例子

<!DOCTYPE html><html><head><title>自定义标签Demo</title></head><style type="text/css">time{color: #2980B9 ;}location{color: #8E44AD;}status{color: #FF0000;}</style><body><div style="margin: 20px"><h3>自定义标签：</h3><ul><li><time>时间</time></li><li><location>地点</location></li><li><status>状态</status></li></ul></div><div style="margin: 20px"><p><time>2018年10月12日</time>，我在<location>中关村</location><status>打代码</status>。</p></div></body></html>

效果

这里需要注意的是标签之间的覆盖规则，选择最近的标签，参见CSS样式覆盖规则

给出两个网页颜色选择器

• 网页颜色选择器
• html颜色代码

参考：

HTML 自定义元素教程

网页中文本空格存在如下几类

• u200b：零宽度空格
• u0020：普通空格
• u00a0：不换行空格
•   不换行空格的转义字符

处理时，先替换成常规的空格字符

sentence.replaceAll("\\u200B|\\u0020|\\u00a0", " ").trim()

参考：

Unicode 之神奇的空格

双数组Trie树(DoubleArrayTrie)

NLP领域又很多需要词典匹配的需求，也就是，字典树+词典的基本方案。对于中文这种字较多的语言，双数组Trie树是比Trie树更好的结构。

原理讲解：

• 小白详解 Trie 树
• 双数组前缀树（Double-Array Trie）
• Trie树优化算法：Double Array Trie 双数组Trie

代码实现：

• darts-java: Double-ARray Trie System Java implementation
• 双数组Trie树(DoubleArrayTrie)Java实现
• 从Trie树到双数组Trie树

最近对以前学习推荐系统的知识点笔记的一个汇总。

概念

你需要推荐系统吗？

1. 看看产品的目的：建立越多连接越好。
2. 看产品现有的连接：产品的数量

一个简单指标

分子是增加的连接数，分母是增加的活跃用户数和增加的有效物品数。
如果增加的连接数主要靠增加的活跃用户数和增加的物品数贡献，则该值较小，不适合加入推荐系统。反之，如果增加的连接数和新增活跃用户和物品关系不大，说明连接数已经有自发生长的趋势，适合加入推荐系统加速这个过程。

推荐系统的问题/任务

1. 评分预测
2. 行为预测

评分预测

显示打分，目标减小预测分数与实际分数之间的误差，回归问题。

评价标准：RMSE、MAE

评分预测存在的问题：

1. 数据不易收集
2. 数据质量不能保证
3. 评分分布不稳定

显示反馈很少，更多的是隐式反馈，通常为各类用户行为。行为预测更多地利用这部分数据。

行为预测

隐式反馈：登陆刷新、购买、收藏、浏览、点击等

行为预测有两种方式：

1. 直接预测用户行为：CTR预估
2. 预测物品的相对排序：learning2rank

隐式数据的好处：

1. 比显式更加稠密
2. 隐式更加代表用户的真实想法
3. 隐式反馈常常和模型的目标函数关联更密切，也因此通常更容易在 AB 测试中和测试指标挂钩。

推荐系统中几个普遍的问题

1. 冷启动问题
2. 探索与利用问题：Exploit 和 Explore （EE问题）
3. 安全问题
   1. 给出不靠谱的推荐结果，影响用户体验并最终影响品牌形象；
   2. 收集了不靠谱的脏数据，这个影响会一直持续留存在产品中，很难完全消除；
   3. 损失了产品的商业利益，这个是直接的经济损失。

推荐方法

基于内容推荐

用户画像

用户画像应该给机器看，而不是给人看。

用户画像是将用户向量化后的结果，其关键因素：维度和量化。

维度：

1. 每个维度的名称是可理解的
2. 维度的数目是拍脑袋决定的
3. 维度的筛选也是拍脑袋决定的

维度越多越精细，但是计算代价会变大，同时也会引入噪声

量化：
不要为了用户画像而用户画像，它只是推荐系统的一个副产品，所以要根据推荐效果（排序好坏、召回覆盖等指标）来指导用户画像量化。

用户画像构建方法

1. 直接使用原始数据。比如人口统计学信息、购买历史、浏览历史等。
2. 堆数据。堆积历史数据，做统计工作，常用的比如兴趣标签。
3. 机器学习方法，比如隐语义模型、矩阵分解等embedding，构建无法直观理解的稠密向量。

从文本数据中挖掘用户画像

• 用户：昵称、姓名、性别、动态、评论等
• 物品：标题、描述、内容等

构建用户画像步骤

1. 分析用户的文本和物品的文本，使其结构化；
2. 标签选择，为用户挑选有信息量的结构化数据，作为其画像内容。

结构化文本算法

1. 关键词提取：TF-IDF、TextRank。
2. 实体识别NER：常用基于词典的方法结合 CRF 模型。
3. 内容分类：将文本按照频道体系分类，用分类来表达较粗粒度的结构化信息。短文本常用Facebook 开源的 FastText。
4. 聚类：无监督聚类，分簇，使用编号
5. 主题模型：LDA
6. 编码embedding

实体识别还有比较实用化的非模型做法：词典法。提前准备好各种实体的词典，使用trie-tree结构存储，拿着分好的词去词典寻找。
工业级工具：spaCy

LDA工具：Gensim和PLDA等

标签选择

通过户端的文本，物品端的文本如何结构化，得到了诸如标签（关键词、分类等）、主题、词嵌入向量。接下来就是第二步：如何把物品的结构化信息给用户呢？

我们把用户对物品的行为，消费或者没有消费看成是一个分类问题。用户用实际行动帮我们标注了若干数据，那么挑选出他实际感兴趣的特性就变成了特征选择问题。

最常用的是两个方法：卡方检验（CHI）和信息增益（IG）。基本思想是：

1. 把物品的结构化内容看成文档；
2. 把用户对物品的行为看成是类别；
3. 每个用户看见过的物品就是一个文本集合；
4. 在这个文本集合上使用特征选择算法选出每个用户关心的东西。

卡方检验

计算每一个词和每一个类别的卡方值：

1. 每个词和每个类别都要计算，只要对其中一个类别有帮助的词都应该留下；
2. 由于是比较卡方值的大小，所以公式中的 N 可以不参与计算，因为它对每个词都一样，就是总的文本数；
3. 卡方值越大，意味着偏离“词和类别相互独立”的假设越远，靠“词和类别互相不独立”这个备择假设越近。

误区： 基于内容的推荐系统，标签只是很小一部分。而且就算是标签，衡量质量的方式也不是数目够不够。

所谓的基于内容推荐，通俗一点来讲，就是一个包装成推荐系统的信息检索系统。这听上去有点残酷，但通常一个复杂的推荐系统很可能是从基于内容推荐成长起来的。

为什么基于内容的推荐系统这么重要呢？因为内容数据非常易得，哪怕是在一个产品刚刚上线，用心找的话总能找到一些可以使用的内容，不需要有用户行为数据就能够做出推荐系统的第一版。

要把基于内容的推荐做好，需要做好“抓、洗、挖、算”四门功课。它们分别是：

1. 抓：一直持续抓数据丰富自己的内容，所以做好一个基于内容的推荐，抓取数据补充内容源，增加分析的维度，两者必不可少。
2. 洗：冗余的内容、垃圾内容、政治色情等敏感内容等等都需要被洗出去。
3. 挖：很多推荐系统提升效果并不是用了更复杂的推荐算法，而是对内容的挖掘做得更加深入。
4. 算：匹配用户的兴趣和物品的属性，计算出更合理的相关性，这是推荐系统本身的使命，不仅仅是基于内容的推荐才要做的。

结合基于内容推荐的框架看上诉几个步骤

内容这一端：内容源经过内容分析，得到结构化的内容库和内容模型，也就是物品画像。用户这一端：用户看过推荐列表后，会产生用户行为数据，结合物品画像，经过用户分析得到用户画像。

内容分析的产出

1. 结构化内容库
2. 内容分析模型
   结构化的内容库，最重要的用途是结合用户反馈行为去学习用户画像。容易被忽略的是第二个用途，在内容分析过程中得到的模型，比如说：
   
   1. 分类器模型；
   2. 主题模型；
   3. 实体识别模型；
   4. 嵌入模型。

   这些模型主要用在：当新的物品刚刚进入时，需要实时地被推荐出去，这时候对内容的实时分析，提取结构化内容，再于用户画像匹配。

内容推荐算法

1. 直接计算相似度，BM25F算法
2. 转为预估问题、分类问题
   

   一种最典型的场景：提高某种行为的转化率，如点击、收藏、转发等。那么标准的做法是：收集这类行为的日志数据，转换成训练样本，训练预估模型。

   
   每一条样本由两部分构成：一部分是特征，包含用户端的画像内容，物品端的结构化内容，可选的还有日志记录时一些上下文场景信息，如时间、地理位置、设备等等，另一部分就是用户行为，作为标注信息，包含“有反馈”和“无反馈”两类。

二分类：LR+GBDT

协同过滤

User-based CF

$S(u, K)$ 和用户 $ u $ 兴趣最接近的K个用户,$N(i)$ 是对物品i有过行为的用户集合，$w{uv} $ 用户u和v之间的相似度，$ r{ui} $ 用户v对物品i的兴趣，一般为{0,N}

用户相似度计算

用户向量

1. 向量的维度就是物品的个数；
2. 向量是稀疏的，也就是说并不是每个维度上都有数值，原因当然很简单，这个用户并不是消费过所有物品，废话嘛，连我们压箱底的都给用户推荐了，那当然不用再推荐什么了；
3. 向量维度上的取值可以是简单的 0 或者 1，也就是布尔值，1 表示喜欢过，0 表示没有，当然因为是稀疏向量，所以取值为 0 的就忽略了。

Jaccard相似性

余弦相似性

用户间相似度改进：惩罚热门

两个用户对冷门物品采取过同样的行为更能说明他们兴趣的相似度

对两两用户都利用余弦相似度计算相似度。这种方法的时间复杂度是O(|U|*|U|)，这在用户数很大时非常耗时，可以采用物品到用户的倒排表。

存在问题及解决

1. 构造矩阵：采用稀疏矩阵存储，COO（行号，列号，数值）
2. 相似度计算：数据量大时处理

第一个办法是：将相似度计算拆成 Map Reduce 任务，将原始矩阵 Map 成键为用户对，值为两个用户对同一个物品的评分之积，Reduce 阶段对这些乘积再求和，Map Reduce 任务结束后再对这些值归一化；

map: < , r_u1i * r_u2i> ， 各个维度上做乘法

reduce：求和并归一化

第二个办法是：不用基于用户的协同过滤，采用基于图的算法。

另外，这种计算对象两两之间的相似度的任务，如果数据量不大，一般来说不超过百万个，然后矩阵又是稀疏的，那么有很多单机版本的工具其实更快，比如 KGraph、 GraphCHI 等。

1. 推荐计算

得到了用户之间的相似度之后。接下来还有一个硬骨头，计算推荐分数。显然，为每一个用户计算每一个物品的推荐分数，计算次数是矩阵的所有元素个数，这个代价，你当然不能接受啊。

采用MapReduce

1. 遍历每个用户喜欢的物品列表；
2. 获取该用户的相似用户列表；
3. 把每一个喜欢的物品 Map 成两个记录发射出去，一个是键为 < 相似用户 ID，物品 ID，1> 三元组，可以拼成一个字符串，值为 < 相似度 >，另一个是键为 < 相似用户 ID，物品 ID，0> 三元组，值为 < 喜欢程度 * 相似度 >，其中的 1 和 0 为了区分两者，在最后一步中会用到；
4. Reduce 阶段，求和后输出；
5. < 相似用户 ID，物品 ID, 0> 的值除以 < 相似用户 ID，物品 ID, 1> 的值

3:

• < 相似用户 ID，物品 ID，1 > -> w_{uv}
• < 相似用户 ID，物品 ID，0 > -> w{uv}*r{vi}

4: reduce应该是对相似用户求和

5：做归一化处理

Item-CF

物品相似度计算

注：相似度计算基于的是评分矩阵或者布尔化的行为矩阵

Jaccard

物品去中心化

用户去中心化

更一般的相似性计算，比如余弦

1. $$w_{ij} = \frac{< r_i, r_j>}{|r_i|}$$
2. 热门关联 $$w_{ij} = \frac{< r_i, r_j>}{|r_i||r_j|}$$
3. 对热门的打压 $$w_{ij} = \frac{< r_i, r_j>}{|r_i|^{\alpha} |r_j|^{ 1- \alpha }}$$ $ \alpha $ 为0 最大限度打压热门，为1 不打压
4. 用户打压 $$<r_i, r_j> = \sum_{u \in U} \frac{r_{ui} r_{uj}}{ \log (1 + N(u))}$$ IUF（Inverse User Frequence）

1. 热传导

冷门受益

热门受益

看除的分母，热门物品度大，冷门度小

调和

矩阵分解/隐语义模型LFM(latent factor model)

评分预测问题只是很典型，其实并不大众，毕竟在实际的应用中，评分数据很难收集到，属于典型的精英问题；与之相对的另一类问题行为预测，才是平民级推荐问题，处处可见。

近邻模型存在的问题：

1. 物品之间存在相关性，信息量并不随着向量维度增加而线性增加；
2. 矩阵元素稀疏，计算结果不稳定，增减一个向量维度，导致近邻结果差异很大的情况存在。

矩阵分解的目的分解评分矩阵A

推荐过程

$ p_u $ 用户向量，$ q_i $ 物品向量。

基本SVD

SVD（奇异值分解）的损失函数：

SVD学习过程

1. 准备好用户物品的评分矩阵，每一条评分数据看做一条训练样本；
2. 给分解后的 U 矩阵和 V 矩阵随机初始化元素值；
3. 用 U 和 V 计算预测后的分数；
4. 计算预测的分数和实际的分数误差；
5. 按照梯度下降的方向更新 U 和 V 中的元素值；
6. 重复步骤 3 到 5，直到达到停止条件。

增加偏置

分别为全局评分、物品偏置、用户偏置

偏置的计算为，当前评分-对应的平均分

对应的损失函数

增加隐式数据/历史行为

在 SVD 中结合用户的隐式反馈行为和属性，这套模型叫做 SVD++。

隐式反馈的加入方法：

除了假设评分矩阵中的物品有一个隐因子向量外，用户有过行为的物品集合也都有一个隐因子向量，维度是一样的。把用户操作过的物品隐因子向量加起来，用来表达用户的兴趣偏好。

类似的，用户属性，全都转换成 0-1 型的特征后，对每一个特征也假设都存在一个同样维度的隐因子向量，一个用户的所有属性对应的隐因子向量相加，也代表了他的一些偏好。

综合两者，SVD++ 的目标函数中，只需要把推荐分数预测部分稍作修改，原来的用户向量那部分增加了隐式反馈向量和用户属性向量：

加入时间因素

1. 对评分按照时间加权，让久远的评分更趋近平均值；
2. 对评分时间划分区间，不同的时间区间内分别学习出隐因子向量，使用时按照区间使用对应的隐因子向量来计算；
3. 对特殊的期间，如节日、周末等训练对应的隐因子向量。

损失函数优化方法

SGD V.S. ALS

ALS的思想就是固定一个优化另外一个，所以叫交替最小二乘。其好处：

1. 在交替的其中一步，也就是假设已知其中一个矩阵求解另一个时，要优化的参数是很容易并行化的；
2. 在不那么稀疏的数据集合上，交替最小二乘通常比随机梯度下降要更快地得到结果，事实上这一点就是我马上要说的，也就是关于隐式反馈的内容。

相比“预测用户会打多少分”，“预测用户会不会去浏览”更加有意义，而且，用户浏览数据远远多于打分评价数据。也就是说，实际上推荐系统关注的是预测行为，行为也就是一再强调的隐式反馈。

对隐式反馈的矩阵分解，需要将交替最小二乘做一些改进，改进后的算法叫做加权交替最小二乘：Weighted-ALS。

1. 如果用户对物品无隐式反馈则认为评分是 0；
2. 如果用户对物品有至少一次隐式反馈则认为评分是 1，次数作为该评分的置信度。