import torch
from torch import nn
from torch.nn import init

net = nn.Sequential(nn.Linear(4, 3), nn.ReLU(), nn.Linear(3, 1))  # pytorch已经进行默认初始化

print(net)
X = torch.rand(2, 4)
Y = net(X).sum()
for param in net.parameters():
    print(param.grad, "net有四个模型参数")
'''
-------------------------访问模型参数
对于Sequential实例中含有模型参数的层，可以通过Module类的parameters()方法来访问所有参数（通过迭代器型形式返回）
'''
print(type(net.named_parameters()))  # 该函数除了返回参数Tensor还会返回名字
for name, param in net.named_parameters():
    print(name, param.size())
# 返回的名字自动加上了Sequential中模块所在层数的索引作为前缀
# 0.weight torch.Size([3, 4])
# 0.bias torch.Size([3])
# 2.weight torch.Size([1, 3])
# 2.bias torch.Size([1])
# 访问单层参数
for name, param in net[0].named_parameters():
    print(name, param.size(), type(param))


# 返回的param的类型是torch.nn.parameter.Parameter,是Tensor的子类
# 如果一个Tensor是Parameter的话，那么该Tensor会自动添加到模型的参数列表中
class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        # 实际上就是生成了一个初始化自定义的权重参数，用于进行训练
        self.weight1 = nn.Parameter(torch.rand(20, 20))
        self.weight2 = torch.rand(20, 20)

    def forward(self, x):
        pass


n = MyModel()
for name, param in n.named_parameters():
    print(name)

weight_0 = list(net[0].parameters())[0]  # 返回的是一个tensor数据
print(weight_0.data)  # 使用tensor.data访问参数数值
Y.backward()
print(weight_0.grad)  # 使用tensor.grad访问梯度

'''
-------------------------------------------初始化模型参数
不同类型的layer具体采用的哪一种初始化方法是不一样的
'''
# 接下来将权重参数初始化为均值为0，标准差为0.01的正态随机分布，并依然将偏置设置为0
for name, param in net.named_parameters():
    if 'weight' in name:
        init.normal_(param, mean=0, std=0.01)
        print(name, param.data)

# 使用常数来初始化权重参数
for name, param in net.named_parameters():
    if 'bias' in name:
        init.constant_(param, val=0)
        print(name, param.data)

'''
---------------------------------自定义初始化方法
当我们想要的初始化方法没有函数提供时，需要自己实现一个初始化方法
'''


# 先介绍init.normal_方法是怎么被定义的
def normal_(tensor, mean=0, std=1):
    with torch.no_grad():
        return tensor.normal_(mean, std)


# 自定义初始化方法 在下面函数中，令权重概率一般概率初始化为0，另一半初始化概率为[-10,-5]和[5,10]两个区间
# 里的均匀分布的随机函数
def init_weight_(tensor):
    with torch.no_grad():
        tensor.uniform_(-10, 10)  # 从-10~10中均匀随机选取tensor.size()大小的数据进行填充
        tensor *= (tensor.abs() >= 5).float()
        # 先确定tensor中绝对值大于5的元素，然后float函数对其独热化，在用原tensor对其相乘，则独热向量为0
        # 处，相乘为0，独热向量为1处，相乘则为均匀取值之后的tensor值
        # 因为uniform_()是均匀随机取值，所以[-10，-5],[5,10]和(-5,5)两者之间的取值概率分布是一样的，
        # 所以判断条件tensor绝对值大于5则能排除一半的区间元素，即位于(-5,5)之间的元素
        # 所以上面的概率区间就能分离出来


for name, param in net.named_parameters():
    if 'weight' in name:
        init_weight_(param)
        print(name, param.data)

# 还可以通过改变这些参数的data来改写模型参数值的同时不会影响梯度
for name, param in net.named_parameters():
    if 'bias' in name:
        param.data += 1  # 模型参数值不是梯度值，梯度值是进行模型训练时反向传播才会产生的
        print(name, param.data)

'''
------------------------------------------------共享模型参数
在多个层之间共享模型参数
Module类中的forward函数里多次调用同一个层可以实现多层共享模型参数
除此之外，如果传入Sequential的模块是同一个Module实例也可以共享
'''
linear = nn.Linear(1, 1, bias=False)
net = nn.Sequential(linear, linear)
print(net)
for name, param in net.named_parameters():
    init.constant_(param, val=3)
    print(name, param.data)  # 输出的参数只有一个，说明两个linear层共享一个模型参数
# 在内存中，这两个线性层其实一个对象

'''
--------------------所以模型参数共享不共享，可以看是否是nn.Linear(a,b)这种实例化是否是同一个，
比如上面的就是同一个实例化对象
'''
# 因为模型参数里包括了梯度，所以在反向传播计算时，这些共享参数的梯度是累加的
x = torch.ones(1, 1)
y = net(x).sum()
print(y)
y.backward()
print(net[0].weight.grad)  # 单次梯度是3，两次所以是6  模型为y=3x