算法花园

ImageNet Classiﬁcation with Deep Convolutional Neural Networks(AlexNet)

2019-05-18T00:00:00+00:00

[TOC]

作者以及相关性

Alex Krizhevsky
Ilya Sutskever
Geoffrey E. Hinton
本文被认为是这一轮深度学习浪潮的开端

主题

将 CNN 技术最先应用到图像识别领域，利用 CNN 参数共享的特性，减少网络的规模
解决深度网络难训练（速度慢）以及容易过拟合问题（更多数据或者网络技巧）

数据集与指标

ImageNet LSVRC-2010 contest: 图片 1000 分类
top-1 和 top-5 错误率为指标

模型/实验/结论

模型

由于当时的 GPU 显存限制，无法将所有的数据加载到单独 GPU 中，作者使用两个 GPU 并行训练。
整个模型如下图所示，由 5 个卷积层以及 3 个全连接层组成。其中在 CONV3、FC1、FC2、FC3 层进行两个 GPU 的数据交互。
- [227, 227, 3] INPUT: 原始论文中 224 为笔误。
- [55, 55, 96] CONV1: (11*11*3,96) filters, Stride 4, pad 0
- [27, 27, 96] MAX POOL1: (3*3) filters, Stride 2
- [27, 27, 96] NORM1: Normalization layer
- [27, 27, 256] CONV2: (5*5,256) filters, Stride 1, pad 2
- [13, 13, 256] MAX POOL2: (3*3) filters, Stride 2
- [13, 13, 256] NORM2: Normalization layer
- [13, 13, 384] CONV3: (3*3,384) filters, Stride 1, pad 1
- [13, 13, 384] CONV4: (3*3,384) filters, Stride 1, pad 1
- [13, 13, 384] CONV5: (3*3,256) filters, Stride 1, pad 1
- [6, 6, 256] MAX POOL3: (3*3) filters, Stride 2
- [4096] FC1: 两个 GPU 中的 CONV 层结果进行全连接
- [4096] FC2: FC1 进行全连接
- [1000] FC3: FC2 进行全连接，最后输出分类结果
参数数量 60 million

使用 ReLU 作为激活函数：比 tanh 计算开销小，以及收敛速度快。根据问题的特点选择激活函数（大模型、大数据集）
Local Response Normalization(Norm Layers)：局部响应归一化层，后来很少使用。在经过 ReLU 作用之后，对相同空间位置上（${b_{x,y}}$）的相邻深度（${b^j}$ ）的卷积结果做归一化。n 指定相邻卷积核数目，N 为该层所有卷积的数目。${k, n, \alpha, \beta}$ 都是超参数。本文使用 ${k=2, n=5, \alpha=10^{-4}, \beta = 0.75}$, 分别降低 top-1 和 top-5 错误 1.4% 和 1.2%

$b_{x, y}^{i}=a_{x, y}^{i} /\left(k+\alpha \sum_{j=\max (0, i-n / 2)}^{\min (N-1, i+n / 2)}\left(a_{x, y}^{j}\right)^{2}\right)^{\beta}$

Pooling：s=2 < z=3，有部分重叠，作者通过实验发现这种方法可以更好地避免过拟合。
data augmentation：
- 对图像进行裁剪以及翻转，扩大数据。这种策略对测试带来影响，测试时裁剪出图片四个角落以及中间部分，得到 5 张图片，另外翻转得到 5 张图片，最后分类结果又这 10 图片的平均得分确定。
- 利用 PCA 改变 RGB 通道的强度。
Dropout：每次训练的时候，从模型中 sample 出一个小的模型，减少过拟合。

实验

