Pytorch动态改变网络结构(Dynamically add or delete layers)

王 茂南
王 茂南
王 茂南
3081
文章
75
评论
2019年4月21日07:39:20
评论1 2440字阅读8分8秒
摘要这一篇主要介绍在Pytorch中如何动态改变网络的结构，使用这种方式会方便网络的编写，特别是一些比较深的结构。

介绍

很多时候，我们在使用Pytorch时，想要能够动态的改变网络，希望使用for循环进行add layers，这里记录一下找到的几种方式。可以直接看方式三。

动态改变方式

下面介绍三种方式，可以直接看方式三，个人比较喜欢用方式三，也是比较好用的一种方式。

方式一

通过moduleList来进行改变。但是有缺点, 需要自己向ModuleList中增加结构, 还是麻烦的。可以看下面的例子。

  1. class MyModel(nn.Module):
  2.     def __init__(self, in_features, nb_classes, nb_hidden_layer,
  3.         hidden_size, act=nn.ReLU):
  4.         super(MyModel, self).__init__()
  5.         self.act = act()
  7.         self.fc1 = nn.Linear(in_features, hidden_size)
  8.         self.fcs = nn.ModuleList([nn.Linear(hidden_size, hidden_size),
  9.                                   nn.Linear(hidden_size, hidden_size),
  10.                                   nn.Linear(hidden_size, hidden_size)])
  11.         self.out = nn.Linear(hidden_size, nb_classes)
  13.     def forward(self, x):
  14.         x = self.act(self.fc1(x))
  15.         for l in self.fcs:
  16.             x = F.relu(l(x))
  17.         x = self.out(x)
  18.         return x
  20. model = MyModel(2, 3, 4, 5, nn.ReLU)
  21. print(model)
Pytorch动态改变网络结构(Dynamically add or delete layers)

方式二

通过OrderedDict来实现，这种方式还是比较方便的。

  1. from collections import OrderedDict
  3. class model(nn.Module):
  4.     def __init__(self, n_layers):
  6.         super(model,self).__init__()
  8.         layers = OrderedDict()
  9.         for i in range(n_layers):
  10.             layers[str(i)] = nn.Linear(5,5)
  12.         self.layers = nn.Sequential(layers)
  14. model(n_layers=5)
Pytorch动态改变网络结构(Dynamically add or delete layers)

方式三

使用传参的方式进行动态改变网络结构，需要注意的是，这里在传入网络的时候，需要使用layers进行操作。详细的介绍可以查看这篇文章：Python入门教程[3]-函数

  1. class model(nn.Module):
  2.     def __init__(self, n_layers):
  3.         super(model,self).__init__()
  4.         layers = []
  5.         for i in range(n_layers):
  6.             layers.append(nn.Linear(5,5))
  7.         # 组成nn.Sequential
  8.         # 这里传参需要使用 *layers, 将参数打包
  9.         self.layers = nn.Sequential(*layers)
  11.     def forward(self,x):
  12.         x = self.layers(x)
  13.         return(x)
  15. model(n_layers=5)
Pytorch动态改变网络结构(Dynamically add or delete layers)

一个实例

下面，放一个我们在具体使用的时候，会书写的结构。

  1. # 每一层加上BatchNorm和Relu
  2. class model(nn.Module):
  3.     def __init__(self, n_layers):
  4.         super(model,self).__init__()
  5.         layers = []
  6.         for i in range(n_layers):
  7.             layers.append(nn.Linear(5,5))
  8.             layers.append(nn.BatchNorm1d(5))
  9.             layers.append(nn.ReLU())
  10.         # 组成nn.Sequential
  11.         # 这里传参需要使用 *layers, 将参数打包
  12.         self.input = nn.Linear(2,5)
  13.         self.relu = nn.ReLU()
  14.         self.layers = nn.Sequential(*layers)
  15.         self.output = nn.Linear(5,2)
  16.     def forward(self,x):
  17.         out = self.input(x)
  18.         out = self.relu(out)
  19.         out = self.layers(out)
  20.         out = self.output(out)
  21.         return(out)
  23. mymodel = model(n_layers=5)
  24. print(mymodel)
Pytorch动态改变网络结构(Dynamically add or delete layers)

看一下输入一个值的效果：

Pytorch动态改变网络结构(Dynamically add or delete layers)

参考资料

Pytorch动态改变网络结构(Dynamically add or delete layers)

  • 微信公众号
  • 关注微信公众号
  • weinxin
  • QQ群
  • 我们的QQ群号
  • weinxin
王 茂南
  • 本文由 发表于 2019年4月21日07:39:20
  • 转载请务必保留本文链接：https://mathpretty.com/10314.html
匿名

发表评论

匿名网友 填写信息

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: