pytorch0.4支持了Windows系统的开发，在首页即可使用pip安装pytorch和torchvision。
说白了，以下文字就是来自官方文档60分钟入门的简要翻译.

pytorch是啥

python的科学计算库，使得NumPy可用于GPU计算，并提供了一个深度学习平台使得灵活性和速度最大化

入门

Tensors(张量)

Tensors与NumPy的ndarrays类似，另外可以使用GPU加速计算

未初始化的5*3的矩阵:x = torch.empty(5, 3)
随机初始化的矩阵:x = torch.rand(5, 3)
全零矩阵,定义数据类型:x = torch.zeros(5, 3, dtype=torch.long)
由数据构造矩阵:x = torch.tensor([5.5, 3])
由已存在张量构造矩阵，性质与之前张量一致:

1
2

x = x.new_ones(5, 3, dtype=torch.double) 
x = torch.randn_like(x, dtype=torch.float)

获取维度:print(x.size())

Operations

有多种operation的格式，这里考虑加法

1.

1
2

y = torch.rand(5, 3)
print(x + y)

2.

1

print(torch.add(x, y))

3.

1
2
3

result = torch.empty(5, 3)
torch.add(x, y, out=result)
print(result)

4.

1
2
3

# adds x to y
y.add_(x)
print(y)

operations中需要改变张量本身的值，可以在operation后加,比如`x.copy(y), x.t_()`

索引:print(x[:, 1])
改变维度:x.view(-1, 8)

和Numpy的联系

torch tensor 和 numpy array之间可以进行相互转换，他们会共享内存位置，改变一个，另一个会跟着改变。

tensor to array

1
2
3
4

a = torch.ones(5)
b = a.numpy()
a.add_(1)
print(a,b)

array to tensor

1
2
3
4
5
6

import numpy as np
a = np.ones(5)
b = torch.from_numpy(a)
np.add(a, 1, out=a)
print(a)
print(b)

CUDA Tensors

tensor可以使用.to方法将其移动到任何设备。

1
2
3
4
5
6
7
8
9

# let us run this cell only if CUDA is available
# We will use ``torch.device`` objects to move tensors in and out of GPU
if torch.cuda.is_available():
    device = torch.device("cuda")          # a CUDA device object
    y = torch.ones_like(x, device=device)  # directly create a tensor on GPU
    x = x.to(device)                       # or just use strings ``.to("cuda")``
    z = x + y
    print(z)
    print(z.to("cpu", torch.double))       # ``.to`` can also change dtype together!

Autograd(自动求导)

pytorch神经网络的核心模块就是autograd，autograd模块对Tensors上的所有operations提供了自动求导。

Tensor

torch.Tensor是模块中的核心类，如果设置属性.requires_grad = True,开始追踪张量上的所有节点操作，指定其是否计算梯度。使用.backward()方法进行所有梯度的自动求导，张量的梯度会累积到.grad属性中。
.detach()停止张量的追踪，从梯度计算中分离出来；另外在评估模型时一般使用代码块with torch.no_grad():,因为模型中通常训练的参数也会有.requires_grad = True,这样写可以停止全部张量的梯度更新。
Function类是autograd的变体，Tensor和Function相互交错构建成无环图，编码了完整的计算过程，每个Variable(变量)都有.grad_fn属性，引用一个已经创建了的Tensor的Function.
如上，使用.backward()计算梯度。如果张量是一个标量(只有一个元素),不需要对.backward()指定参数；如果张量不止一个元素，需要指定.backward()的参数，其匹配张量的维度。

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

import torch
x = torch.ones(2, 2, requires_grad=True)
print(x)
y = x + 2
print(y)
print(y.grad_fn)
z = y * y * 3
out = z.mean()
print(z, out)

a = torch.randn(2, 2)
a = ((a * 3) / (a - 1))
print(a.requires_grad)
a.requires_grad_(True) # 改变a张量内在的属性
print(a.requires_grad)
b = (a * a).sum()
print(b.grad_fn)

Gradients

反向传播时，由于out是一个标量，out.backward()等效于out.backward(torch.tensor(1))

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

out.backward()
print(x.grad)

x = torch.randn(3, requires_grad=True)

y = x * 2
while y.data.norm() < 1000:
    y = y * 2

print(y)

gradients = torch.tensor([0.1, 1.0, 0.0001], dtype=torch.float)
y.backward(gradients)

print(x.grad)

print(x.requires_grad)
print((x ** 2).requires_grad)

with torch.no_grad():
    print((x ** 2).requires_grad)

神经网络

