python&pytorch常用方法总结

collections模块中OrderedDict的使用

很多人认为python中的字典是无序的，因为它是按照hash来存储的，但是python中有个模块collections(英文，收集、集合)，里面自带了一个子类OrderedDict，实现了对字典对象中元素的排序。

import collections
print("Regular dictionary")
d={}
d['a']='A'
d['b']='B'
d['c']='C'
d['1'] = '1'
for k,v in d.items():
    print (k,v)

print("\nOrder dictionary")
d1 = collections.OrderedDict()
d1['a'] = 'A'
d1['c'] = 'C'
d1['1'] = '1'
d1['b'] = 'B'
d1['2'] = '2'
for k,v in d1.items():
    print(k,v)
#------------------------------
Regular dictionary
a A
c C
b B
1 1

Order dictionary
a A
c C
1 1
b B
2 2

strip()方法

Python strip() 方法用于移除字符串头尾指定的字符（默认为空格）或字符序列。

str = "*****this is **string** example....wow!!!*****"
print (str.strip( '*' ))  # 指定字符串 *
输出：
this is **string** example....wow!!!

topk()函数

topk()函数取指定维度上的最大值(或最大几个)，第二个参数dim=1，为按行取，dim=0，为按列取，如下：

>>> a=torch.randn((4,6))
>>> print(a)
tensor([[ 0.7042,  0.2533,  1.1596, -0.7436,  0.5264,  0.2085],
        [ 0.2641,  0.9683,  0.4469, -1.9215, -0.7564,  1.1776],
        [ 1.0520, -1.6003, -0.8634,  1.7596, -0.8464,  0.7166],
        [-0.0492, -0.7746,  1.2592, -0.8273,  0.1266,  1.0450]])
>>> _, pred=a.topk(1,0,True,True)
>>> print(_)
tensor([[1.0520, 0.9683, 1.2592, 1.7596, 0.5264, 1.1776]])
>>> print(pred)
tensor([[2, 1, 3, 2, 0, 1]])

OrderedDict

OrderedDict 也是 dict 的子类，其最大特征是，它可以“维护”添加 key-value 对的顺序。简单来说，就是先添加的 key-value 对排在前面，后添加的 key-value 对排在后面。

两个 OrderedDict 中即使包含的 key-value 对完全相同，但只要它们的顺序不同，程序也依然会判断出两个 OrderedDict 是不相等的。例如如下程序：

# 创建普通的dict对象
my_data = {'Python': 20, 'Swift':32, 'Kotlin': 43, 'Go': 25}
# 创建基于key排序的OrderedDict
d1 = OrderedDict(sorted(my_data.items(), key=lambda t: t[0]))
# 创建基于value排序的OrderedDict
d2 = OrderedDict(sorted(my_data.items(), key=lambda t: t[1]))
print(d1) # OrderedDict([('Go', 25), ('Kotlin', 43), ('Python', 20), ('Swift', 32)])
print(d2) # OrderedDict([('Python', 20), ('Go', 25), ('Swift', 32), ('Kotlin', 43)])
print(d1 == d2) # False

mm与dot

Pytorch 的 mm 是矩阵的外积，而dot是元素对应积，即对应位置的元素相乘，需要左右矩阵形状一致。这点和numpy、mxnet不一样。

hasattr()函数

hasattr() 函数用于判断对象是否包含对应的属性。

hasattr 语法：

hasattr(object, name)

参数：
object – 对象。
name – 字符串，属性名。

返回值：
如果对象有该属性返回 True，否则返回 False。

forward() 的使用

使用pytorch的时候，模型训练时，不需要使用forward，只要在实例化一个对象中传入对应的参数就可以自动调用 forward 函数
即：

class Module(nn.Module):
    def __init__(self):
        super(Module, self).__init__()
        # ......
       
    def forward(self, x):
        # ......
        return x

data = .....  #输入数据

# 实例化一个对象

module = Module()

# 前向传播

module(data)  

# 而不是使用下面的

# module.forward(data)   

实际上

module(data)  

是等价于

module.forward(data)   

Pytorch中的 model.train() 和 model.eval() 模式

在训练模型时会在前面加上：

model.train()

启用 BatchNormalization 和 Dropout

在测试模型时在前面使用：

model.eval()

不启用 BatchNormalization 和 Dropout

同时发现，如果不写这两个程序也可以运行，这是因为这两个方法是针对在网络训练和测试时采用不同方式的情况。比如Batch Normalization 和 Dropout。

Batch Normalization

BN的作用主要是对网络中间的每层进行归一化处理，并且使用变换重构（Batch Normalization Transform）保证每层所提取的特征分布不会被破坏。

训练时是针对每个mini-batch的，但是在测试中往往是针对单张图片，即不存在mini-batch的概念。由于网络训练完毕后参数都是固定的，因此每个batch的均值和方差都是不变的，因此直接结算所有batch的均值和方差。所有Batch Normalization的训练和测试时的操作不同。

Dropout

Dropout能够克服Overfitting，在每个训练Batch中，通过忽略一半的特征检测器，可以明显的减少过拟合现象。

在训练中，每个隐层的神经元先乘以概率P，然后再进行激活。
在测试中，所有的神经元先进行激活，然后每个隐层神经元的输出乘P。

pytorch计算损失值并优化过程

# 先定义损失函数和优化函数
opt = torch.optim.SGD(net.parameters(),lr=LR)
loss_func = torch.nn.MSELoss()

# 计算损失值（输出值和真实值做对比）
loss = loss_func(output,b_y)

# 下面是固定的步骤
opt.zero_grad()
loss.backward()
opt.step() 

clamp函数

clamp表示夹紧，夹住的意思

torch.clamp(input,min,max,out=None)-> Tensor

将input中的元素限制在[min,max]范围内并返回一个Tensor

python3 map_embeddings.py --cuda --unsupervised ./data/embeddings/en.emb.txt ./data/embeddings/es.emb.txt ./data/mapedembeddings/en.mapedemb.txt ./data/mapedembeddings/es.mapedemb.txt

python3 eval_translation.py ./data/mapedembeddings/en.mapedemb.acl2018.txt ./data/mapedembeddings/es.mapedemb.acl2018.txt -d ./data/dictionaries/en-es.test.txt