参数：dropout 0.5，batch size 128， SGD Momentum 0.9， Learning rate 1e-2 reduce by 10，L2 weight decay 5e-4
测试集上结果
取出 CONV1 相关的 filters卷积侧重点不同，GPU1 颜色无关，GPU2 颜色相关。多次实验发现都存在这种现象，说明使用多个 GPU 训练是必要的，模型可以捕捉更多信息。
取所有最后一个隐层向量，找到与测试图片欧拉距离最小的训练图片（下图中第一列为测试图片，之后几列是欧拉距离最小的训练集中图片）。肉眼可以发现，同一分类的图片有很大关联性。证明模型能学习图片之间的关系。

结论

通过移除 AlexNet 网络中的某几层发现错误率均有提高，这个网络时必要以及有效的。
文章中作者通过大量的实验确定模型的细节问题，值得我们学习。
当时的 GPU 限制作者的想象力……

决策树

2018-10-28T00:00:00+00:00

之前听过决策树的名字，以为只是暴力判断。通过这一章的学习，了解到决策树是从数据中提取规则，然后对数据进行分类。所以，决策树在构建中理解了数据中所蕴含的知识信息。

3.1 决策树的构建

本文构建的决策树使用 ID3 算法。决策树每一次决策都遵循一个原则：将无序的数据变得更加有序。所以，使用信息论中的熵（entropy）来度量信息。简单来说，系统越有序，熵越低。在数据划分的过程中产生的变化称为信息增益。

根据公式 ${H=-\sum_{i=1}^{n}{p(x_i)}log_2 p(x_i)}$ 计算信息期望值，其中 ${p(x_i)}$ 是选择某一个分类的概率。dataset 是一个 ${n*m}$ 维向量，代表输入的数据。

def calc_shannon_ent(dataset):
    numentries = len(dataset)
    labelcounts = {}
    for featvec in dataset:
        currentlabel = featvec[-1]
        if currentlabel not in labelcounts.keys():
            labelcounts[currentlabel] = 0
        labelcounts[currentlabel] += 1  # 统计标签的种类以及数量
    shannonent = 0.0
    for key in labelcounts:
        prob = float(labelcounts[key])/numentries
        shannonent -= prob * log(prob, 2)  # 计算熵
    return shannonent

划分数据集：构建决策树过程中，删除输入数据的某一列值时使用。

def split_dataset(dataset, axis, value):
    retdataset = []  # 划分之后的子集
    for data in dataset:
        if data[axis] == value:
            reducefeatvec = data[:axis]  # 去除 axis 相关的特征
            reducefeatvec.extend(data[axis+1:])
            retdataset.append(reducefeatvec)
    return retdataset

决策过程：枚举每一种划分方案，并计算之后的信息增益，选择信息熵最小（越有序）的一种方案，并返回这个特征名。信息增益是熵减少的或者是数据无序度的减少。

def choose_best_feature_to_split(dataset):
    numfeatures = len(dataset[0]) - 1  # 每一条数据的特征数，最后一个为标签
    baseentropy = calc_shannon_ent(dataset)  # 计算初始数据中的熵
    bestinfogain = 0.0
    bestfeature = -1
    for idx in range(numfeatures):
        featlist = [data[idx] for data in dataset]  # 列表推导，计算出某个特征的全部值范围，并在下一步去重
        uniquevals = set(featlist)
        newentropy = 0.0
        for value in uniquevals:
            subdataset = split_dataset(dataset, idx, value)
            prob = len(subdataset)/float(len(dataset))
            newentropy += prob * calc_shannon_ent(subdataset)
        infogain = baseentropy - newentropy
        # print baseentropy, newentropy
        if (infogain > bestinfogain):
            bestinfogain = infogain
            bestfeature = idx
    return bestfeature

构建决策树：利用递归调用构建，直到程序遍历完数据集的所有属性，或者每个分支下面的所有实例都具有相同的分类。

当所有属性都被遍历，但是某一个分支下面的数据标签不完全一样，采用多数表决的方法决定该叶子节点的分类。

