标签：features self 学习 pytorch bias model True out
# https://blog.csdn.net/qq_27825451/article/details/90705328
# https://blog.csdn.net/qq_27825451/article/details/90550890
"""
1.torch.nn.Module的基本属性
torch.nn.Module的基本定义(有一部分没有完全列出来)
class Module(object):
def __init__(self):
def forward(self, *input):
def add_module(self, name, module):
def cuda(self, device=None):
def cpu(self):
def __call__(self, *input, **kwargs):
def parameters(self, recurse=True):
def named_parameters(self, prefix='', recurse=True):
def children(self):
def named_children(self):
def modules(self):
def named_modules(self, memo=None, prefix=''):
def train(self, mode=True):
def eval(self):
def zero_grad(self):
def __repr__(self):
def __dir__(self):
在定义自已的网络的时候，需要继承nn.Module类，并重新实现构造函数__init__构造函数和forward这两个方法
一般把网络中具有可学习参数的层（如全连接层、卷积层等）放在构造函数__init__()中
一般把不具有可学习参数的层(如ReLU、dropout、BatchNormanation层)直接在forward方法里面使用nn.functional来代替(但也可放在构造函数中)
forward方法是必须要重写的，它是实现模型的功能，实现各个层之间的连接关系的核心
例1：
import torch
import torch.nn.functional as F
class MyNet(torch.nn.Module):
def __init__(self):
super(MyNet, self).__init__() # 调用父类的构造函数
self.conv1 = torch.nn.Conv2d(3, 32, 3, 1, 1)
self.conv2 = torch.nn.Conv2d(3, 32, 3, 1, 1)
self.dense1 = torch.nn.Linear(32 * 3 * 3, 128)
self.dense2 = torch.nn.Linear(128, 10)
def forward(self, x):
x = self.conv1(x)
x = F.relu(x) #relu不包含可学习参数，直接用torch.nn.functional中的函数来代替即可，而不用在__init__中定义一层
x = F.max_pool2d(x)
x = self.conv2(x)
x = F.relu(x)
x = F.max_pool2d(x)
x = self.dense1(x)
x = self.dense2(x)
return x
model = MyNet()
print(model)
运行结果为：(按构造的顺序来输出)
MyNet(
(conv1): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(conv2): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(dense1): Linear(in_features=288, out_features=128, bias=True)
(dense2): Linear(in_features=128, out_features=10, bias=True)
)
例2：
import torch.nn as nn
from collections import OrderedDict
class MyNet(nn.Module):
def __init__(self):
super(MyNet, self).__init__()
self.conv_block=nn.Sequential()
self.conv_block.add_module("conv1",nn.Conv2d(1, 3, 2, 1, 1))
self.conv_block.add_module("relu1",nn.ReLU())
self.conv_block.add_module("pool1",nn.MaxPool2d(2))
self.dense_block = nn.Sequential()
self.dense_block.add_module("dense1",nn.Linear(3 * 3 * 2, 2))
self.dense_block.add_module("relu2",nn.ReLU())
self.dense_block.add_module("dense2",nn.Linear(2, 10))
def forward(self, x):
conv_out = self.conv_block(x)
res = conv_out.view(conv_out.size(0), -1)
out = self.dense_block(res)
return out
model = MyNet()
print("model")
print(model)
print("---------------------")
print("model.children()")
for i in model.children(): #依次给出model的所有sequential的迭代器，不带sequential的名字
print(i)
print("---------------------")
print("model.named_children()")
for i in model.named_children():#依次给出model的所有sequential的迭代器，且带sequential的名字
print(i)
print("---------------------")
print("model.modules()")
for i in model.modules():#依次给出model的所有module的迭代器，不带module的名字
print(i)
print("---------------------")
print("model.named_modules()")
for i in model.named_modules():#依次给出model的所有module的迭代器，且带module的名字
print(i)
print("---------------------")
print("model.parameters()")
for i in model.parameters():#依次给出model的所有parameter的迭代器，不带parameter的名字
print(i)
print("---------------------")
print("model.named_parameters()")
for i in model.named_parameters():#依次给出model的所有parameter的迭代器，且带parameter的名字
print(i)
print("---------------------")
运行结果为：
model
MyNet(
(conv_block): Sequential(
(conv1): Conv2d(1, 3, kernel_size=(2, 2), stride=(1, 1), padding=(1, 1))
(relu1): ReLU()
(pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
)
(dense_block): Sequential(
(dense1): Linear(in_features=18, out_features=2, bias=True)
(relu2): ReLU()
(dense2): Linear(in_features=2, out_features=10, bias=True)
)
)
---------------------
model.children()
Sequential(
(conv1): Conv2d(1, 3, kernel_size=(2, 2), stride=(1, 1), padding=(1, 1))
(relu1): ReLU()
(pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
)
Sequential(
(dense1): Linear(in_features=18, out_features=2, bias=True)
(relu2): ReLU()
(dense2): Linear(in_features=2, out_features=10, bias=True)
)
---------------------
model.named_children()
('conv_block', Sequential(
(conv1): Conv2d(1, 3, kernel_size=(2, 2), stride=(1, 1), padding=(1, 1))
(relu1): ReLU()
(pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
))
('dense_block', Sequential(
(dense1): Linear(in_features=18, out_features=2, bias=True)
(relu2): ReLU()
(dense2): Linear(in_features=2, out_features=10, bias=True)
))
---------------------
model.modules()
MyNet(
(conv_block): Sequential(
(conv1): Conv2d(1, 3, kernel_size=(2, 2), stride=(1, 1), padding=(1, 1))
(relu1): ReLU()
(pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
)
(dense_block): Sequential(
(dense1): Linear(in_features=18, out_features=2, bias=True)
(relu2): ReLU()
(dense2): Linear(in_features=2, out_features=10, bias=True)
)
)
Sequential(
(conv1): Conv2d(1, 3, kernel_size=(2, 2), stride=(1, 1), padding=(1, 1))
(relu1): ReLU()
(pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
)
Conv2d(1, 3, kernel_size=(2, 2), stride=(1, 1), padding=(1, 1))
ReLU()
MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
Sequential(
(dense1): Linear(in_features=18, out_features=2, bias=True)
(relu2): ReLU()
(dense2): Linear(in_features=2, out_features=10, bias=True)
)
Linear(in_features=18, out_features=2, bias=True)
ReLU()
Linear(in_features=2, out_features=10, bias=True)
---------------------
model.named_modules()
('', MyNet(
(conv_block): Sequential(
(conv1): Conv2d(1, 3, kernel_size=(2, 2), stride=(1, 1), padding=(1, 1))
(relu1): ReLU()
(pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
)
(dense_block): Sequential(
(dense1): Linear(in_features=18, out_features=2, bias=True)
(relu2): ReLU()
(dense2): Linear(in_features=2, out_features=10, bias=True)
)
))
('conv_block', Sequential(
(conv1): Conv2d(1, 3, kernel_size=(2, 2), stride=(1, 1), padding=(1, 1))
(relu1): ReLU()
(pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
))
('conv_block.conv1', Conv2d(1, 3, kernel_size=(2, 2), stride=(1, 1), padding=(1, 1)))
('conv_block.relu1', ReLU())
('conv_block.pool1', MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False))
('dense_block', Sequential(
(dense1): Linear(in_features=18, out_features=2, bias=True)
(relu2): ReLU()
(dense2): Linear(in_features=2, out_features=10, bias=True)
))
('dense_block.dense1', Linear(in_features=18, out_features=2, bias=True))
('dense_block.relu2', ReLU())
('dense_block.dense2', Linear(in_features=2, out_features=10, bias=True))
---------------------
model.parameters()
Parameter containing:
tensor([[[[ 0.3384, -0.3845],
[-0.1613, 0.3380]]],
[[[ 0.2801, -0.4308],
[-0.4579, -0.4079]]],
[[[ 0.4746, 0.2603],
[ 0.2364, 0.3468]]]], requires_grad=True)
Parameter containing:
tensor([-0.0088, 0.0850, -0.2161], requires_grad=True)
Parameter containing:
tensor([[ 0.0889, -0.1723, -0.1162, 0.1607, -0.2197, 0.2246, -0.1110, 0.1100,
0.0349, -0.1866, 0.0958, 0.0758, -0.1890, -0.1085, -0.0107, 0.1274,
-0.0860, -0.2008],
[ 0.1167, 0.2232, 0.1577, 0.0863, 0.1839, -0.0344, 0.0345, 0.1662,
0.0696, 0.0617, -0.0599, 0.0356, 0.0662, -0.0662, 0.2344, -0.1326,
0.1135, -0.0499]], requires_grad=True)
Parameter containing:
tensor([0.1168, 0.0047], requires_grad=True)
Parameter containing:
tensor([[-0.0934, 0.3301],
[-0.5924, -0.0535],
[ 0.4757, -0.6286],
[-0.5138, -0.4037],
[ 0.4963, 0.0071],
[ 0.3045, -0.0059],
[ 0.1025, 0.2137],
[ 0.0442, 0.5752],
[ 0.0516, -0.0108],
[ 0.3253, 0.1881]], requires_grad=True)
Parameter containing:
tensor([-0.1619, -0.4607, 0.4397, -0.4366, 0.2577, 0.2420, 0.3210, -0.3229,
-0.0024, 0.6178], requires_grad=True)
---------------------
model.named_parameters()
('conv_block.conv1.weight', Parameter containing:
tensor([[[[ 0.3384, -0.3845],
[-0.1613, 0.3380]]],
[[[ 0.2801, -0.4308],
[-0.4579, -0.4079]]],
[[[ 0.4746, 0.2603],
[ 0.2364, 0.3468]]]], requires_grad=True))
('conv_block.conv1.bias', Parameter containing:
tensor([-0.0088, 0.0850, -0.2161], requires_grad=True))
('dense_block.dense1.weight', Parameter containing:
tensor([[ 0.0889, -0.1723, -0.1162, 0.1607, -0.2197, 0.2246, -0.1110, 0.1100,
0.0349, -0.1866, 0.0958, 0.0758, -0.1890, -0.1085, -0.0107, 0.1274,
-0.0860, -0.2008],
[ 0.1167, 0.2232, 0.1577, 0.0863, 0.1839, -0.0344, 0.0345, 0.1662,
0.0696, 0.0617, -0.0599, 0.0356, 0.0662, -0.0662, 0.2344, -0.1326,
0.1135, -0.0499]], requires_grad=True))
('dense_block.dense1.bias', Parameter containing:
tensor([0.1168, 0.0047], requires_grad=True))
('dense_block.dense2.weight', Parameter containing:
tensor([[-0.0934, 0.3301],
[-0.5924, -0.0535],
[ 0.4757, -0.6286],
[-0.5138, -0.4037],
[ 0.4963, 0.0071],
[ 0.3045, -0.0059],
[ 0.1025, 0.2137],
[ 0.0442, 0.5752],
[ 0.0516, -0.0108],
[ 0.3253, 0.1881]], requires_grad=True))
('dense_block.dense2.bias', Parameter containing:
tensor([-0.1619, -0.4607, 0.4397, -0.4366, 0.2577, 0.2420, 0.3210, -0.3229,
-0.0024, 0.6178], requires_grad=True))
---------------------
2.自定义层及构建神经网络模型
import torch
class MyLayer(torch.nn.Module):
'''
因为这个层实现的功能是：y=(x+bias)@weights,所以有两个参数：
权值矩阵weights
偏置矩阵bias
输入 x 的维度是(in_features,)
输出 y 的维度是(out_features,)
weights 的维度是(in_features, out_features)
bias 的维度是(in_fearures,)，注意不是out_features
'''
def __init__(self, in_features, out_features, bias=True):
super(MyLayer, self).__init__() # 和自定义模型一样，第一句话就是调用父类的构造函数
self.in_features = in_features
self.out_features = out_features
self.weight = torch.nn.Parameter(torch.randn(in_features, out_features)) # 由于weights是可以训练的，所以使用Parameter来定义
#torch.nn.Parameter继承自torch.randn，其作用将一个不可训练的类型的参数转化为可训练的类型为parameter的参数，并将这个参数绑定到module里面，成为module中可训练的参数。
if bias:
self.bias = torch.nn.Parameter(torch.randn(in_features)) # 由于bias是可以训练的，所以使用Parameter来定义
else:
self.register_parameter('bias', None)
def forward(self, input):
tmp=input+self.bias
y=torch.matmul(tmp,self.weight)
return y
N, D_in, D_out = 10, 5, 3 # 一共10组样本，输入特征为5，输出特征为3
# 先定义一个模型
class MyNet(torch.nn.Module):
def __init__(self):
super(MyNet, self).__init__() # 第一句话，调用父类的构造函数
self.mylayer1 = MyLayer(D_in,D_out)
def forward(self, x):
x = self.mylayer1(x)
return x
model = MyNet()
#创建输入、输出数据
x = torch.randn(N, D_in) #（10，5）
y = torch.randn(N, D_out) #（10，3）
#定义损失函数
loss_fn = torch.nn.MSELoss(reduction='sum') # \sigma((x_i-y_i)^2)
#设置学习率
learning_rate = 1e-3
#创建造一个Adam参数优化器类(优化器的作用为：给反向传播得到的梯度进行一些修改优化再进行更新) (除了Adam还有SGD等，但一般没Adam好用)
# params(必须):给定所有需要训练的参数,lr(可选):learning_rate,除此之外还有其他一些可选参数
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
#创建一个StepLR的scheduler(作用为:可以调整optimizer的lr),StepLR为指定的频率进行衰减，除此之外还有指数衰减ExponentialLR等
# optimizer(必须),step_size(必须):学习率下降间隔数,gamma:学习率调整倍数(默认为0.1)
# 一般以epoch为单位进行更换
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=30,gamma = 0.8 )
for epoch in range(2):
for t in range(10):
# 第一步：数据的前向传播，计算预测值p_pred
y_pred = model(x)
# 第二步：计算预测值p_pred与真实值的误差
loss = loss_fn(y_pred, y)
print(f"第{epoch+1}个epoch 的 第 {t+1} 次训练, 损失是 {loss.item()}")
# 注:在反向传播之前，将模型的梯度归零，不然这次算出的梯度会和之前的叠加
optimizer.zero_grad()
# 第三步：反向传播误差(pytorch会自动求导算梯度)
loss.backward()
# 第四步：在算完所有参数的梯度后，更新整个网络的参数
optimizer.step()
# 每次epoch对scheduler进行一次更新(即对optimizer的lr进行更新)
scheduler.step()
运行结果为(因为有随机，所以只是某一次的输出)：
第1个epoch 的 第 1 次训练, 损失是 287.74481201171875
第1个epoch 的 第 2 次训练, 损失是 286.4709167480469
第1个epoch 的 第 3 次训练, 损失是 285.20184326171875
第1个epoch 的 第 4 次训练, 损失是 283.93768310546875
第1个epoch 的 第 5 次训练, 损失是 282.678466796875
第1个epoch 的 第 6 次训练, 损失是 281.4242248535156
第1个epoch 的 第 7 次训练, 损失是 280.1751403808594
第1个epoch 的 第 8 次训练, 损失是 278.9311828613281
第1个epoch 的 第 9 次训练, 损失是 277.6924133300781
第1个epoch 的 第 10 次训练, 损失是 276.4590148925781
第2个epoch 的 第 1 次训练, 损失是 275.23089599609375
第2个epoch 的 第 2 次训练, 损失是 274.0081787109375
第2个epoch 的 第 3 次训练, 损失是 272.7908935546875
第2个epoch 的 第 4 次训练, 损失是 271.5791015625
第2个epoch 的 第 5 次训练, 损失是 270.37286376953125
第2个epoch 的 第 6 次训练, 损失是 269.1722717285156
第2个epoch 的 第 7 次训练, 损失是 267.977294921875
第2个epoch 的 第 8 次训练, 损失是 266.7879638671875
第2个epoch 的 第 9 次训练, 损失是 265.60430908203125
第2个epoch 的 第 10 次训练, 损失是 264.4263916015625
1次epoch表示对所有训练数据进行了一次训练
在实际训练时,将所有数据分成多个batch,每次送入一部分数据
batchsize:每个batch的训练样本数量
"""
import torch.nn as nn
import torch
nllloss = nn.NLLLoss( reduction='sum')
predict = torch.Tensor([[2, 3, 1],
[3, 7, 9]])
label = torch.tensor([1, 2])
output=nllloss(predict, label)
print(output)
标签：features,
self,
学习,
pytorch,
bias,
model,
True,
out
From： https://www.cnblogs.com/zhongzero/p/16708975.html