发表于   |   分类于

Bert 模型部署

最近在研究google的bert相关知识，使用fine-tune方法训练了一个模型，但是看效果比较麻烦，每次都要重新load模型导致效率非常低下。
因此，参考网上以及同事的思路，设计了一套通用的bert model查看效果的工具。

主要内容

  1. 如何产出模型文件？

    1
    2
    estimator._export_to_tpu = False
    estimator.export_savedmodel("./export/", serving_input_fn)

  2. 如何避免重复加载？

    我们通过graph建立了sess，启动一个web应用，将sess保存在内存中，请求来的时候，直接使用sess进行predict，export_dir 是模型的路径。

    1
    2
    3
    4
    from tensorflow.python.saved_model import tag_constants
    self.graph_predict = tf.Graph()
    self.sess = tf.Session(graph = self.graph_predict)
    tf.saved_model.loader.load(self.sess, [tag_constants.SERVING], export_dir)

  3. 如何结合web框架？

    本次使用的是flask，为什么要使用flask，因为tf使用的是python，使用flask的话，可以直接将sess的实例保存在内存中，每次请求来的时候进行预测。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
from predictor import Predictor
one_predictor = Predictor(args)

app = Flask(__name__)
@app.route('/')
def hello_world():
    return 'Hello World!'

@app.route('/test', methods=['GET', 'POST'])
def index():
    if request.method == 'POST':
        query = (request.form.get('se_query').strip())
        result = one_predictor.predict_query(query)
        return render_template('test.html', result)
    
if __name__ == '__main__':
    server = pywsgi.WSGIServer(('0.0.0.0', 8001), app)
    server.serve_forever()

总结

使用flask封装bert fine-tune后的模型，极大的提高了策略调研的效率，还是要多思考，多尝试，多看tf的api相关文档。

相关代码

  1. https://github.com/c00h00g/bert_app_serving

发表于   |   分类于

最近，在学习fasttext相关源码，这篇文章主要分享下学习监督学习相关的学习心得。

主要架构

  1. 输入：term级别词向量，比如输入“中国” “新” “说唱”三个term，每个词进入系统前都被随机初始化成了dim纬度的向量
  2. hidden : 将所有term的向量进行相加，然后求解平均值，组成短片段的向量表示
  3. 输出：label个向量, 即我们要分类的个数
  4. 对输出对值求softmax，loss函数使用crossEntroy loss

求解的参数

和传统lr的区别是：传统lr我们是知道特征的值的，只需要求解w的值；但是，这里我们词向量也是未知的，也是需要求解的, 因此需要求解的参数是以下两个：

  1. hidder layer和最终输出的矩阵权重w
  2. 每个单词的词向量

理论基础

  1. crossEntropy loss梯度

  2. 求解梯度
    当i == j时:

  3. 求解梯度
    当i != j时:

  4. 结合代码分析

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    real Model::softmax(int32_t target, real lr) {
      grad_.zero();
      computeOutputSoftmax();
      for (int32_t i = 0; i < osz_; i++) {
        //alpha就是loss对softmax之前变量梯度的计算
        //如果i == target, 梯度为output[i] - label
        //如果i != target, 梯度为output[i]
        //这儿用的label - ouput[i], 因为减去梯度，相当于加上负梯度
        real label = (i == target) ? 1.0 : 0.0;
        real alpha = lr * (label - output_[i]);
        grad_.addRow(*wo_, i, alpha);
        wo_->addRow(hidden_, i, alpha);
      }
      return -log(output_[target]);
    }

  5. 举例
    如果类别一共三维，经过softmax后的向量为[0.1, 0.3, 0.6], 第二维label为1，则loss对原始输入的梯度为[0.1, -0.7, 0.6], 可见需要在第二维上重点调整，以调到最大。

发表于   |   分类于

背景

在平常的工作中，我们经常要操作excel；但这不是程序猿的思维，程序员应该把excel当成程序可以操作的数据。

读写excel

对excel的操作主要是读取和写入操作，分别介绍下

读取数据

  1. 读取excel中的所有sheet

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    import xlrd

    def get_all_sheets_names(self):
        """
        读取excel里所有的sheet
        """
        self.sheet_names = dict()
        idx = 0
        rd = xlrd.open_workbook(self.excel_r_path)
        for one_name in rd.sheet_names():
            self.sheet_names[one_name] = idx
            idx += 1

        if DEBUG_SWITCH == 1:
            for key, value in self.sheet_names.items():
                print key, value
        return

  2. 读取其中一个sheet中的数据

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    def read_one_excel_data(self, index):
        """
        读取一个excel中的数据
        """
        one_sheet = self.rd.sheet_by_index(index)
        # 行数& 列数
        rows = one_sheet.nrows
        columns = one_sheet.ncols

        for i in range(rows):
            one_list = []
            for j in range(columns):
                one_elem = one_sheet.cell(i, j).value.encode('utf-8')
                one_list.append(one_elem)
            self.data.append(one_list)

        if DEBUG_SWITCH == 1:
            for row in self.data:
                for dt in row:
                    print dt,
                print

写入数据

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
def set_style(self, name, height, bold = False):
    """
    初始化样式, 字体等
    """
    style = xlwt.XFStyle()  # 初始化样式
    font = xlwt.Font()  # 为样式创建字体
    font.name = name # 'Times New Roman'
    font.bold = bold
    font.color_index = 4
    font.height = height
    style.font = font
    return style

def write_excel_sheet(self, sheet_name):
    """
    写excel
    """
    self.wt = self.wt_excel.add_sheet(sheet_name, cell_overwrite_ok = True) 
    write_data = [('a1', 'a2', 'a3'), ('b1', 'b2', 'b3'), ('c1', 'c2', 'c3')]
    heads = ['a', 'b', 'c']

    #写第几行
    line_num = 0

    #write head
    for i in range(len(heads)):
        self.wt.write(line_num, i, heads[i], self.set_style('Times New Roman', 220, True))
    line_num += 1

    #write cont
    for elem in write_data:
        for i in range(len(elem)):
            self.wt.write(line_num, i, elem[i], self.set_style('Times New Roman', 220))
        line_num += 1

    self.wt_excel.save(self.excel_w_path)
    return

做成web版本

只需要将数据加载起来，通过web框架展现出来

  1. 上传 & 展现

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    <form action="" enctype='multipart/form-data' method='POST'>
        <input type="file" name="file">
        <input type="submit" value="上传">
    </form>

    {% if data_row_num %}
    <table class="table table-bordered table-hover">
        <tbody>
        {% for i in range(data_row_num) %}
            <tr>
            {% for j in range(col_num) %}
                <td>
                    {{ data_csv[i][j] }}
                </td>
            {% endfor %}
            </tr>
        {% endfor %}
        </tbody>
    </table>
    {% endif %}

  2. 下载

    1
    2
    3
    4
    5
    <form action="" enctype='multipart/form-data' method='POST'>
        <input type="file" name="file">
        <input type="submit" value="upload", name="upload">
        <input type="submit" value="download", name="download">
    </form>

服务端

1
2
3
4
5
6
7
if request.form.get('upload') == 'upload':
    pass
elif request.form.get('download') == 'download':
    path = os.getcwd()
    #写入数据到chg.xls
    write_excel(path + '/chg.xls', data)
    return send_from_directory(path, 'chg.xls', as_attachment = True)

总结

我们既能操纵excel里的数据进行快速分析，也能通过网页的方式查看excel中的数据；更进一步，我们可以让用户提交处理数据的逻辑，将逻辑传递到后台，定制化数据输出

发表于   |   分类于

最近在研究fasttext源码，这篇文章主要分析一些非理论层面的c++的技巧。

编译方面

  1. 由于需要对多线程进行支持使用了-pthread参数
  2. -std=c++0x : C++11之前被称为C++0x，因为原本计划在2010年发布，所以之前一些编译器使用C++11的编译参数是：-std=c++0x，后面使用：-std=c++11