神经网络可以用torch.nn构建。nn依赖于autograd定义模型和求导，nn.Module定义网络层，方法forward(input)返回网络输出。

举例说明，如下是对数字图片分类的卷积网络架构。

这是一个简单的前馈神经网络，将输入数据依次通过几层网络层后最终得到输出。
神经网络典型的训练步骤如下：

• 定义神经网络及学习的参数(权重)
• 迭代输入数据
• 将输入数据输入到网络结构中
• 计算代价函数
• 误差向后传播
• 更新网络权重 weight = weight - learning_rate * gradient

定义网络

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

import torch
import torch.nn as nn
import torch.nn.functional as F


class Net(nn.Module):

    def __init__(self):
        super(Net, self).__init__()
        # 1 input image channel, 6 output channels, 5x5 square convolution
        # kernel
        self.conv1 = nn.Conv2d(1, 6, 5)
        self.conv2 = nn.Conv2d(6, 16, 5)
        # an affine operation: y = Wx + b
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        # Max pooling over a (2, 2) window
        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
        # If the size is a square you can only specify a single number
        x = F.max_pool2d(F.relu(self.conv2(x)), 2)
        x = x.view(-1, self.num_flat_features(x))
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

    def num_flat_features(self, x):
        size = x.size()[1:]  # all dimensions except the batch dimension
        num_features = 1
        for s in size:
            num_features *= s
        return num_features


net = Net()
print(net)

out:

1
2
3
4
5
6
7

Net(
  (conv1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1))
  (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
  (fc1): Linear(in_features=400, out_features=120, bias=True)
  (fc2): Linear(in_features=120, out_features=84, bias=True)
  (fc3): Linear(in_features=84, out_features=10, bias=True)
)

可以仅定义forward()函数，当使用autograd时backward()被自动定义。可以在forward()函数中使用任何operation操作。
net.parameters()返回模型中的可学习参数。

1
2
3

params = list(net.parameters())
print(len(params))
print(params[0].size())  # conv1's .weight

使所有参数的梯度归零然后开始计算梯度

1
2

net.zero_grad()
out.backward(torch.randn(1, 10))

代价函数

代价函数将(output,target)作为输入，计算output与target之间的距离。
nn模块中有几种不同的代价函数选择，最简单的是nn.MSELoss，计算均方误差
eg：

1
2
3
4
5
6
7

output = net(input)
target = torch.arange(1, 11)  # a dummy target, for example
target = target.view(1, -1)  # make it the same shape as output
criterion = nn.MSELoss()

loss = criterion(output, target)
print(loss)

按照向后传播的方向传播loss，使用grad_fn可以查看整个流程的计算图

1
2
3
4

input -> conv2d -> relu -> maxpool2d -> conv2d -> relu -> maxpool2d
      -> view -> linear -> relu -> linear -> relu -> linear
      -> MSELoss
      -> loss

使用loss.backward()，流程中所有requres_grad=True的张量累积它的梯度至.grad

1
2
3

print(loss.grad_fn)  # MSELoss
print(loss.grad_fn.next_functions[0][0])  # Linear
print(loss.grad_fn.next_functions[0][0].next_functions[0][0])  # ReLU

向后传播

loss.backward()传播误差，

1
2
3
4
5
6
7
8
9

net.zero_grad()     # zeroes the gradient buffers of all parameters

print('conv1.bias.grad before backward')
print(net.conv1.bias.grad)

loss.backward()

print('conv1.bias.grad after backward')
print(net.conv1.bias.grad)

更新权重

误差每次传播后，需要对权重进行更新，简单的更新方式如下：

1
2
3

learning_rate = 0.01
for f in net.parameters():
    f.data.sub_(f.grad.data * learning_rate)

torch.optim实现了这一过程，并有着不同的更新规则GD, Nesterov-SGD, Adam, RMSProp，

1
2
3
4
5
6
7
8
9
10
11

import torch.optim as optim

# create your optimizer
optimizer = optim.SGD(net.parameters(), lr=0.01)

# in your training loop:
optimizer.zero_grad()   # zero the gradient buffers
output = net(input)
loss = criterion(output, target)
loss.backward()
optimizer.step()    # Does the update

note: 每次迭代时由于梯度的累积，需要手动将梯度归零optimizer.zero_grad()

用隐含马尔可夫模型和他的应用
对于序列标注问题，目前主流的方法是条件随机场和长短期记忆网络，而一些简单的任务如分词、词性标注和命名实体识别，应用隐马尔可夫模型能够快速同时高效地进行学习。

模型简介

