课程笔记：Containers：Sequential、ModuleList和ModuleDict

Containers:
(1) nn.Sequential：按顺序的包装多个网络层，常用于block构建
(2) nn.ModuleList：像python的list一样包装多个网络层（迭代性）
(3) nn.ModuleDict：像python的dict一样包装多个网络层（通过命名索引网络层）（索引性）

一、容器Sequential
nn.Sequential是nn.Module的容器，用于按顺序包装一组网络层
顺序性：个网络层级之间是严格按顺序构建
自带forward(): 自带的forward里，通过for循环依次执行前向传播运算

nn.Sequentia是nn.Module的容器，用于按顺序包装一组网络层，使这组网络层被看作使整体（或子模块）
Sequential继承自Module类，则有8个有序字典去管理它的属性
例如：对LeNet：

卷积、池化、卷积、池化包装成一个sequential,fc1、fc2、fc3也包装成一个sequential，将两个sequential组装起来就是LeNet

Sequential:

class LeNetSequential(nn.Module):
	def __init__(self, classes):
		#继承自Module,有8个有序字典
		super(LeNetSequential,self).__init__()
		self.classes = classes
		self.features = nn.Sequential(
			nn.Conv2d(3, 6, 5),
			nn.ReLU(),
			nn.MaxPool2d(kernel_size=2, stride=2)
			nn.Conv2d(6, 16, 5),
			nn.ReLU(),
			nn.MaxPool2d(kernel_size=2, stride=2),)

		self.classifier = nn.Sequential(
			nn.Linear(16*5*5, 120),
			nn.ReLU(),
			nn.Linear(120, 84),
			nn.ReLU(),
			nn.Linear(84, self.classes),)
		
	def forward(self, x):
		x = self.features(x)
		x = x.view(x.size()[0],-1)
		x = self.classifier(x)
		return x
	
#网络实例化（用的是__init__部分，构建子网络）
net = LeNetSequential(2)
#模拟图片
fake_img = torch.randn((4, 3, 32, 32), dtype=torch.float32)
#调用网络（用的是forward部分，拼接子网络）
out = net(fake_img)			

class LeNetSequentialOrderDict(nn.Module):
	def __init__(self, classes):
		#继承自Module,有8个有序字典
		super(LeNetSequentialOrderDict, self).__init__()
		self.features = nn.Sequential(OrderDict({
			'conv1': nn.Conv2d(3, 6, 5),
			'relu1': nn.ReLU(),
			'pool1': nn.Maxpool2d(kernel_size=2, stride=2),
			'conv2': nn.Conv2d(6, 16, 5),
			'relu2': nn.ReLU(),
			'pool2': nn.Maxpool2d(kernel_size=2, stride=2),
		}))

		self.classifer = nn.Sequential(OrderDict({
			'fc1': nn.Linear(16*5*5, 120),
			'relu3': nn.ReLU(),
			'fc2': nn.Linear(120, 84),
			'relu4': nn.ReLU(),
			'fc3': nn.Linear(84, classes),
		}))
	def forward(self, x):
		x = self.features(x)
		x = x.view(x.size()[0], -1)
		x = self.classifer(x)
		return x
#网络实例化（用的是__init__部分，构建子网络）
net = LeNetSequentialOrderDict(2)
#模拟图片
fake_img = torch.randn((4, 3, 32, 32), dtype=torch.float32)
#调用网络（用的是forward部分，拼接子网络）
out = net(fake_img)			

二、容器ModuleList
nn.ModuleList是nn.Module的容器，用于包装一组网络层，以迭代的方式调用网络层：
append()：在ModuleList后面添加网络层
extend()：拼接两个ModuleList
insert()：指定在ModuleList中位置插入网络层

class ModuleList(nn.Module):
	def __init(self):
		super(ModuleList, self).__init__()
		self.linears = nn.ModuleList([nn.Linear(10,10)for i in range(20)])
	
	def forward(self, x):
		for i, linear in enumerate(self.linears):
			x = linear(x)
		return x
#网络实例化（用的是__init__部分，构建子网络）
net = ModuleList()
#输入的数据
fake_data = torch.ones((10, 10))
#调用网络
output = net(fake_data)

三、容器之ModuleDict
nn.容器之ModuleDict是nn.module的容器，用于包装一组网络层，以索引的方式调用网络层
主要方法：
clear()：清空容器之ModuleDict
items()：返回可迭代的键值对（key-value pairs）
keys()：返回字典的键（key）
values()：返回字典的值（value）
pop()：返回一键值对，并从字典中删除

class ModuleDict(nn.Module):
	def __init__(self):
		super(ModuleDict, self).__init__()
		self.choices = nn.ModuleDict({
			'conv': nn.Conv2d(10, 10, 3),
			'pool': nn.Maxpool2d(3)
		})
		
		self.activation = nn.ModuleDict({
			'relu': nn.ReLU(),
			'prelu': nn.PReLU()
		})
	def forward(self, x, choice, act):
		x = self.choices[choice](x)
		x = self.activation[act](x)
		return x
#网络实例化（用的是__init__部分，构建子网络）
net = ModuleDict()
#输入数据
fake_img = torch.randn((4, 10, 32, 32))
#调用函数
output = net(fake_img, 'conv', 'relu')