torch.nn中的网络模型介绍

import torch.nn as nn
import torch
#seq=24，batch=10，input_size=100
x = torch.rand(24,10,100)
#input_size=100,hide_size=16
lstm = nn.LSTM(100,16,num_layers=2)
#结果输出
output,(h,c) = lstm(x)
print(output.size())
print(h.size())
print(c.size())

 
output:
#这个表示的是最终10个长度为24的句子的最终的输出
torch.Size([24, 10, 16])
#因为是上下两层的lstm，所以有两组h和c
torch.Size([2, 10, 16])
torch.Size([2, 10, 16])

import torch.nn as nn
import torch
#batch=10，seq=24，input_size=100
x = torch.rand(24,10,100)
#input_size=100,hide_size=16
lstm = nn.LSTM(100,16,num_layers=2,batch_first=True)
#结果输出
output,(h,c) = lstm(x)
print(output.size())
print(h.size())
print(c.size())

OUT:
torch.Size([24, 10, 16])
torch.Size([2, 24, 16])
torch.Size([2, 24, 16])

import torch
import torch.nn as nn
lstm = nn.LSTM(10, 20, 2)
x = torch.randn(5, 3, 10)
h0 = torch.randn(2, 3, 20)
c0 = torch.randn(2, 3, 20)
hn,cn=h0,c0
#可以根据seq的长度一个一个循环输入
for i in range(len(x)):
    #x[i]后就少了一个维度了，所以需要前面再加入一个维度unsqueeze(0)
    output, (hn, cn)=lstm(x[i].unsqueeze(0), (hn, cn))
    print(output.shape)#这个时候output的输出就不是整体所有步长的了，而是一个一个步长的输出了。

OUT:

torch.Size([1, 3, 20]) 
torch.Size([1, 3, 20])
torch.Size([1, 3, 20])
torch.Size([1, 3, 20])
torch.Size([1, 3, 20])

import torch as t
input = t.randn(6,5,3) # batch_size= 6(sentence_num), sentence_word_num= 5, word_vector_num = 3
print(input)
print(input.shape) # [6,5,3]
input = input.permute(0,2,1) # 维度转换(sentence_word_num <-> word_vector_num) 
print(input)
print(input.shape) # [6,3,5]
conv1 = nn.Conv1d(3, 8, 2, bias=False) # in_channels = word_vector_num = 3,out_channels = 8(new word_vector_num), kernel_size = 2
print(conv1.weight.shape) # [8,3,2]
output = conv1(input)
print(output)
print(output.shape) # [6,8,4]

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

x = torch.randn(1, 100, 3)        # 创建一个batch_size=1的点云，长度100
layer = nn.Linear(3, 10)        # 构造一个输入节点为3，输出节点为10的网络层
y = F.sigmoid(layer(x))            # 计算y，sigmoid激活函数

print(x.size())
print(y.size())
'''
>>>torch.Size([1, 100, 3])
>>>torch.Size([1, 100, 10])

import torch
import torch.nn as nn
import torch.nn.functional as F
#先进行了转置
x = torch.randn(1, 3, 100)                    # 创建一个batch_size=1的点云，长度100
layer = nn.Conv1d(3, 10, kernel_size=1)        # 构造一个输入节点为3，输出节点为10的网络层
y = F.sigmoid(layer(x))                         # 计算y，sigmoid激活函数

print(x.size())
print(y.size())
'''
>>>torch.Size([1, 3, 100])
>>>torch.Size([1, 10, 100])#若要结果与线性变换一直，可以最后对结果再转置回来。

import torch

def count_parameters(model):
    """Count the number of parameters in a model."""
    return sum([p.numel() for p in model.parameters()])

conv = torch.nn.Conv1d(8,32,1)
print(count_parameters(conv))
# 288

linear = torch.nn.Linear(8,32)
print(count_parameters(linear))
# 288

print(conv.weight.shape)
# torch.Size([32, 8, 1])
print(linear.weight.shape)
# torch.Size([32, 8])

# use same initialization
linear.weight = torch.nn.Parameter(conv.weight.squeeze(2))
linear.bias = torch.nn.Parameter(conv.bias)

tensor = torch.randn(128,256,8)
permuted_tensor = tensor.permute(0,2,1).clone().contiguous()    # 注意此处进行了维度重新排列

out_linear = linear(tensor)
print(out_linear.mean())
# tensor(0.0067, grad_fn=<MeanBackward0>)

out_conv = conv(permuted_tensor)
print(out_conv.mean())
# tensor(0.0067, grad_fn=<MeanBackward0>)