代码方面

  1. reserve 和 resize对区别？

    • reserve的作用是预留空间，不会创建对象，真正的数据填充需要使用push_back操作来进行。为什么要这样做？下面这个代码会导致capacity多次重新分配，去预申请内存，然后将原来地址上的所有元素拷贝到新地址上。因为vector在发现当前空间不够时，一般会把capacity进行翻倍，如果再次不够就再次翻倍, 这种效率是很低的。

      1
      2
      3
      4
      vector<int> v;
      for (int i = 0; i < 100; ++i) {
          v.push_back(i);
      }

    • resize是直接调整size，改变容器的大小，并且创建对象。如果new_size > old_size, 则在vector增加new_size - old_size默认构造出来的元素；反之，将多出的部分删掉，但不改变capacity。

  2. lambad表达式

    1
    2
    3
    4
    for (int32_t i = 0; i < args_->thread; i++) {
        //lambda表达式
        threads.push_back(std::thread([=]() { trainThread(i); }));
    }

    lambda表达式的定义如下：[capture list] (parameter list) -> return type { function body }
    其中capture_list的官方解释是：capture list is an (often empty) list of local variables defined in the enclosing function, 指的是lambda所在的函数中的局部变量
    parameter list 指的是函数的参数，return type指的是返回类型，function body指的是函数主题。
    那么，上面这段代码的意思是：lambda表达式所在函数中所有的局部变量为capture list，没有参数，没有返回值的函数。下面再举个例子说明下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    void test_equal(int c) {
        int a = 5;
        int b = 3;
        auto f2 = [=]() {return a + b + c;};
        cout << f2() << endl;
    }
    int main() {
        test_equal(5);
        return 0;
    }

    这段代码的输出是：5+3+5=13

  3. shared_ptr智能指针
    具体问题请参考这篇博客：https://www.cnblogs.com/heleifz/p/shared-principle-application.html

  4. 使用int32_t／int64_t
    为了程序的可移植性之后要这样使用, 我们在stdint.html(https://sites.uclouvain.be/SystInfo/usr/include/stdint.h.html)中可以看到long在64位机器上是8字节的，但在32位机器上是32字节的，long是会随着机器的不同而改变的，长度是不确定的，但是使用int32_t就能保证是32位的。

    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
    ifndef __int8_t_defined
    # define __int8_t_defined
    typedef signed char                int8_t;
    typedef short int                int16_t;
    typedef int                        int32_t;
    # if __WORDSIZE == 64
    typedef long int                int64_t;
    # else
    __extension__
    typedef long long int                int64_t;
    # endif
    #endif

    /* Unsigned.  */
    typedef unsigned char                uint8_t;
    typedef unsigned short int        uint16_t;
    #ifndef __uint32_t_defined
    typedef unsigned int                uint32_t;
    # define __uint32_t_defined
    #endif
    #if __WORDSIZE == 64
    typedef unsigned long int        uint64_t;
    #else
    __extension__
    typedef unsigned long long int        uint64_t;
    #endif
    1. utf-8编码边界在线检测
      参考下阮一峰的这篇博客：
      http://www.ruanyifeng.com/blog/2007/10/ascii_unicode_and_utf-8.html
      如果一个字符的前两个字节是10的话，那么utf-8完整字符一定还没有结束
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      void Dictionary::computeSubwords(const std::string& word,
                      std::vector<int32_t>& ngrams) const {
           for (size_t i = 0; i < word.size(); i++) {
                std::string ngram;
                if ((word[i] & 0xC0) == 0x80) continue;
                for (size_t j = i, n = 1; j < word.size() && n <= args_->maxn; n++) {
                    ngram.push_back(word[j++]);
                    while (j < word.size() && (word[j] & 0xC0) == 0x80) {
                        ngram.push_back(word[j++]);
                    }
                    if (n >= args_->minn && !(n == 1 && (i == 0 || j == word.size()))) {
                        int32_t h = hash(ngram) % args_->bucket;
                        pushHash(ngrams, h);
                    }
                }
           }
      }

发表于   |   分类于

背景

点赞点踩是互联网上收集用户反馈的一个非常重要的手段，这些后验特征对于结果的排序是非常有用的；但是，我们经常会遇到这样的问题，
一个结果有5条1分的评价, 0条0分的评价，一个结果有480个1分的评价，20个0分的评价，如果直接按照good / all来算，第一个结果是1.0，第二个结果
是4.8；可是显然，第二条结果是大概率好于第一条结果的。由此，我们引入威尔逊区间的概念。

实现代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
from math import sqrt

def confidence(ups, downs, z):
    """
    ups : 赞成
    downs : 不赞成
    z :  统计量，95%的置信水平，统计量值为1.96，可以通过查表实现
    """
    n = ups + downs
    if n == 0:
    return 0
    p = float(ups) / n
    return ((p + z*z/(2*n) - z * sqrt((p*(1-p)+z*z/(4*n))/n))/(1+z*z/n))


if __name__ == '__main__':
    print confidence(5, 0, 1.96)
    print confidence(50, 10, 1.96)
    print confidence(500, 100, 1.96)
    print confidence(5000, 1000, 1.96)

输出结果:

1
2
3
4
0.565508505248
0.719681485028
0.801411699243
0.823690598226

总结

涉及到所有比例置信度的问题都可以用威尔逊区间来优化

参考

  1. http://www.ruanyifeng.com/blog/2012/03/ranking_algorithm_wilson_score_interval.html
  2. https://stackoverflow.com/questions/10029588/python-implementation-of-the-wilson-score-interval
k