HMM被认为是解决大多数NLP问题最为快速有效的问题。将语言模型与通信问题联系起来，通信的本质是编解码和传输的过程。一个典型的通信系统包括信息源、信道、接收者、信息、上下文和编码。通信中，如何根据接收端的观测信号o₁,o₂,o₃,…来推测信号源发送的信息s₁,s₂,s₃,…?当然是求条件概率了。

$$
s_1,s_2,s_3,…=ArgMax_{s_1,s_2,s_3,…}{P(s_1,s_2,s_3,…|o_1,o_2,o_3,…)}
$$
根据贝叶斯公式，上述公式也等价于

$$
\frac{P(o_1,o_2,o_3,…|s_1,s_2,s_3,…)\cdot{P(s_1,s_2,s_3,…)}}{P(o_1,o_2,o_3,…)}
$$
公式中，分母可以看做是常数，因此对于通信问题求状态信息概率的问题可以看作是求联合概率$P(o_1,o_2,o_3,…|s_1,s_2,s_3,…)\cdot{P(s_1,s_2,s_3,…)}$,HMM模型通过简化该模型来计算信号源的概率。

HMM模型基于马尔可夫假设和独立输出假设。

符合马尔可夫假设的随机过程称为马尔可夫过程，也称为马尔可夫链。即随机状态中各个状态的概率分布只和前一个状态有关，下图表示一个离散的马尔可夫过程。