def majoritycnt(classlist):
    classcount = {}
    for vote in classlist:
        if vote not in classcount.keys():
            classcount[vote] = 0
        classcount[vote] += 1
    sortedclasscount = sorted(classcount.iteritems(), key=operator.itemgetter(1), reverse=True)
    return sortedclasscount[0][0]

递归调用，利用 dict 来存储树

def create_tree(dataset, labels):
    classlist = [example[-1] for example in dataset]  # 统计数据集中的标签信息
    if classlist.count(classlist[0]) == len(dataset):  # 结束递归条件：数据集中的标签全部相同，或者数据集中只剩下一个数据
        return classlist[0]
    if len(dataset[0]) == 1:
        return majoritycnt(classlist)
    bestfeature = choose_best_feature_to_split(dataset)  # 选择分类的标签
    bestfeaturelabel = labels[bestfeature]
    mytree = {bestfeaturelabel: {}}  # 利用mytree保存结果
    del(labels[bestfeature])
    featvalues = [example[bestfeature] for example in dataset]
    unqiuevals = set(featvalues)
    for value in unqiuevals:  # 利用特征的取值范围划分本层
        sublabels = labels[:]
        mytree[bestfeaturelabel][value] = create_tree(split_dataset(dataset, bestfeature, value), sublabels)
    return mytree

3.2 L用 Matplotlib 画图

有点复杂，自我感觉和后面的关系不是很大，所以只是写了一下简单部分的代码。这里面的有一个技巧是利用 type() 函数判断对象是不是 dict，以此来确定是否是决策树的底层。

# -*- coding:utf-8 -*-
# author: xiang578
# email: i@xiang578
# blog: www.xiang578.com


import matplotlib.pyplot as plt


# 定义画图相关的属性
decisonnode = dict(boxstyle="sawtooth", fc='0.8')
leafnode = dict(boxstyle='round4', fc='0.8')
arrow_args = dict(arrowstyle='<-')


def plot_node(nodetext, centerpt, parentpt, nodetype):
    create_plot.ax1.annotate(nodetext, xy=parentpt, xycoords='axes fraction', xytext=centerpt,
                             textcoords='axes fraction',
                             va="center", ha="center", bbox=nodetype, arrowprops=arrow_args)


def create_plot():
    fig = plt.figure(1, facecolor='white')
    fig.clf()
    create_plot.ax1 = plt.subplot(111, frameon=False)  # 定义一个函数的属性，属于全局变量
    plot_node('decisonnode', (0.5, 0.1), (0.1, 0.5), decisonnode)
    plot_node('leafnode', (0.8, 0.1), (0.3, 0.8), leafnode)
    plt.show()


def test_create_plot():
    create_plot()


