import torch
import torch.nn as nn
import torch.nn.functional as F # nn.functional.py中存放激活函數等的實現
?
@torch.no_grad()
def init_weights(m):
? ? print("xxxx:", m)
? ? if type(m) == nn.Linear:
? ? ? ? ?m.weight.fill_(1.0)
? ? ? ? ?print("yyyy:", m.weight)
?
class Model(nn.Module):
? ? def __init__(self):
? ? ? ? # 在實現自己的__init__函數時,為了正確初始化自定義的神經網絡模塊,一定要先調用super().__init__
? ? ? ? super(Model, self).__init__()
? ? ? ? self.conv1 = nn.Conv2d(1, 20, 5) # submodule(child module)
? ? ? ? self.conv2 = nn.Conv2d(20, 20, 5)
? ? ? ? self.add_module("conv3", nn.Conv2d(10, 40, 5)) # 添加一個submodule到當前module,等價于self.conv3 = nn.Conv2d(10, 40, 5)
? ? ? ? self.register_buffer("buffer", torch.randn([2,3])) # 給module添加一個presistent(持久的) buffer
? ? ? ? self.param1 = nn.Parameter(torch.rand([1])) # module參數的tensor
? ? ? ? self.register_parameter("param2", nn.Parameter(torch.rand([1]))) # 向module添加參數
?
? ? ? ? # nn.Sequential: 順序容器,module將按照它們在構造函數中傳遞的順序添加,它允許將整個容器視為單個module
? ? ? ? self.feature = nn.Sequential(nn.Linear(2, 2), nn.Linear(2, 2))
? ? ? ? self.feature.apply(init_weights) # 將fn遞歸應用于每個submodule,典型用途為初始化模型參數
? ? ? ? self.feature.to(torch.double) # 將參數數據類型轉換為double
? ? ? ? cpu = torch.device("cpu")
? ? ? ? self.feature.to(cpu) # 將參數數據轉換到cpu設備上
?
? ? def forward(self, x):
? ? ? ?x = F.relu(self.conv1(x))
? ? ? ?return F.relu(self.conv2(x))
?
model = Model()
print("## Model:", model)
?
model.cpu() # 將所有模型參數和buffers移動到CPU上
model.float() # 將所有浮點參數和buffers轉換為float數據類型
model.zero_grad() # 將所有模型參數的梯度設置為零
?
# state_dict:返回一個字典,保存著module的所有狀態,參數和persistent buffers都會包含在字典中,字典的key就是參數和buffer的names
print("## state_dict:", model.state_dict().keys())
?
for name, parameters in model.named_parameters(): # 返回module的參數(weight and bias)的迭代器,產生(yield)參數的名稱以及參數本身
? ? print(f"## named_parameters: name: {name}; parameters size: {parameters.size()}")
?
for name, buffers in model.named_buffers(): # 返回module的buffers的迭代器,產生(yield)buffer的名稱以及buffer本身
? ? print(f"## named_buffers: name: {name}; buffers size: {buffers.size()}")
?
# 注:children和modules中重復的module只被返回一次
for children in model.children(): # 返回當前module的child module(submodule)的迭代器
? ? print("## children:", children)
?
for name, children in model.named_children(): # 返回直接submodule的迭代器,產生(yield) submodule的名稱以及submodule本身
? ? print(f"## named_children: name: {name}; children: {children}")
?
for modules in model.modules(): # 返回當前模型所有module的迭代器,注意與children的區別
? ? print("## modules:", modules)
?
for name, modules in model.named_modules(): # 返回網絡中所有modules的迭代器,產生(yield)module的名稱以及module本身,注意與named_children的區別
? ? print(f"## named_modules: name: {name}; module: {modules}")
?
model.train() # 將module設置為訓練模式
model.eval() # 將module設置為評估模式
?
print("test finish")

import torch
import torch.nn as nn

# 括號中加入nn.Module（父類）。Test2變成子類，繼承父類（nn.Module）的所有特性。
class Test2(nn.Module):  
    def __init__(self):  # Test2類定義初始化方法
       super(Test2, self).__init__()  # 父類初始化
       self.M = nn.Parameter(torch.ones(10))
        
    def weightInit(self):
        print('Testing')

    def forward(self, n):
        # print(2 * n)
        print(self.M * n)
        self.weightInit()

# 調用方法
network = Test2()
network(2)  # 2賦值給forward(self, n)中的n。
……省略一部分代碼……
# 因為Test2是nn.Module的子類，所以也可以執行父類中的方法。如：
model_dict = network.state_dict()  # 調用父類中的方法state_dict()，將Test2中訓練參數賦值model_dict。
for k, v in model_dict.items():  # 查看自己網絡參數各層名稱、數值
	print(k)  # 輸出網絡參數名字
    # print(v)  # 輸出網絡參數數值