其中，模型参数为转移概率，从一个状态转移到下一个状态的概率。随机选择初始状态后，运行一段时间T后，根据马尔可夫链的转移概率可以生成一个状态序列：$s_1,s_2,s_3,…,s_T$。或者可以根据已存在的状态序列，通过计算某一状态的出现次数与转到零一状态的次数之比来估计转移概率。
HMM模型是马尔可夫模型的扩展，每一时刻输出o_t,且只与s_t相关，s_t是不可见的，只能通过观察o_t来估计隐含状态s_t。
基于马尔可夫假设和独立输出假设，之前的联合概率可写作
$$
P(s_1,s_2,s_3,…,o_1,o_2,o_3,…)=\prod_tP(s_t|s_{t-1})\cdot{P(o_t|s_t)}
$$
其中，$P(s_t|s_{t-1}$称为转移概率，$P(o_t|s_t)$称为生成概率。
HMM模型参数为$<S,O,A,B,\Pi>$

• S表示模型状态，N是状态数量，$S={S_1,S_2,…,S_N}$
• O表示每个状态的观察值，M为所有可能观察值的数量，$O={O_1,O_2,…,O_M}$
• $A={a_{ij}}\in{R^{N*N}}$表示状态转移概率矩阵
• $B={b_j(k)}\in{R^{N*M}}$表示生成概率矩阵
• $\Pi\in{R^N}$表示初始状态概率

由此，通过$\Pi$和A可以生成隐含状态序列，然后由每一时刻的生成概率B可以产生观察序列。设模型参数为$\lambda$,模型给定时，有

$$
P(s|\lambda)=\pi_{i_1}a_{i_1i_2}a_{i_2i_3}…a_{i_{T-1}i_T}
$$

$$
P(o|s,\lambda)=b_{i_1o_1}b_{i_2o_2}…b_{i_To_T}
$$

$$
P(o,s|\lambda)=\pi_{i_1}b_{i_1o_1}a_{i_1i_2}b_{i_2o_2}…a_{i_{T-1}}b_{i_To_T}
$$

围绕HMM模型有三个基本问题，不同的任务有不同的算法求解。

给定模型计算输出序列概率

暴力计算

列举出所有可能的状态序列，计算每个序列的联合概率$P(o,s|\lambda)$,然后全部相加，得到观测序列的概率$\sum_i{P(o,s|\lambda)}$。这样的计算方式时间复杂度高。

前向算法

引入前向变量$\alpha_t(i)$,表示在t时刻状态为i时，输出序列为$o_1,o_2,…,o_T$的概率。这样，$P(o)=\alpha_t(1)+\alpha_t(2)+…+\alpha_t(i)$.而t时刻的前向变量可以通过t-1时刻的前向变量计算得到，以此类推，初始化计算出第一次的前向变量时，通过迭代最终可以计算出观察序列的概率。

$$
\alpha_t(i+1)=(\sum_{i=1}^{N}{\alpha_t(i)})b_j{(o_{t+1})},1\leq{t}\leq{T-1}
$$

后向算法

跟前向算法差不多，引入了后向变量$\beta_t(i)$

给定模型和特定观察序列求概率最大的状态序列

维特比算法

可以将此类问题看作是动态规划，用维特比算法求解。
在状态序列中，每一时刻的状态都有N种取值，假设序列长度为T，则一共有$N^T$种可能的状态序列，长序列时很难使用暴力计算来求解最大概率的路径。
维特比算法认为概率最大的路径P经过序列上的任意时刻，从起始点到该时刻的这段路径一定也是到当前时刻的概率最大的路径，因此维特比从第一个时刻开始，依次考察路径的概率，计算得到的概率最大的路径经过的状态即是这一时刻的状态的取值。因此，每一步计算的复杂度都和相邻两个时刻$S_i$和$S_i+1$各自的节点数目$n_i$,$n_i+1$的乘积成正比，即$O(n_i\cdot{n_{i+1}})$.

估计模型参数

已知观察序列和对应的状态序列

观察序列和状态序列都已知的情况下，很好解决。利用样本中出现的各个取值的次数可以计算出大致的模型参数。

$$
P(o_t|s_t)\approx\frac{(o_t,s_t)}{(s_t)}
$$

$$
P(s_t|s_{t-1})\approx\frac{(s_t,s_{t-1})}{(s_{t-1})}
$$

已知观察序列

在已知观察序列未知状态序列的情况下，可以使用鲍姆韦尔奇算法求解，通过期望最大化（EM）算法进行迭代。
首先找到一组能够产生输出序列O的模型参数，根据模型参数计算当前概率最大的状态序列的可能值并作为标注数据，按照3.1的方式重新计算模型参数，再次寻找概率最大的状态序列，一直迭代，直至模型性能收敛。

hmmlearn

hmmlearn是用于学习HMM模型的python库，与scikit-learn的API相似，依赖于scikit-learn,NumPy,SciPy,matplotlib等库。在官方文档中详细描述了hmmlearn中API的使用和一些实例。
hmmlearn的安装和其他模块一样。
pip install hmmlearn
hmmlearn实现了三种算法的HMM模型，如下：

针对观测序列为连续量的情况，可以使用前两种类，假设观察量呈现高斯分布或高斯混合分布，模型不复杂时使用第一种就足够了。

构建HMM，产生样本

通过传递参数，可以构建HMM对象。
在MultionalHMM类中，主要参数如下

class hmmlearn.hmm.MultinomialHMM(n_components=1, startprob_prior=1.0, transmat_prior=1.0, algorithm='viterbi', random_state=None, n_iter=10, tol=0.01, verbose=False, params='ste', init_params='ste')

n_components: 状态数量N
algorithm: 可选’viterbi’或’map’
n_iter: 模型EM迭代的最大次数
tol: 收敛阈值，最大似然增益小于tol时停止EM迭代
verbose： verbose=True时打印每次迭代的收敛程度
params: 控制哪些参数需要在训练中更新，’ste’的组合，分别代表初始概率分布、转移矩阵和生成矩阵
init_params: 哪些参数需要初始化

MultinomialHMM类的属性

在GaussianHMM类中，主要参数如下：

class hmmlearn.hmm.GaussianHMM(n_components=1, covariance_type='diag', min_covar=0.001, startprob_prior=1.0, transmat_prior=1.0, means_prior=0, means_weight=0, covars_prior=0.01, covars_weight=1, algorithm='viterbi', random_state=None, n_iter=10, tol=0.01, verbose=False, params='stmc', init_params='stmc')
GaussianHMM类中，参数与离散HMM略有不同，

covariance_type : 用于描述协方差的类型，必须是”spherical”,”diag”,”full”,”tied”的一种，详见
params: ‘cmte’,cm分别代表高斯分布的方差和均值
init_params: ‘cmte’

在属性中，因为是连续量，所以没有emissionprob_，变成了means_和covars_.

下面是构建GaussianHMM实例：

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

>>> import numpy as np
>>> from hmmlearn import hmm
>>> np.random.seed(42)

>>> model = hmm.GaussianHMM(n_components=3, covariance_type="full")
>>> model.startprob_ = np.array([0.6, 0.3, 0.1])
>>> model.transmat_ = np.array([[0.7, 0.2, 0.1],
...                             [0.3, 0.5, 0.2],
...                             [0.3, 0.3, 0.4]])
>>> model.means_ = np.array([[0.0, 0.0], [3.0, -3.0], [5.0, 10.0]])
>>> model.covars_ = np.tile(np.identity(2), (3, 1, 1))
>>> X, Z = model.sample(100)

建立确定参数的HMM模型时，需要在构建实例后，传入模型的参数，连续模型是cmte,离散模型是ste。
代码最后，通过model.sample(100)产生长度为100的样本，X，Z分别代表了状态序列和观测序列。

训练HMM参数，估计状态序列

可以通过fit方法来训练HMM参数，输入是联立的观测序列和它的长度序列。
通过方法score可以计算观测序列的概率。
推断状态序列可以用predict方法。

保存和加载模型

有两种方法，标准的pickle模块和scikit-learn中的joblib模块

1
2
3
4
5

>>> from sklearn.externals import joblib
>>> joblib.dump(remodel, "filename.pkl")
["filename.pkl"]
>>> joblib.load("filename.pkl")  
GaussianHMM(algorithm='viterbi',...

参考文献：

1. https://www.cnblogs.com/pinard/p/7001397.html
2. http://hmmlearn.readthedocs.io/en/latest/auto_examples/plot_hmm_stock_analysis.html
3. 数学之美.吴军

给25岁的自己

现在是2018年5月29日凌晨1点，写下这篇文章，给25岁即将毕业的我。希望自己以后每年都会有时间在这里写上一段话，以供后来的我瞻仰，额。。。好像不该用瞻仰这个词。

接下来的话全是即兴发挥，恩，可以说是接近乱扯了。

不迷茫

研究生三年，边学边迷茫，想着要毕业了，应该不迷茫了吧。恩，不迷茫是不可能的。到现在，还是不清楚自己该做些什么。不过，这很重要吗？我一般都不怎么考虑这些大问题，日子慢慢过呗。

本科的时候很清楚自己要读研，因为总想着妈的学了这么多好耍的东西，上班了就用不了了就很亏啊。而且还年轻啊。年轻的时候何必让自己想那么多大人该想的事情，就做自己想做的。所以，继续读了三年书。实话讲，很庆幸这三年的时光，让自己有了很多思考的时间。以前从不会在凌晨的时候还在电脑前看书，写代码，现在，真的是，凌晨不学点东西，我浑身难受！我一直认为，研究生就是学会怎么和孤独相处的过程，每个人都有自己的事情，找到合拍的很难，自己的研究方向别人又很难搞懂，所以，自律就很重要了。哈哈，虽然我并不自律。但也努力地在每个阶段中去完成一些事情，回过头来看看，真的是收获颇丰啊。总结起来，学了很多领域的知识，硬件、软件、控制、图像、文本、数据挖掘，每个领域都很有趣，以后有咸鱼时间再利用这些知识做些好玩的事情吧。

学生时代的生活是在学习中寻找自己的人身价值，很遗憾，学生时代即将过去了，我也不知道我的人生价值是什么，十年之后，我会在哪里，做些什么，我都想象不出来。以前和朋友聊天的时候，我总结了一个观点，人分两种，一种是很清楚的知道每一个当下的自己该干嘛，对未来有个美好蓝图，然后朝着那个目标不断努力，另一种是不清楚自己以后该干嘛，在社会上大抵是被推着走的，就像是游戏里的角色，到了某一个关口，来不及反应，马上又有新的任务派给他了，完成之后又是新的任务。。。大多数人都是第二种吧，我也是，不过我觉得没什么差。何必需要一个蓝图来束缚自己，我的年龄、背景和阅历不足以让我在二十岁的时候意识到这个社会的法则，因此我也不需要当前我就有一个宏伟的目标，我需要的是一个一个的小目标，每完成一个，我就依照自己的兴趣给自己分配下一个。三十而立四十不惑嘛，慢慢地走到了那个阶段了，是什么就是什么，毕竟也有努力过，怎么可能会后悔呢？

所以，只要自己想着要做什么，就做什么。哈哈哈，很佛性啊，不争不抢。

迷茫

我目前的心性决定了我现在能想到的未来仅是半年后，再远就想不到了，也不需要去想，额，不知道以后会不会变，毕竟，这样的生活，对于在充满竞争的社会上，是出于劣势的。

之前也和朋友聊天说过这个问题，25岁了，没有考虑房子，没有考虑结婚，只想着觉得，恩，这个算法很牛批，我要来试试看，哟，那个框架很炫酷，现在就下载下来看看。这种态度在职场中是不讨好的，之前有过三个月的实习经历，深深觉得，要想升职加薪，真的要到处用心，把握每一个机会，而我，之前很看淡这些，觉得没得撒子意思的嘛，额，甚至呆的久了，觉得这种公司是真滴很没劲，人情世故要考虑，每次开会说什么要慎重。我知道这些在以后都是必备的技能，所以，很矛盾。慢慢来吧