# 自动微分模块torch.autograd负责自动计算张量操作的梯度，具有自动求导功能。自动微分模块是构成神经网络训练的必要模块，可以实现网络权重参数的更新，使得反向传播算法的实现变得简单而高效

import torch

# 1. **张量**

#    Torch中一切皆为张量，属性requires_grad决定是否对其进行梯度计算。默认是 False，如需计算梯度则设置为True。

# 2. **计算图**：

#    torch.autograd通过创建一个动态计算图来跟踪张量的操作，每个张量是计算图中的一个节点，节点之间的操作构成图的边。

# 3. **反向传播**

#    使用tensor.backward()方法执行反向传播，从而计算张量的梯度。这个过程会自动计算每个张量对损失函数的梯度。

# 4. **梯度**

#    计算得到的梯度通过tensor.grad访问，这些梯度用于优化模型参数，以最小化损失函数。

# 张量的梯度计算 导数值

# 使用tensor.backward() 求tensor的导数值 会先求 tensor的导函数 然后带入值 这个tensor 是关于另一个tensor的表达式 原来的tensor是一组数据浮点型 这个tensor是一个函数

# 创建 原来的tensor时 要设置 requires_grad=True 表示这个tensor要被用于求导 设置了之后 tensor每次参加运算都会被求导一次 吃性能

# 调用backward 后 原来的tensor 就有个grad属性 这个属性是 导数值

# 一个 标量映射成另一个标量 对这个映射的结果做反向传播 结果在原来 标量里面

#

def demo1():

    t1= torch.tensor(7.0, requires_grad=True, dtype=torch.float32)

    t2= t1**2 + 2 * t1 + 7

    t2.backward()

    print(t1.grad)

   

# 向量的梯度计算

# 映射的结果必须是一个标量才行 对映射进行一下处理让他为标量 比如求和 或者平均值

def demo2():

    torch.manual_seed(666)

    t1=torch.rand(20,4, requires_grad=True, dtype=torch.float32)

    t2= t1**2 + 2 * t1 + 7

    t2=t2.sum()

    t2.backward()

    print(t1.grad) # 返回的是原向量每一个元素的梯度 是一个跟原来向量size一样的tensor

# 多标量梯度计算 就是映射式子里面有两个未知数 两个变量tensor 就是求了一个偏导

# 两个变量就都有了grad

def demo3():

    t1= torch.tensor(7.0, requires_grad=True, dtype=torch.float32)

    t2= torch.tensor(5.0, requires_grad=True, dtype=torch.float32)

    t3= t1**2 + 2 * t1 + 7+t2**2

    t3.backward()

    print(t1.grad)

    print(t2.grad)

# 多向量也差不多不过要先 变为标量

# 理解 一个tensor 代表一个W tensor里面代表这个W的取值情况 ，然后当这些W取值的时候 Y应该也有个对应的值组成了一个数据集 有x和y的 这样就可以 算梯度了

# y.backward()的时候 相当于把y 表达式的 导函数求出来存在y的一个属性里面 然后再把y表达式中的变量的值传进来计算导数 再返回给 变量的grad属性里面

def demo4():

    torch.manual_seed(666)

    t1=torch.rand(20,4, requires_grad=True, dtype=torch.float32)

    torch.manual_seed(3)

    t2=torch.rand(20,4, requires_grad=True, dtype=torch.float32)

    t3= t1**2 + 2 * t1 + 7+t2**2

    t3=t3.sum()

    t3.backward()

    print(t1.grad)

    print(t2.grad)

# 梯度的上下文控制

# 梯度计算的上下文控制和设置对于管理计算图、内存消耗、以及计算效率至关重要。下面我们学习下Torch中与梯度计算相关的一些主要设置方式。

# 映射函数y的requires_grad默认为ture 不用的话占性能 可以手动关了

def demo4():

    x=torch.rand(20,4, requires_grad=True, dtype=torch.float32)

    # 使用with语法 torch.no_grad() 关闭梯度 with torch.no_grad(): 局部作用 再with里面所有的torch都没有requires_grad

    with torch.no_grad():

        y = x**2 + 2 * x + 3 # 没有梯度的y

    print(y.requires_grad)  # False

    # 或者装饰器也可以

    @torch.no_grad()

    def test():

         y = x**2 + 2 * x + 3 # 没有梯度的y

         return y

    # 全局设置 设置了之后后面代码全部都没有梯度了

    torch.set_grad_enabled(False)

# 累积梯度 多次backward 的时候每次给变量返回的导数值 会累加起来 而不是覆盖 因为不管你怎么变y的表达式  都会给y里面的变量 返回个梯度 让他存起来

def demo5():

    torch.manual_seed(666)

    t1=torch.rand(20,4, requires_grad=True, dtype=torch.float32)

    for x in range(3):

        t2= t1**2 + 2 * t1 + 7

        t2=t2.sum()

        t2.backward()

        print(t1.grad)

# 梯度清空 每次backward 把梯度清空了 tensor.grad.zero_()

def demo6():

    torch.manual_seed(666)

    t1=torch.rand(20,4, requires_grad=True, dtype=torch.float32)

    for x in range(3):

        t2= t1**2 + 2 * t1 + 7

        t2=t2.sum()

        if t1.grad != None:

            t1.grad.zero_()

        t2.backward()

        print(t1.grad)

# 梯度更新 手动

def demo7():

    # 定义初始W 学习率和 训练轮次

    torch.manual_seed(666)

    w1=torch.rand(3,3,3,requires_grad=True)

    torch.manual_seed(6)

    w2=torch.rand(3,3,3,requires_grad=True)      

    print(w1,w2)

    lr=0.1

    turn=100        

    # 开始训练 假设 均方差公式

    for x in range(turn):

        y=w1**2+w2**2+2*w1+2*w2+100

        # 清空梯度

        if w1.grad!=None:

            w1.grad.zero_()

        if w2.grad!=None:

            w2.grad.zero_()

        # 计算梯度

        y=y.mean()

        y.backward()

        # 得到当前梯度

        # 梯度更新 使用tensor.data

        w1.data=w1.data-lr*w1.grad

        w2.data=w1.data-lr*w2.grad

    # 得到训练完后的 w值 可以保存 这个时候w有requires_grad=Ture 保存的时候 去掉用detach 下次使用 load出来

    print(w1,w2)

    torch.save(w1.detach(),"assets/w/w1.plt")

    torch.save(w2.detach(),"assets/w/w2.plt")

# 注意事项

# 当requires_grad=True时，在调用numpy转换为ndarray时报错

# 使用detach()方法创建张量的叶子节点即可 tensor.detach().numpy()

# detach() 就是原来   requires_grad=Flase的tensor 和原来的tensor 浅拷贝 改一个两个都变

def test():

    torch.manual_seed(666)

    w1=torch.rand(3,3,3,requires_grad=True)

    print(w1)

    w2=w1.detach()

    print(w2)

    w2[:,:,1]=100

    print(w1)

    print(w2)

   

if __name__=="__main__":

    # demo1()

    # demo2()

    # demo3()

    # demo4()

    # demo5()

    # demo6()

    # demo7()

    test()