torch.nn总结-FlyAI

torch.nn总结

PyTorch

最后更新 2020-08-10 10:30 阅读 4699

最后更新 2020-08-10 10:30

阅读 4699

PyTorch

1. torch.nn.Parameter(torch.FloatTensor(hidden_size))
	将一个不可训练的类型Tensor转换成可以训练的类型parameter并将这个parameter绑定到这个module里面;
	
2. torch.nn.Module：构建模型的基类

3. torch.nn.Sequential：容器,按照构造的顺序执行
	>> model = nn.Sequential(nn.Conv2d(1,20,5),nn.ReLU(),nn.Conv2d(20,64,5),nn.ReLU())
	
4. torch.nn.ModuleList: 包含子模块的列表
	>> self.linears = nn.ModuleList([nn.Linear(10, 10) for i in range(5)])
	>> for i, l in enumerate(self.linears):
	>> 		x = self.linears[i//2](x) + l(x)
	
5. torch.nn.ModuleDict: 字典中保存子模块，想python字典一样的方式调用
	>> self.choices = nn.ModuleDict({
                'conv': nn.Conv2d(10, 10, 3),
                'pool': nn.MaxPool2d(3)})
	>> x = self.choices['conv'](x)
	
# 1. 卷积/转置卷积
6. torch.nn.Conv1d(						** 一维卷积, L代表序列长度	(初始化类)
		in_channels, 			* 输入的通道数 C_in
		out_channels, 			* 输出的通道数 C_out
		kernel_size, 			* 卷积核尺寸
		stride=1, 				* 步长
		padding=0, 				* 0 padding
		dilation=1, 			* 膨胀卷积中，膨胀系数(卷积核间隔)
		groups=1, 				* 从输入通道到输出通道被阻塞的连接数
		bias=True, 				* 是否使用bias
		padding_mode='zeros')	* 'zeros', 'reflect', 'replicate' or 'circular'
	** (batch, C_in, L_in) --> (batch, C_out, L_out)	L_out = (L_in + 2*padding - dilation*(kernel_size-1) - 1) / stride + 1 (向下取整)
	** 包含变量：.weight  .bias
7. torch.nn.Conv2d(						** 二维卷积，H代表图片的高，W代码图片的宽	(初始化类)
		in_channels, 			* 输入的通道数 C_in
		out_channels, 			* 输出的通道数 C_out
		kernel_size, 			* 卷积核尺寸; 可以有两个元素代表分别对H/W方向操作
		stride=1, 				* 步长; 可以有两个元素代表分别对H/W方向操作
		padding=0, 				* 0 padding; 可以有两个元素代表分别对H/W方向操作
		dilation=1, 			* 膨胀卷积中，膨胀系数(卷积核间隔); 可以有两个元素代表分别对H/W方向操作
		groups=1, 				* 从输入通道到输出通道被阻塞的连接数
		bias=True, 				* 是否使用bias
		padding_mode='zeros')	* 'zeros', 'reflect', 'replicate' or 'circular'
	** (batch, C_in, H_in, W_in) -- > (batch, C_out, H_out, W_out) H_out和W_out算法同上
	** 包含变量：.weight  .bias

# 2. Pooling
8. torch.nn.MaxPool1d(					** 一维maxpooling	(初始化类)
		kernel_size, 			* 卷积核尺寸
		stride=None, 			* 步长，默认=kernel_size
		padding=0, 				* zero padding
		dilation=1, 			* 膨胀卷积中，膨胀系数(卷积核间隔)
		return_indices=False, 	* 是否同时返回max位置的索引；一般在torch.nn.MaxUnpool1d中很有用(maxpool逆计算)
		ceil_mode=False)		* 
	** (batch, C_in, L_in) --> (batch, C_out, L_out)	L_out = (L_in + 2*padding - dilation*(kernel_size-1) - 1) / stride + 1 (向下取整)
9. torch.nn.MaxPool2d(					** 二维maxpooling	(初始化类)
		kernel_size, 			* 卷积核尺寸
		stride=None, 			* 步长，默认=kernel_size
		padding=0, 				* zero padding
		dilation=1, 			* 膨胀卷积中，膨胀系数(卷积核间隔)
		return_indices=False, 	* 是否同时返回max位置的索引；一般在torch.nn.MaxUnpool2d中很有用(maxpool逆计算)
		ceil_mode=False)
	** (batch, C_in, H_in, W_in) -- > (batch, C_out, H_out, W_out) H_out和W_out算法同上

# 3. 非线性激活	(初始化类)
10. torch.nn.Sigmoid()					** Sigmoid(X) = 1/(1+exp(-x))
11. torch.nn.LogSigmoid()				** LogSigmoid(x) = log(1/(1+exp(-x)))
12. torch.nn.ReLU(inplace=False)		** ReLU(x) = max(0, x)
13. torch.nn.ReLU6(inplace=False)		** ReLU6(x) = min(max(0,x), 6)	//(0,6)之间截断
14. torch.nn.LeakyReLU(					** LeakyReLU(x) = max(0, x) + negative_slope × min(0, x) 
		negative_slope=0.01, inplace=False)
15. torch.nn.ELU(						** ELU(x) = max(0, x) + min(0, alpha × (exp(x)-1))
		alpha=1.0, 
		inplace=False)			* 是否in_place
16. torch.nn.PReLU(						** PReLU(x) = max(0, x) + a × min(0, x)  a是可训练参数
		num_parameters=1, 		* 需要训练的a的数量，必须是通道值≥1
		init=0.25)				* a的初始值
17. torch.nn.RReLU(						** RReLU(x) = max(0, x) + a × min(0, x)  a在[lower, upper]之间随机取值
		lower=0.125, upper=0.3333333333333333, inplace=False)
18. torch.nn.SELU(inplace=False)		**SELU(x) = scale * (max(0,x) + min(0, a*(exp(x)-1)))	//a=1.6732632423543772848170429916717,scale=1.0507009873554804934193349852946
19. torch.nn.CELU(alpha=1.0, inplace=False)	** CELU(x) = max(0,x) + min(0, alpha×(exp(x/alpha) - 1))
20. torch.nn.GELU()						** GELU(x) = x × Q(X)		// Q(x)是高斯分布的累积分布
21. torch.nn.Tanh()						** Tanh(x) = (exp(x) - exp(-x)) / (exp(x) + exp(-x))
22. torch.nn.Threshold(					** Threshold(x) = x if x>threshold else value
		threshold, value, inplace=False)
23. torch.nn.Softmax(dim=None)			** 在dim维度上softmax，Softmax(X) = exp(xi)/sum(exp(Xi))

# 4. MultiheadAttention
24. torch.nn.MultiheadAttention(			** 初始化 多头注意力 类
		embed_dim, 				* model dim
		num_heads, 				* 分头
		dropout=0.0, 			* attn_output_weights上的dropout rate
		bias=True, 				* 是否使用bias
		add_bias_kv=False, 		* 在dim=0的维度上，对key和value加上偏置
		add_zero_attn=False, 	* 在dim=1的维度上，对key和value添加0
		kdim=None, 				* key的dim
		vdim=None)				* value的dim	# 如果kdim/vdim为None,默认等于embed_dim
	forward(							** 计算多头注意力
		query,					* (target_seq_len, batch, embed_dim)
		key, 					* (source_seq_len, batch, embed_dim)
		value, 					* (source_seq_len, batch, embed_dim)
		key_padding_mask=None, 	* k和v掩码标志,(batch, source_seq_len)
		need_weights=True, 		
		attn_mask=None)			* attn掩码标志,(target_seq_len, source_seq_len)或(batch*num_heads, target_seq_len, source_seq_len)
	输出：
		attn_output				* (target_seq_len, batch, embed_dim)
		attn_output_weights		* (batch, target_seq_len, source_seq_len)
		
# 5. Normalization
[BatchNorm：batch方向做归一化，算NHW的均值，对小batchsize效果不好；BN主要缺点是对batchsize的大小比较敏感，由于每次计算均值和方差是在一个batch上，所以如果batchsize太小，则计算的均值、方差不足以代表整个数据分布
LayerNorm：channel方向做归一化，算CHW的均值，主要对RNN作用明显；]
25. torch.nn.BatchNorm1d(				** 2d或3d输入上批标准化	(初始化类)
		num_features, 				* 输入的特征数
		eps=1e-05, 					* 平滑
		momentum=0.1, 				* 移动平均默认的动量值
		affine=True, 				* 当设为true，给该层添加可学习的仿射变换参数
		track_running_stats=True)
	** y = (x - mean(x))/sqrt(std(x)+eps) × gamma + beta	gammahe beta是可训练的
26. torch.nn.BatchNorm2d(				** 4d输入进行批标准化	(初始化类)
		num_features, 				* 输入的特征数
		eps=1e-05, 					* 平滑
		momentum=0.1, 				* 
		affine=True, 				* 当设为true，给该层添加可学习的仿射变换参数
		track_running_stats=True)
27. torch.nn.LayerNorm(					** Layer Norm
		normalized_shape, 			*  (int or list or torch.Size) 输入的尺寸
		eps=1e-05, 
		elementwise_affine=True)
	** y = (x - mean(x))/sqrt(std(x)+eps) × gamma + beta	gammahe beta是可训练的
	
# 6. RNN
28. torch.nn.RNN(						** 计算RNN(x) = ReLU(W(ih)*x(t) + b(ih) + W(hh)*h(t-1) + b(hh)) (初始化类)
		input_size,				* 输入的embed_dim
		hidden_size,			* 隐藏层size
		num_layers=1,			* RNN层数
		nonlinearity='tanh',	* 激活函数 'tanh' or 'relu'
		bias=True,				
		batch_first=False,		* if True:(batch, seq_len, embed_dim) else (seq_len, batch, embed_dim)
		dropout=0,				* 出最后一层外，其他每层输出的dropout rate
		bidirectional=False)	* 是否是双向RNN
	输入：(input, h0)
		input: (seq_len, batch, embed_dim),输入序列，可以是PackedSeqence
		h0: (num_layers*num_directions, batch, hidden_size)，每一循环初始时刻的h，未给默认是0.BiRNN时num_directions=2
	输出：(output, hn)
		output: (seq_len, batch, num_directions*hidden_size)，每一个时刻的最后输出，如果输入是PackedSeqence，输出也是PackedSeqence
		hn: (num_layers*num_directions, batch, hidden_size)，每一循环最后时刻的输出h
	包含变量：.weight_ih_l .weight_hh_l .bias_ih_l .bias_hh_l	--初始化变量满足U(-sqrt(k), sqrt(k)), k=1/hidden_size 
29. torch.nn.LSTM(						** LSTM (初始化类)
		input_size,				* 输入的embed_dim
		hidden_size,			* 隐藏层size
		num_layers=1,			* RNN层数
		bias=True,				
		batch_first=False,		* if True:(batch, seq_len, embed_dim) else (seq_len, batch, embed_dim)
		dropout=0,				* 出最后一层外，其他每层输出的dropout rate
		bidirectional=False)	* 是否是双向LSTM
	** [ i(j)		[ sigmoid
	**   o(j)   =  	  sigmoid	✖  (W[x(j);h(j-1)] + b)
	**	 f(j)		  sigmoid
	**	 g(j)]		   tanh	 ]
	** 	C(j) = f(j) · C(j-1) + i(j) · g(j)
	**  h(j) = o(j) · tanh(C(j))
	输入：(input, (h0, c0))
		input: (seq_len, batch, embed_dim),输入序列，可以是PackedSeqence
		h0: (num_layers*num_directions, batch, hidden_size)，每一循环初始时刻的h，未给默认是0.BiRNN时num_directions=2
		c0: (num_layers*num_directions, batch, hidden_size), 每一循环初始时刻的c，未给默认是0.BiRNN时num_directions=2
	输出：(output, (hn, cn))
		output: (seq_len, batch, num_directions*hidden_size)，每一个时刻的最后输出，如果输入是PackedSeqence，输出也是PackedSeqence
		hn: (num_layers*num_directions, batch, hidden_size)，每一循环最后时刻的输出h
		cn: (num_layers*num_directions, batch, hidden_size)，每一循环最后时刻的输出c
	包含变量：.weight_ih_l .weight_hh_l .bias_ih_l .bias_hh_l	--初始化变量满足U(-sqrt(k), sqrt(k)), k=1/hidden_size 
30. torch.nn.GRU(*args, **kwargs)
31. torch.nn.RNNCell(					** RNN cell (初始化类)
		input_size, 			* 输入的embed_dim
		hidden_size, 			* 隐藏层h的size
		bias=True, 				* 
		nonlinearity='tanh')	* 激活函数 'tanh' or 'relu'
	输入：input, h_0
		input: (batch, embed_dim)
		h_0:	(batch, hidden_size) 上一时刻的h，不提供的话默认为0
	输出：h_1
		h_1: (batch, hidden_size) 当前时刻rnn cell的输出h
	包含变量：.weight_ih .weight_hh .bias_ih .bias_hh	--初始化变量满足U(-sqrt(k), sqrt(k)), k=1/hidden_size 
32. torch.nn.LSTMCell(					** LSTM cell (初始化类)
		input_size, 			* 输入的embed_dim
		hidden_size, 			* 隐藏层h的size
		bias=True)
	输入：input, h_0, c_0
		input: (batch, embed_dim)
		h_0: (batch, hidden_size) 上一时刻的h，不提供的话默认为0
		c_0: (batch, hidden_size) 上一时刻的c，不提供的话默认为0
	输出：h_1
		h_1: (batch, hidden_size) 当前时刻rnn cell的输出h
		c_1: (batch, hidden_size) 当前时刻rnn cell的输出c
	包含变量：.weight_ih .weight_hh .bias_ih .bias_hh	--初始化变量满足U(-sqrt(k), sqrt(k)), k=1/hidden_size 	
33. torch.nn.GRUCell(input_size, hidden_size, bias=True)

# 7. Transformer layers				
34. torch.nn.Transformer(				** Transformer  (初始化类)
		d_model=512, 			* encoder/decoder输入和输出维度  (这里d_model=embed_dim=hidden_size)
		nhead=8, 				* 多头
		num_encoder_layers=6, 	* encoder层数
		num_decoder_layers=6, 	* decoder 层数
		dim_feedforward=2048, 	* feed forward层dim
		dropout=0.1, 			* dropout rate
		activation='relu', 		* 激活函数 relu/gelu
		custom_encoder=None, 	* 自编码
		custom_decoder=None)	* 自解码
	forward(
		src, 							* encoder输入, (source_seq_len, batch, d_model)
		tgt, 							* decoder输入, (target_seq_len, batch, d_model)
		src_mask=None, 					* 未来词mask,mask掉未来词对当前词的预测, (source_seq_len, source_seq_len)
		tgt_mask=None, 					* 未来词mask,mask掉未来词对当前词的预测, (target_seq_len, target_seq_len)
		memory_mask=None, 				* 未来词mask,mask掉未来词对当前词的预测, (target_seq_len, source_seq_len)
		src_key_padding_mask=None, 		* encoder层attention mask(计算scaled dot product时), (batch, source_seq_len)
		tgt_key_padding_mask=None, 		* decoder层attention mask(计算scaled dot product时), (batch, target_seq_len)
		memory_key_padding_mask=None)	* encoder输出与decoder输入计算decoder multi-head attention时mask,(batch, source_seq_len)
	输出：
		output: shape=(target_seq_len, batch, d_model)
35. torch.nn.TransformerEncoder(		** Transformer encoder过程  (初始化类)
		encoder_layer, 					* TransformerEncoderLayer()类的实例
		num_layers, 					* encoder的层数
		norm=None)						* layerNorm
	forward(
		src, 							* encoder的输入	(source_seq_len, batch, d_model)
		mask=None, 						* 未来词mask	(source_seq_len, source_seq_len)
		src_key_padding_mask=None)		* padding mask	(batch, source_seq_len)
36. torch.nn.TransformerEncoderLayer(	** TransformerEncoderLayer 类
		d_model, 						* 输入输出dim
		nhead, 							* 多头
		dim_feedforward=2048, 			* feed forward层dim
		dropout=0.1, 					* dropout rate
		activation='relu')				* 激活函数 relu/gelu
	forward(
		src, 							* encoder的输入	(source_seq_len, batch, d_model)
		mask=None, 						* 未来词mask	(source_seq_len, source_seq_len)
		src_key_padding_mask=None)		* padding mask	(batch, source_seq_len)
37. torch.nn.TransformerDecoder(		** Transformer decoder过程  (初始化类)
		decoder_layer, 					* TransformerDecoderLayer()类的实例
		num_layers, 					* decoder的层数
		norm=None)						* layerNorm
	forward(
		tgt, 							* decoder的输入 (target_seq_len, batch, d_model)
		memory, 						* encdoer的输出 (source_seq_len, batch, d_model)
		tgt_mask=None, 					* 未来词mask, (target_seq_len, target_seq_len)
		memory_mask=None, 				* 未来词mask, (target_seq_len, source_seq_len)
		tgt_key_padding_mask=None, 		* decoder层attention mask(计算scaled dot product时), (batch, target_seq_len)
		memory_key_padding_mask=None)	* encoder输出与decoder输入计算decoder multi-head attention时mask,(batch, source_seq_len)
38. torch.nn.TransformerDecoderLayer(
		d_model, 						* 输入输出dim
		nhead, 							* 多头
		dim_feedforward=2048, 			* feed forward层dim
		dropout=0.1, 					* dropout rate
		activation='relu')				* 激活函数 relu/gelu
	forward(
		tgt, 							* decoder的输入 (target_seq_len, batch, d_model)
		memory, 						* encdoer的输出 (source_seq_len, batch, d_model)
		tgt_mask=None, 					* 未来词mask, (target_seq_len, target_seq_len)
		memory_mask=None, 				* 未来词mask, (target_seq_len, source_seq_len)
		tgt_key_padding_mask=None, 		* decoder层attention mask(计算scaled dot product时), (batch, target_seq_len)
		memory_key_padding_mask=None)	* encoder输出与decoder输入计算decoder multi-head attention时mask,(batch, source_seq_len)
		
# 8. Linear layers
39. torch.nn.Linear(					** 线性映射层  (初始化类)
		in_features, 		* 输入维度 input_size
		out_features, 		* 输出维度 output_size
		bias=True)
	输入： input: (batch, *, input_size)
	输出:  output: (batch, *, output_size)
	包含变量：.weight .bias	--初始化变量满足U(-sqrt(k), sqrt(k)), k=1/input_size

# 9. Dropout layers
40. torch.nn.Dropout(					** 随机置0  (初始化类)
		p=0.5, 				* 置0概率，dropout rate
		inplace=False)
	输入和输出一样的维度
	
# 10. embedding layer
41. torch.nn.Embedding(					** word embedding
		num_embeddings, 			* 需要embedding的词的个数
		embedding_dim, 				* 
		padding_idx=None, 			* 次下标的word embedding用0填充
		max_norm=None, 				* 归一化embedding的值
		norm_type=2.0, 				* 对max_norm计算p_norm时的范数p
		scale_grad_by_freq=False, 	* 根据字典中单词频率，缩放梯度
		sparse=False, 				* 是否为稀疏张量 (GNN有用到)
		_weight=None)
	输入：id列表, LongTensor
	输出: (batch, embed_dim), 每个id对应的embedding
	包含变量：.weight	-- 初始化变量满足N(0, 1)的正态分布
42. torch.nn.EmbeddingBag(				** bag embedding
		num_embeddings, 
		embedding_dim, 
		max_norm=None, 
		norm_type=2.0, 
		scale_grad_by_freq=False, 
		mode='mean', 
		sparse=False, 
		_weight=None, 
		include_last_offset=False)
		
# 11. 损失函数
43. torch.nn.L1Loss(					** L1损失 平均绝对值误差(MAE)  loss(x, y) = mean(abs(xi-yi))
		size_average=None, 		* 
		reduce=None, 
		reduction='mean')		* 计算的损失是sum还是mean，默认mean
44. torch.nn.MSELoss(					** L2损失 平均平方误差(MSE)  loss(x, y) = mean((xi-yi)^2)
		size_average=None, 
		reduce=None, 
		reduction='mean')		* 计算的损失是sum还是mean，默认mean
45. torch.nn.CrossEntropyLoss(			** 交叉熵损失 loss(x) = weight × (-x + log(sum(exp(xj))))
		weight=None, 			* 对每个类别给定一个权重，在不平衡训练集上很有用	
		size_average=None, 		* 默认对每个batch损失进行平均，如果False则对其累加
		ignore_index=-100, 		* 指定一个不想要输入梯度的目标值
		reduce=None, 			* 
		reduction='mean')		* 计算损失是sum还是mean，默认mean
	输入：
		input:	(batch, num_class)
		target: (batch)
	输出：output: 标量
46. torch.nn.CTCLoss(					** CTC损失
		blank=0, 				* 空白标志
		reduction='mean', 		* 计算的损失是sum还是mean，默认mean
		zero_infinity=False)	* 当输入太短时使用，是否是0的无穷损失和相关梯度
	输入：
		log_probs: (input_size, batch, num_class), 对数化输出概率(torch.nn.funcitonal.log_softmax())
		targets: (batch, max_target_len)
		input_lengths: (batch), 句子的真实长度
		target_lenghts: (batch), 目标的真实长度
	输出：output: 标量
47. torch.nn.NLLLoss(					** 负对数释然损失，用于训练一个n类的分类器 loss(x) = -weight × x
		weight=None, 			* 对每个类别给定一个权重，在不平衡训练集上很有用	
		size_average=None, 		* 默认对每个batch损失进行平均，如果False则对其累加
		ignore_index=-100, 		* 指定一个不想要输入梯度的目标值
		reduce=None, 
		reduction='mean')		* 计算损失是sum还是mean，默认mean
	输入：
		input:	(batch, num_class)
		target: (batch)
	输出：output: 标量
48. torch.nn.PoissonNLLLoss(			** 泊松分布的负对数释然损失 input - target×log(input) + log(target)
		log_input=True, 		* loss=exp(input)-target×input if True else loss=input - target×log(input+eps)
		full=False, 			* 是否计算全部损失，eg.加上Stirling近似
		size_average=None, 		* 默认对每个batch损失进行平均，如果False则对其累加
		eps=1e-08, 				* 平滑
		reduce=None, 
		reduction='mean')		* 计算损失是sum还是mean，默认mean
	输入: 
		input: (batch, *)
		target: (batch, *)
	输出: output: 标量
49. torch.nn.KLDivLoss(					** KL散度损失，计算不同的连续分布之间的距离，在连续的输出分布的空间上进行直接回归很有效；loss(x) = mean(target×(log(target)-x)
		size_average=None, 		* 默认对每个batch损失进行平均，如果False则对其累加
		reduce=None, 
		reduction='mean')		* 计算损失是sum还是mean，默认mean
	输入: 
		input: (batch, *)
		target: (batch, *)
	输出: output: 标量
50. torch.nn.BCELoss(					** 二分类任务的交叉熵损失 loss(x) = mean(-weight×(target×log(x) + (1-target)×log(1-x)))
		weight=None, 			* 每个batch的权重
		size_average=None, 		* 默认对每个batch损失进行平均，如果False则对其累加
		reduce=None, 
		reduction='mean')		* 计算损失是sum还是mean，默认mean
	输入: 
		input: (batch, *)
		target: (batch, *)
	输出: output: 标量
51. torch.nn.MultiLabelMarginLoss(		** 多标签分类损失，
		size_average=None, 
		reduce=None, 
		reduction='mean')
		
# 12. 工具 utils
52. torch.nn.utils.clip_grad_norm_(		** 对一个可迭代的parameters进行梯度norm截断，norm是根据所有的梯度计算出来的。
		parameters, 			* 一个可迭代的tensor或一个tensor，将被截断
		max_norm, 				* 梯度的最大norm
		norm_type=2)			* p_norm类型
53. torch.nn.utils.clip_grad_value_(	** 通过给定的值进行梯度截断
		parameters, 			* 一个可迭代的tensor或一个tensor，将被截断
		clip_value)				* 梯度截断的边界，[-clip_value, clip_value]之间
54. torch.nn.utils.parameters_to_vector(parameters)	 		** 模型参数(可迭代的tensor)转换成向量
55. torch.nn.utils.vector_to_parameters(vec, parameters)	** 向量转换成模型参数(可迭代的tensor)
# 1.

56. torch.nn.utils.rnn.pack_padded_sequence(		** 返回一个PackedSequence对象 PackedSequence对象经过运算结果还是一个PackedSequence对象
			input,			被填充后的 batch,
			lenths,			每个序列的长度。
			batch_first)	如果是True，input的形状应该是B*T*size	
		为什么pad pack
		如果不用pack和pad操作会有一个问题，什么问题呢？比如上图，句子“Yes”只有一个单词，但是padding了多余的pad符号，
	这样会导致LSTM对它的表示通过了非常多无用的字符，这样得到的句子表示就会有误差。
	在上面这个例子，我们想要得到的表示仅仅是LSTM过完单词"Yes"之后的表示，而不是通过了多个无用的“Pad”得到的表示。
		这里的pack，理解成压紧比较好。 将一个 填充过的变长序列 压紧。（填充时候，会有冗余，所以压紧一下）;
	（注意pack的形式，不是按行压，而是按列压）
		压缩成：data:		[第一列的所有值，第二列的所有值，...]  （pad被压缩掉） 
				batch_size:	[第一列有多少个值，第二列有多少个值，...]	(真实值，不计算pad)
		pack之后，原来填充的 PAD（一般初始化为0）占位符被删掉了。输入的shape=(seq_len, batch, embedding=*/0),
	if batch_first=True, shape=(batch, seq_len, embedding=*/0)
		Variable中保存的序列，应该按序列长度的长短排序，长的在前，短的在后。即input[:,0]代表的是最长的序列，
	input[:, B-1]保存的是最短的序列。
		NOTE： 只要是维度大于等于2的input都可以作为这个函数的参数。你可以用它来打包labels，然后用RNN的输出和
	打包后的labels来计算loss。通过PackedSequence对象的.data属性可以获取 Variable。
57. torch.nn.utils.rnn.pad_packed_sequence(			** 返回一个tuple (填充后的序列, batch中每个序列真实长度的列表)
			sequence(PackedSequence),	将要填充的batch
			batch_first)				如果是True，返回的数据形状应该是B*T*size
		上面提到的函数的功能是将一个填充后的变长序列压紧。 这个操作和pack_padded_sequence()是相反的。把压紧的序列
	再填充回来。填充时会初始化为0。返回的Varaible的值的size是 T×B×*, T 是最长序列的长度，B 是 batch_size,如果 
	batch_first=True,那么返回值是B×T×*。Batch中的元素将会以它们长度的逆序排列。

本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可，转载请附上原文出处链接和本声明。
本文链接地址：https://www.flyai.com/article/630

讨论

500字

表情

发送

删除确认

是否删除该条评论？

取消删除