def retrieve_tree(i):
    istoftrees = [{'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}},
                  {'no surfacing': {0: 'no', 1: {'flippers': {0: {'head': {0: 'no', 1: 'yes'}}, 1: 'no'}}}}
                  ]
    return istoftrees[i]


def get_num_leafs(mytree):
    numleafs = 0
    firststr = mytree.keys()[0]
    seconddict = mytree[firststr]
    for key in seconddict.keys():
        if type(seconddict[key]).__name__ == 'dict':
            numleafs += get_num_leafs(seconddict[key])
        else:
            numleafs += 1
    return numleafs


def get_tree_depth(mytree):
    maxdepth = 0
    firststr = mytree.keys()[0]
    seconddict = mytree[firststr]
    for key in seconddict.keys():
        if type(seconddict[key]).__name__ == 'dict':
            thisdepth = 1 + get_tree_depth(seconddict[key])
        else:
            thisdepth = 1
        if thisdepth > maxdepth:
            maxdepth = thisdepth
    return maxdepth


def test_get():
    my_tree = retrieve_tree(0)
    print my_tree
    print get_tree_depth(my_tree)
    print get_num_leafs(my_tree)


if __name__ == '__main__':
    # test_create_plot()
    test_get()

3.3 测试和存储分类器

利用决策树分类，沿着构造好的决策树一直往下递归，直到遇到的节点数据类型不是 dict 。

def classify(inputtree, featlabels, testvec):
    firststr = inputtree.keys()[0]
    seconddict = inputtree[firststr]
    # print firststr, featlabels
    idx = featlabels.index(firststr)
    key = testvec[idx]
    if type(seconddict[key]).__name__ == 'dict':
        label = classify(seconddict[key], featlabels, testvec)
    else:
        label = seconddict[key]
    return label

利用 Python 模块中的 pickle 序列化对象，实现决策树的可持久化。

def store_tree(inputtree, filename):
    import pickle
    fw = open(filename, 'w')
    pickle.dump(inputtree,fw)
    fw.close()


def grab_tree(filename):
    import pickle
    fr = open(filename)
    return pickle.load(fr)


def t_pickle():
    mydat, labels = creat_dataset()
    mytree = create_tree(mydat, labels)
    store_tree(mytree, 'clasaifyierStorage.txt')
    print grab_tree('clasaifyierStorage.txt')

3.4 使用决策树预测隐形眼镜类型

跟上面提到的鱼分类类似，关键是从 txt 中读取数据，然后调用分类的算法。书中也没有提供其他过多的测试数据。

def t_Lenses():
    fr = open('lenses.txt')
    lenses = []
    for inst in fr.readlines():
        line = inst.strip()
        tmp = inst.strip().split('\t')
        lenses.append(tmp)
    # lenses = [inst.strip('\n').split('\t') for inst in fr.readline()]
    # print lenses
    lenseslabels = ['age', 'prescript', 'astigmatic', 'tearrate']
    lensestree = create_tree(lenses, lenseslabels)
    print lensestree

参考

MachineLearning/3.决策树.md at master · apachecn/MachineLearning

《机器学习实战》第 2 章 k-近邻算法（knn）

2018-10-21T00:00:00+00:00

2.1 k-近邻算法概述

对于输入数据，通过统计与它距离最近的 k 个数据的标签，选择出现次数最多的分类，成为它的分类。

2.1.1 准备：使用 Python 导入数据

需要引入 Python 中的 numpy 以及 operator 包。

from numpy import *
import numpy as np
import operator

def createdataset():
    group = array([[1.0, 1.1], [1.0, 1.0], [0, 0], [0, 0.1]])
    labels = ['A', 'A', 'B', 'B']
    return group, labels

2.1.2 实施 kNN 分类算法

kNN 算法处理未知类别的数据集中的点的流程：

计算已知类别的点与未知类别的点之前的距离（可以利用欧拉公式）；
将上一步计算得到距离从小到大排序；
选出距离最小的前 k 个点；
统计出这 k 个点对于的类别总数以及次数；
选择上一步中出现次数最多的类别作为当前点的类别。

根据之前课程学习的经验，编程实现过程中尽量要做到计算向量化。

def classify0(inx, dataset, labels, k):
    datasetsize = dataset.shape[0]
    diffmat = tile(inx, (datasetsize, 1)) - dataset  # tile([1,2],(3,2))==>[[1, 2, 1, 2], [1, 2, 1, 2], [1, 2, 1, 2]]
    sqdiffmat = diffmat**2
    sqdistances = sqdiffmat.sum(axis=1)
    distances = sqdistances**0.5  # 计算和已知数据的距离
    sorteddistindicies = distances.argsort()  # 将元素从小到大排序，返回索引的序列
    classcount = {}  # 记录结果
    for i in range(k):
        voteilabel = labels[sorteddistindicies[i]]
        classcount[voteilabel] = classcount.get(voteilabel, 0) + 1  # get(key, default) 返回value，不存在时返回 default
    sortedclasscount = sorted(classcount.iteritems(), key=operator.itemgetter(1), reverse=True)  # 取 value 值排序
    return sortedclasscount[0][0]

2.2 使用 k-近邻算法改进约会网站的配对效果

打开作者提供的数据文件 datingTestSet2.txt，我们可以发现其对应的数据格式如下：

每一行都是一条记录
第一列：每年获得的飞行常客里程数
第二列：玩视频游戏所耗时间百分比
第三列：每周消费的冰淇凌公升数
第四列：标签

8.326976	0.953952	3
7.153469	1.673904	2
1.441871	0.805124	1
13.147394	0.428964	1
1.669788	0.134296	1
10.141740	1.032955	1
6.830792	1.213192	3
13.276369	0.543880	3
8.631577	0.749278	1

所以，我们首先要将数据以矩阵的方式读入。其中，我们将最后一项当成是分类。

def file2matrix(filename):
    fr = open(filename)
    arrayoflines = fr.readlines()
    numberoflines = len(arrayoflines)
    returnmat = zeros((numberoflines, 3))
    classlabelvalue = []
    index = 0
    for line in arrayoflines:
        line = line.strip()
        listfromline = line.split('\t')
        returnmat[index, :] = listfromline[0:3]
        classlabelvalue.append(int(listfromline[-1]))  # 转化成为int
        index = index + 1
    return returnmat, classlabelvalue

书本中，为了更直观的了解数据，还使用 Matplotlib 库进行画图，这里不继续介绍。

2.2.3 归一化数值

由于不同的数据取值的范围不同，为了减少某些值特别大或者特别小的影响，我们需要采取数值归一化，将取值范围减少到 0 到 1 之间。比如采用 ${newValue = (oldValue-min)/(max-min)}$。

def autonorm(dataset):
    minvals = dataset.min(0)
    maxvals = dataset.max(0)
    ranges = maxvals - minvals
    normdataset = zeros(shape(dataset))
    m = dataset.shape[0]
    normdataset = dataset - tile(minvals, (m, 1))
    normdataset = normdataset/tile(ranges, (m, 1))
    return normdataset, ranges, minvals

2.2.4 测试算法

注意：输入数据验证时，也应该使用上一步的均值进行归一化。

def classfyperson():
  resultlist = ['not at all', 'is small doses', 'in large doses']
  percenttats = float(raw_input("percentage of time spent playing video games ?"))
  ffmiles = float(raw_input("frequent filer miles earned per year?"))
  icecream = float(raw_input("liters of ice cream consumed per year?"))
  datingdatamat, datinglabels = file2matrix('datingTestSet2.txt')
  normmat, ranges, minvals = autonorm(datingdatamat)  # 归一化数值
  inarr = array([ffmiles, percenttats, icecream])
  classfypersonresult = classify0((inarr-minvals)/ranges, normmat, datinglabels, 3)
  print "You will probably like this person: ", resultlist[classfypersonresult - 1]

2.3 手写识别系统

利用函数将 32*32 的二进制图像转换为一个向量。

def img2vector(filename):
    returnvec = zeros((1, 1024))
    fr = open(filename)
    for i in range(32):
        linestr = fr.readline()
        for j in range(32):
            returnvec[0, 32*i+j] = int(linestr[j])
    return returnvec

利用 listdir 函数，处理从目录中批量读取文件名，之后再进行文件内容的读取。

def handwritingclasstest():
    hwlabels = []
    trainingfilelist = listdir('digits/trainingDigits')
    m = len(trainingfilelist)
    trainingmat = zeros((m, 1024))
    for i in range(m):
        filenamestr = trainingfilelist[i]
        filestr = filenamestr.split('.')[0]
        classnumstr = int(filestr.split('_')[0])
        hwlabels.append(classnumstr)
        trainingmat[i, :] = img2vector('digits/trainingDigits/%s' % filenamestr)
    testfilelist = listdir('digits/testDigits')
    mtest = len(testfilelist)
    errorcount = 0.0
    for i in range(mtest):
        testfilenamestr = testfilelist[i]
        testfilestr = testfilenamestr.split('.')[0]
        testclassnumstr = int(testfilestr.split('_')[0])
        testvect = img2vector('digits/testDigits/%s' % testfilenamestr)
        result = classify0(testvect, trainingmat, hwlabels, 3)
        if (testclassnumstr != result):
            errorcount += 1
        print 'the classifier came back with: %d, the real number is: %d.\n' % (result, testclassnumstr)
    print 'the total error is %d, the total error rate is: %f\n' % (errorcount, errorcount/float(mtest))

2.4 本章小结

该方法最简单且有效；
在使用该算法时，需要保存所有的训练数据，以及遍历测试数据与训练数据之间的关系。耗时长，空间大；
无法给出数据集的基础结构信息。

深入浅出之 Factorization Machines

2018-10-02T00:00:00+00:00

Factorization Machines 由日本 Osaka University 的 Steffen Rendle [1] 在 2010 年提出。FM 是一种常用的因子机模型

FM

电影评分

【数据图】

$\hat y:= w_0 + \sum_{i=1}^{n} w_ix_i + \sum_{i=1}^n \sum_{j=i+1}^n \left \langle v_i,v_j \right \rangle x_iy_i$ $W_{i,j}=\left \langle v_i,v_j \right \rangle = \sum_{f=1}^kv_{i,f} \cdot v_{j,f}$ $\sum_{i=1}^n \sum_{j=i+1}^n \left \langle v_i,v_j \right \rangle x_iy_i = \frac{1}{2}\sum^k_{f=1} \left( \left(\sum_{i=1}^nv_{i,f}x_i \right)^2 - \sum^n_{i=1} v^2_{i,f} x_i^2 \right)$

$\frac{\partial}{\partial \theta} \hat y \left( x \right) = \begin{cases} 1, & \text{ if $\theta$ is $w_0$} \\ x_i, & \text{ if $\theta$ is ${w_i}$} \\ x_i\sum^n_{j=1} v_{j,f}x_j - v_{i,f}x_i^2, &\text{if $\theta$ is ${v_{i,f}}$} \end{cases}$ $$

FM vs SVM

对于经典的特征组合问题，不难想到使用 SVM 求解。Steffen 在论文中也多次将 FM 和 SVM 做对比。

一个二阶

最后总结一下，FM 相比于 SVM 有下面三个特点： 1. SVM 中虽然也有特征交叉项，但是只能在样本中含有相对应的特征交叉数据时才能学习。但是 FM 能在数据稀疏的时候学习到交叉项的参数。 2. SVM 问题无法直接，常用的方法是根据拉格朗日对偶性将原始问题转化为对偶问题。 3. 在使用模型预测时，SVM 依赖部分训练数据（支持向量），FM 模型则没有这种依赖。

NFM

在工业界，实际上大部分需要处理的问题都是非线性，前文介绍的 FM 模型很难学习特征之间的高阶隐藏关系。Neural Factorization Machines 正是在这样的背景下诞生的，它的结构如下： $\hat { y } _ { N F M } ( \mathbf { x } ) = w _ { 0 } + \sum _ { i = 1 } ^ { n } w _ { i } x _ { i } + f ( \mathbf { x } )$

其中第一项和第二项是线性回归，第三项是神经网络。神经网络中利用 FM 模型的二阶特征交叉结果做为输入，学习数据之间的高阶特征。与直接利用高阶 FM 模型相比，可以降低模型的训练复杂度，加快训练速度。

模型的神经网络部分包含 4 层，分别是 Embedding Layer、Bi-Interaction Layer、Hidden Layers、Prediction Score。

Embedding Layer 层对输入的稀疏数据进行 Embedding 操作。一般来说最常见的 Embedding 是在一张权值表中进行 lookup 操作，论文中作者强调他们这一步操作需要处理带权重的向量。
Bi-Interaction Layer 层是这篇论文的创新，这一层将 Embedding vector 转换成为只有 k 维的单独向量。
Hidden Layers 层是一个常规的 DNN

Reference

Rendle, Steffen. “Factorization Machines,” 995–1000, IEEE, 2010. doi:10.1109/icdm.2010.127.
深入浅出Factorization Machines系列
因子机深入解析

利用 jekyll 搭建博客

2018-10-02T00:00:00+00:00

起

最近几个月，刚刚告别校园。在工作中遇到一些挑战，需要自己去学习一大堆的知识，所以准备在博客上记录一下。不过之前的 hexo 博客原生不支持数学公式，按网上的方法加插件也没有成功。所以直接利用 jekyll 搭建一个新的博客。

新博客取名为“算法花园”，看起来颇有几分自大。并且从目前的文章数量来看，最多称得上是“算法荒地”，也不知道自己有多少的时间来给这一片荒地开荒。希望你下次再过来时，这里除了野草还有几朵野花。

搭建

Github repo 原生支持 jeklly 博客，搭建本地环境没有太大的必要。所以喜欢哪个博客主题，直接 fork 到自己的仓库，然后将 _config.yml 中的一些字段修改成与你的信息对应，新的博客就差不多完成了。

配置域名需要在仓库创建一个 CNAME 文件，然后将需要的域名写入。之后将对应的域名解析到 username.github.io 即可。

Gitalk

主题中自带 disqus 评论框架，不过为了博客的可持续发展，还是决定使用基于 Github Issues 作为评论数据的载体。目前有两种方案，Gitalk 和 gitment。这两种我都尝试了一下，不过 gitment 目前在页面登录时会出现错误，所以直接选用 Gitalk。这个框架的引入也十分的简单，下面简单介绍一下。

申请 github OAuth

登录 Github 后，选择 Settings - Developer settings - OAuth Apps ，点击 New OAuth App，填写下面这样的表单。除了 Authorization callback URL 需要填写你的博客地址，其他都可以随意填写。

点击 Register application 后，会生成下图所示的配置文件。其中 Client ID 和 Client Secret 会在下一步中使用。

修改 jekyll

直接修改文章页面的样式，我使用的主题 post 样式保存在 _layouts/post.html。

在这个文件中添加 Gitalk 使用的 css 和 js 文件：

<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/gitalk@1/dist/gitalk.css">
<script src="https://cdn.jsdelivr.net/npm/gitalk@1/dist/gitalk.min.js"></script>

添加 Gitalk 的评论框：

<div id='gitalk-container'></div>
<script>
const gitalk = new Gitalk({
  clientID: 'clientID',
  clientSecret: 'clientSecret',
  repo: 'repo',
  owner: 'owner',
  admin: ['admin'],
  id: '{ {} }',
  distractionFreeMode: false  // Facebook-like distraction free mode
})

gitalk.render('gitalk-container')
</script>

其中 clientID 和 clientSecret 由上一步申请 OAuth Apps 时生成，直接复制过来使用。repo 指定将评论相关的 Issues 创建在哪个仓库，一般选择你保存 jeklly 文件的仓库。owner 指定 repo 的主人，一般就是你自己的 Github 用户名。admin 可以初始化文章评论的用户。id 指定是某篇文章的评论在 Issues 中的标题，使用 page.title 可以将文章的标题当成是 Issues 的标题。（注：上面的代码中 id 对应的值为 '{ {} }'，你在复制的时候需要在 { {} } 中间添加 page.title，并且删除空格。我这样处理是因为将替换后的结果写在文章中，会被 jekyll 渲染成这篇文章的标题而无法正确显示。）

完成以上这两步，每篇文章下方都会生成一个评论框。

对应的 Github repo 的 Issues 中也会有一个 issue。

To do

文章的 toc 功能无法使用
数学公式参考
阅读数量
文章的 url 格式