Day 02 - PyTorch框架使用

学习目标

• 掌握张量的基本运算
• 掌握张量的按元素相乘和矩阵乘法
• 掌握张量的常用运算函数
• 掌握张量的索引操作
• 掌握张量的形状操作
• 掌握张量的拼接
• 实现自动微分模块入门案例
• 了解梯度下降法求最小值案例

# 导包
import torch
import numpy as np
import matplotlib.pyplot as plt
# 设置中文字体
plt.rcParams['font.sans-serif'] = ['SimHei']  # 微软雅黑
plt.rcParams['axes.unicode_minus'] = False            # 解决负号显示问题
# 设置设备
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

day02_01_张量的按元素相乘和矩阵乘法

• 按元素相乘(Hadamard)： A * B，相同形状的张量对应位置的元素相乘。要求两个张量的形状相同。
• 矩阵乘法: A @ B, 第一个矩阵A的行与第二个矩阵B的列的对应元素相乘，比如矩阵A.shape: (n, m)，矩阵B.shape: (m, p), 两个矩阵乘法运算 shape 为: (n, p)。对于高维矩阵，要求A.shape[-1] = B.shape[-2]

两个矩阵的按元素乘法称为Hadamard积（Hadamard product）（数学符号\(\odot\)）

矩阵\(\mathbf{A} \in \mathbb{R}^{m \times n}\)(第\(i\)行和第\(j\)列的元素是\(a_{ij}\))
和\(\mathbf{B} \in \mathbb{R}^{m \times n}\)(第\(i\)行和第\(j\)列的元素是\(b_{ij}\))的Hadamard积为：
$$
\mathbf{A} \odot \mathbf{B} =
\begin{bmatrix}
a_{11} b_{11} & a_{12} b_{12} & \dots & a_{1n} b_{1n} \
a_{21} b_{21} & a_{22} b_{22} & \dots & a_{2n} b_{2n} \
\vdots & \vdots & \ddots & \vdots \
a_{m1} b_{m1} & a_{m2} b_{m2} & \dots & a_{mn} b_{mn}
\end{bmatrix}.
$$

假设两个 2D 张量 A 和 B，形状都是 (3,4)：

张量 A：

张量 B：

按元素相乘（矩阵形式，显示计算过程）

"""
案例：
    演示 张量的按元素相乘和矩阵乘法
按元素相乘：
    要求：两个张量的形状一样，A为(m,n)，B为(m,n)
    运算：对应位置的元素直接相乘，得到一个新的张量，形状也一样
    API:
        t1 * t2
        torch.mul(t1, t2)
        t1.mul(t2)
        注意：tensor.x, torch.x(tensor,)，比如torch.add(t1, t2)表示加法
矩阵乘法：
    要求：第一个张量的列数 = 第二个张量的行数,
    t1的形状是 (m, n), t2的形状是 (n, p)，结果张量的形状是 (m, p)
    运算：第一个张量的行向量 和 第二个张量的列向量 做点积，也就是先相乘，再求和
    API:
        t1 @ t2
        t1.matmul(t2)
        torch.matmul(t1, t2)
        t1.dot(t2) 只能用于一维张量的点积运算
        torch.dot(t1, t2) 只能用于一维张量的点积运算

需要掌握的：
    t1 * t2
    t1 @ t2
"""

# 导包
import torch

# 0.设置随机种子
torch.random.manual_seed(6)

# 1.创建两个张量, 3*4
t1 = torch.randint(1, 10, (3,4))
print(f"t1: {t1}, shape: {t1.shape}, dtype元素类型：{t1.dtype}")
t2 = torch.randint(1, 10, (3,4))
print(f"t2: {t2}, shape: {t2.shape}, dtype元素类型：{t2.dtype}")
print("-"*60)
# 2.按元素相乘, t1*t2
t3 = t1*t2
print(f"t1*t2: {t3}, shape: {t3.shape}, dtype元素类型：{t3.dtype}")
print("-"*60)

t1: tensor([[9, 7, 7, 3],
        [8, 1, 3, 4],
        [2, 1, 6, 8]]), shape: torch.Size([3, 4]), dtype元素类型：torch.int64
t2: tensor([[8, 6, 8, 6],
        [4, 3, 2, 5],
        [7, 4, 6, 9]]), shape: torch.Size([3, 4]), dtype元素类型：torch.int64
------------------------------------------------------------
t1*t2: tensor([[72, 42, 56, 18],
        [32,  3,  6, 20],
        [14,  4, 36, 72]]), shape: torch.Size([3, 4]), dtype元素类型：torch.int64
------------------------------------------------------------

矩阵乘法（matrix-matrix multiplication）
要求：A.shape[-1]=B.shape[-2]

有两个矩阵\(\mathbf{A} \in \mathbb{R}^{n \times k}\)和\(\mathbf{B} \in \mathbb{R}^{k \times m}\)：

用行向量\(\mathbf{a}^\top_{i} \in \mathbb{R}^k\)表示矩阵\(\mathbf{A}\)的第\(i\)行，用列向量\(\mathbf{b}_{j} \in \mathbb{R}^k\)作为矩阵\(\mathbf{B}\)的第\(j\)列。

$$\mathbf{A}=
\begin{bmatrix}
\mathbf{a}^\top_{1} \
\mathbf{a}^\top_{2} \
\vdots \
\mathbf{a}^\top_n \
\end{bmatrix},
\quad \mathbf{B}=\begin{bmatrix}
\mathbf{b}{1} & \mathbf{b} \} & \cdots & \mathbf{b}_{m
\end{bmatrix}.
$$
要生成矩阵积\(\mathbf{C} = \mathbf{A}\mathbf{B}\)，将每个元素\(c_{ij}\)计算为点积\(\mathbf{a}^\top_i \mathbf{b}_j\):

假设两个 2D 张量 A 和 B，形状分别为 (3,4) 和 (4,3)：

张量 A：

张量 B：

矩阵乘法计算过程

矩阵乘法 C = A @ B，C 的形状为 (3,3)，每个元素 C[i,j] 为 A 的第 i 行与 B 的第 j 列对应元素乘积之和：

对应计算结果

说明：
- 矩阵乘法的每个元素是 行向量与列向量的点积。
- A 的列数必须等于 B 的行数，结果矩阵 C 的形状为 (A行数, B列数)。

# 3.创建两个张量，做矩阵乘法, (3,4) @ (4,3) --> (3,3)
t1 = torch.randint(1, 10, (3,4))
t2 = torch.randint(1, 10, (4,3))
# 演示 矩阵乘法
t3 = t1 @ t2
print(f"t1: {t1}, shape: {t1.shape}, dtype元素类型：{t1.dtype}")
print(f"t2: {t2}, shape: {t2.shape}, dtype元素类型：{t2.dtype}")
print(f"t1 @ t2: {t3}, shape: {t3.shape}, dtype元素类型：{t3.dtype}")

t1: tensor([[8, 5, 6, 7],
        [6, 1, 1, 8],
        [5, 4, 9, 3]]), shape: torch.Size([3, 4]), dtype元素类型：torch.int64
t2: tensor([[9, 9, 6],
        [3, 8, 6],
        [5, 7, 5],
        [3, 2, 7]]), shape: torch.Size([4, 3]), dtype元素类型：torch.int64
t1 @ t2: tensor([[138, 168, 157],
        [ 86,  85, 103],
        [111, 146, 120]]), shape: torch.Size([3, 3]), dtype元素类型：torch.int64

# 演示3维张量的矩阵乘法
import torch

# 创建张量
t1 = torch.arange(30).reshape(3,2,5)
t2 = torch.arange(30).reshape(3,5,2)
# 矩阵乘法
t3 = torch.matmul(t1, t2)

print(f"t1: {t1}")
print(f"t2: {t2}")
print(f"t3=t1@t2: {t3.shape}")

t1: tensor([[[ 0,  1,  2,  3,  4],
         [ 5,  6,  7,  8,  9]],

        [[10, 11, 12, 13, 14],
         [15, 16, 17, 18, 19]],

        [[20, 21, 22, 23, 24],
         [25, 26, 27, 28, 29]]])
t2: tensor([[[ 0,  1],
         [ 2,  3],
         [ 4,  5],
         [ 6,  7],
         [ 8,  9]],

        [[10, 11],
         [12, 13],
         [14, 15],
         [16, 17],
         [18, 19]],

        [[20, 21],
         [22, 23],
         [24, 25],
         [26, 27],
         [28, 29]]])
t3=t1@t2: torch.Size([3, 2, 2])

点积（Dot Product）

给定两个向量\(\mathbf{x},\mathbf{y}\in\mathbb{R}^d\)，
点积（dot product）\(\mathbf{x}^\top\mathbf{y}\)
（或\(\langle\mathbf{x},\mathbf{y}\rangle\)）
是相同位置的按元素乘积的和：\(\mathbf{x}^\top \mathbf{y} = \sum_{i=1}^{d} x_i y_i\)。

# 4. 演示 点积
# 把t1,t2转为一维张量，做点积运算
t1 = t1.reshape(-1)
t2 = t2.reshape(-1)
print(f"t1: {t1}, shape: {t1.shape}, dtype元素类型：{t1.dtype}")
print(f"t2: {t2}, shape: {t2.shape}, dtype元素类型：{t2.dtype}")
t3 = t1.dot(t2)
print(f"t1.dot(t2): {t3}, shape: {t3.shape}, dtype元素类型：{t3.dtype}")

t1: tensor([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
        18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]), shape: torch.Size([30]), dtype元素类型：torch.int64
t2: tensor([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
        18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]), shape: torch.Size([30]), dtype元素类型：torch.int64
t1.dot(t2): 8555, shape: torch.Size([]), dtype元素类型：torch.int64

day02_02_张量的常用运算函数

• sum(), mean(), max(), min()

"""
案例：
    演示 张量的常用运算函数
涉及到的API：
    sum(), mean(), max(), min()         -> 有dim参数，可以指定维度/轴进行操作，会改变张量的形状
    pow()/**, sqrt(), exp(), log(), log2(), log10() -> 无dim参数，对张量中的所有元素进行运算，不会改变张量的形状
需要掌握的：
    sum(), mean(), max(), min(), **

"""

# 导包
import torch

# 0.设置随机种子
torch.manual_seed(6)
# 1.创建一个张量, 3*4*5
t1 = torch.randint(1, 10, (3,4,5))
print(f"t1: {t1}, shape: {t1.shape}, dtype元素类型：{t1.dtype}")
print("-"*60)
# 2.演示 sum
print(f"t1.sum(): {t1.sum()}")  # 标量
# 指定dim=0
print(f"t1.sum(dim=0): {t1.sum(dim=0)}, shape: {t1.sum(dim=0).shape}")    # 张量
# 指定dim=1
print(f"t1.sum(dim=1): {t1.sum(dim=1)}, shape: {t1.sum(dim=1).shape}")    # 张量
print("-"*60)
# 指定dim=2
print(f"t1.sum(dim=2): {t1.sum(dim=2)}, shape: {t1.sum(dim=2).shape}")    # 张量

t1: tensor([[[9, 7, 7, 3, 8],
         [1, 3, 4, 2, 1],
         [6, 8, 8, 6, 8],
         [6, 4, 3, 2, 5]],

        [[7, 4, 6, 9, 8],
         [5, 6, 7, 6, 1],
         [1, 8, 5, 4, 9],
         [3, 9, 9, 6, 3]],

        [[8, 6, 5, 7, 5],
         [3, 2, 7, 7, 8],
         [2, 2, 3, 6, 4],
         [7, 8, 8, 2, 5]]]), shape: torch.Size([3, 4, 5]), dtype元素类型：torch.int64
------------------------------------------------------------
t1.sum(): 322
t1.sum(dim=0): tensor([[24, 17, 18, 19, 21],
        [ 9, 11, 18, 15, 10],
        [ 9, 18, 16, 16, 21],
        [16, 21, 20, 10, 13]]), shape: torch.Size([4, 5])
t1.sum(dim=1): tensor([[22, 22, 22, 13, 22],
        [16, 27, 27, 25, 21],
        [20, 18, 23, 22, 22]]), shape: torch.Size([3, 5])
------------------------------------------------------------
t1.sum(dim=2): tensor([[34, 11, 36, 20],
        [34, 25, 27, 30],
        [31, 27, 17, 30]]), shape: torch.Size([3, 4])

# 3.演示 mean
t1 = t1.to(torch.float32)
print(f"t1.mean(): {t1.mean()}")  # 标量
# 指定dim=0
print(f"t1.mean(dim=0): {t1.mean(dim=0)}")    # 张量
# 指定dim=1
print(f"t1.mean(dim=1): {t1.mean(dim=1)}")    # 张量
print("-"*60)
# 4.演示 max
t1 = t1.to(torch.float32)
print(f"t1.max(): {t1.max()}")  # 标量
# 指定dim=0
print(f"t1.max(dim=0): {t1.max(dim=0)}")    # 张量
# 指定dim=1
print(f"t1.max(dim=1): {t1.max(dim=1)}")    # 张量
print("-"*60)

# 5.演示 min
t1 = t1.to(torch.float32)
print(f"t1.min(): {t1.min()}")  # 标量
# 指定dim=0
print(f"t1.min(dim=0): {t1.min(dim=0)}")    # 张量
# 指定dim=1
print(f"t1.min(dim=1): {t1.min(dim=1)}")    # 张量

# 6.演示 pow()/**
# 求2次方
print(f"t1.pow(2): {t1.pow(2)}")  # 标量
# 求10次方
print(f"t1.pow(10): {t1.pow(10)}")  # 标量

t1.mean(): 5.366666793823242
t1.mean(dim=0): tensor([[8.0000, 5.6667, 6.0000, 6.3333, 7.0000],
        [3.0000, 3.6667, 6.0000, 5.0000, 3.3333],
        [3.0000, 6.0000, 5.3333, 5.3333, 7.0000],
        [5.3333, 7.0000, 6.6667, 3.3333, 4.3333]])
t1.mean(dim=1): tensor([[5.5000, 5.5000, 5.5000, 3.2500, 5.5000],
        [4.0000, 6.7500, 6.7500, 6.2500, 5.2500],
        [5.0000, 4.5000, 5.7500, 5.5000, 5.5000]])
------------------------------------------------------------
t1.max(): 9.0
t1.max(dim=0): torch.return_types.max(
values=tensor([[9., 7., 7., 9., 8.],
        [5., 6., 7., 7., 8.],
        [6., 8., 8., 6., 9.],
        [7., 9., 9., 6., 5.]]),
indices=tensor([[0, 0, 0, 1, 0],
        [1, 1, 1, 2, 2],
        [0, 0, 0, 0, 1],
        [2, 1, 1, 1, 0]]))
t1.max(dim=1): torch.return_types.max(
values=tensor([[9., 8., 8., 6., 8.],
        [7., 9., 9., 9., 9.],
        [8., 8., 8., 7., 8.]]),
indices=tensor([[0, 2, 2, 2, 0],
        [0, 3, 3, 0, 2],
        [0, 3, 3, 0, 1]]))
------------------------------------------------------------
t1.min(): 1.0
t1.min(dim=0): torch.return_types.min(
values=tensor([[7., 4., 5., 3., 5.],
        [1., 2., 4., 2., 1.],
        [1., 2., 3., 4., 4.],
        [3., 4., 3., 2., 3.]]),
indices=tensor([[1, 1, 2, 0, 2],
        [0, 2, 0, 0, 0],
        [1, 2, 2, 1, 2],
        [1, 0, 0, 0, 1]]))
t1.min(dim=1): torch.return_types.min(
values=tensor([[1., 3., 3., 2., 1.],
        [1., 4., 5., 4., 1.],
        [2., 2., 3., 2., 4.]]),
indices=tensor([[1, 1, 3, 1, 1],
        [2, 0, 2, 2, 1],
        [2, 1, 2, 3, 2]]))
t1.pow(2): tensor([[[81., 49., 49.,  9., 64.],
         [ 1.,  9., 16.,  4.,  1.],
         [36., 64., 64., 36., 64.],
         [36., 16.,  9.,  4., 25.]],

        [[49., 16., 36., 81., 64.],
         [25., 36., 49., 36.,  1.],
         [ 1., 64., 25., 16., 81.],
         [ 9., 81., 81., 36.,  9.]],

        [[64., 36., 25., 49., 25.],
         [ 9.,  4., 49., 49., 64.],
         [ 4.,  4.,  9., 36., 16.],
         [49., 64., 64.,  4., 25.]]])
t1.pow(10): tensor([[[3.4868e+09, 2.8248e+08, 2.8248e+08, 5.9049e+04, 1.0737e+09],
         [1.0000e+00, 5.9049e+04, 1.0486e+06, 1.0240e+03, 1.0000e+00],
         [6.0466e+07, 1.0737e+09, 1.0737e+09, 6.0466e+07, 1.0737e+09],
         [6.0466e+07, 1.0486e+06, 5.9049e+04, 1.0240e+03, 9.7656e+06]],

        [[2.8248e+08, 1.0486e+06, 6.0466e+07, 3.4868e+09, 1.0737e+09],
         [9.7656e+06, 6.0466e+07, 2.8248e+08, 6.0466e+07, 1.0000e+00],
         [1.0000e+00, 1.0737e+09, 9.7656e+06, 1.0486e+06, 3.4868e+09],
         [5.9049e+04, 3.4868e+09, 3.4868e+09, 6.0466e+07, 5.9049e+04]],

        [[1.0737e+09, 6.0466e+07, 9.7656e+06, 2.8248e+08, 9.7656e+06],
         [5.9049e+04, 1.0240e+03, 2.8248e+08, 2.8248e+08, 1.0737e+09],
         [1.0240e+03, 1.0240e+03, 5.9049e+04, 6.0466e+07, 1.0486e+06],
         [2.8248e+08, 1.0737e+09, 1.0737e+09, 1.0240e+03, 9.7656e+06]]])

# 5. 演示 pow, sqrt, exp, log, log2, log10
print(f"t1.pow(2): {t1.pow(2)}")        # 每个元素的平方
print(f"torch.pow(t1, 2): {torch.pow(t1, 2)}")  # 每个元素的平方
print(f"t1**2: {t1**2}")              # 每个元素的平方
print(f"t1.pow(3): {t1.pow(3)}")        # 每个元素的立方
print(f"torch.pow(t1, 3): {torch.pow(t1, 3)}") # 每个元素的立方
print(f"t1**3: {t1**3}")
print(f"t1.sqrt(): {t1.sqrt()}")          # 每个元素的平方根
print(f"torch.sqrt(t1): {torch.sqrt(t1)}")    # 每个元素的平方根
print(f"t1**0.5: {t1**0.5}")          # 每个元素的平方根
print(f"t1**(1/3): {t1**(1/3)}")      # 每个元素的立方根
print(f"t1.exp(): {t1.exp()}")          # 每个元素的e指数
print(f"torch.exp(t1): {torch.exp(t1)}")    # 每个元素的e指数
print(f"t1.log(): {t1.log()}")      # 每个元素的自然对数
print(f"t1.log2(): {t1.log2()}")    # 每个元素的以2为底的对数
print(f"t1.log10(): {t1.log10()}")  # 每个元素的以10为底的对数
print(f"torch.log(t1): {torch.log(t1)}")

t1.pow(2): tensor([[[81., 49., 49.,  9., 64.],
         [ 1.,  9., 16.,  4.,  1.],
         [36., 64., 64., 36., 64.],
         [36., 16.,  9.,  4., 25.]],

        [[49., 16., 36., 81., 64.],
         [25., 36., 49., 36.,  1.],
         [ 1., 64., 25., 16., 81.],
         [ 9., 81., 81., 36.,  9.]],

        [[64., 36., 25., 49., 25.],
         [ 9.,  4., 49., 49., 64.],
         [ 4.,  4.,  9., 36., 16.],
         [49., 64., 64.,  4., 25.]]])
torch.pow(t1, 2): tensor([[[81., 49., 49.,  9., 64.],
         [ 1.,  9., 16.,  4.,  1.],
         [36., 64., 64., 36., 64.],
         [36., 16.,  9.,  4., 25.]],

        [[49., 16., 36., 81., 64.],
         [25., 36., 49., 36.,  1.],
         [ 1., 64., 25., 16., 81.],
         [ 9., 81., 81., 36.,  9.]],

        [[64., 36., 25., 49., 25.],
         [ 9.,  4., 49., 49., 64.],
         [ 4.,  4.,  9., 36., 16.],
         [49., 64., 64.,  4., 25.]]])
t1**2: tensor([[[81., 49., 49.,  9., 64.],
         [ 1.,  9., 16.,  4.,  1.],
         [36., 64., 64., 36., 64.],
         [36., 16.,  9.,  4., 25.]],

        [[49., 16., 36., 81., 64.],
         [25., 36., 49., 36.,  1.],
         [ 1., 64., 25., 16., 81.],
         [ 9., 81., 81., 36.,  9.]],

        [[64., 36., 25., 49., 25.],
         [ 9.,  4., 49., 49., 64.],
         [ 4.,  4.,  9., 36., 16.],
         [49., 64., 64.,  4., 25.]]])
t1.pow(3): tensor([[[729., 343., 343.,  27., 512.],
         [  1.,  27.,  64.,   8.,   1.],
         [216., 512., 512., 216., 512.],
         [216.,  64.,  27.,   8., 125.]],

        [[343.,  64., 216., 729., 512.],
         [125., 216., 343., 216.,   1.],
         [  1., 512., 125.,  64., 729.],
         [ 27., 729., 729., 216.,  27.]],

        [[512., 216., 125., 343., 125.],
         [ 27.,   8., 343., 343., 512.],
         [  8.,   8.,  27., 216.,  64.],
         [343., 512., 512.,   8., 125.]]])
torch.pow(t1, 3): tensor([[[729., 343., 343.,  27., 512.],
         [  1.,  27.,  64.,   8.,   1.],
         [216., 512., 512., 216., 512.],
         [216.,  64.,  27.,   8., 125.]],

        [[343.,  64., 216., 729., 512.],
         [125., 216., 343., 216.,   1.],
         [  1., 512., 125.,  64., 729.],
         [ 27., 729., 729., 216.,  27.]],

        [[512., 216., 125., 343., 125.],
         [ 27.,   8., 343., 343., 512.],
         [  8.,   8.,  27., 216.,  64.],
         [343., 512., 512.,   8., 125.]]])
t1**3: tensor([[[729., 343., 343.,  27., 512.],
         [  1.,  27.,  64.,   8.,   1.],
         [216., 512., 512., 216., 512.],
         [216.,  64.,  27.,   8., 125.]],

        [[343.,  64., 216., 729., 512.],
         [125., 216., 343., 216.,   1.],
         [  1., 512., 125.,  64., 729.],
         [ 27., 729., 729., 216.,  27.]],

        [[512., 216., 125., 343., 125.],
         [ 27.,   8., 343., 343., 512.],
         [  8.,   8.,  27., 216.,  64.],
         [343., 512., 512.,   8., 125.]]])
t1.sqrt(): tensor([[[3.0000, 2.6458, 2.6458, 1.7321, 2.8284],
         [1.0000, 1.7321, 2.0000, 1.4142, 1.0000],
         [2.4495, 2.8284, 2.8284, 2.4495, 2.8284],
         [2.4495, 2.0000, 1.7321, 1.4142, 2.2361]],

        [[2.6458, 2.0000, 2.4495, 3.0000, 2.8284],
         [2.2361, 2.4495, 2.6458, 2.4495, 1.0000],
         [1.0000, 2.8284, 2.2361, 2.0000, 3.0000],
         [1.7321, 3.0000, 3.0000, 2.4495, 1.7321]],

        [[2.8284, 2.4495, 2.2361, 2.6458, 2.2361],
         [1.7321, 1.4142, 2.6458, 2.6458, 2.8284],
         [1.4142, 1.4142, 1.7321, 2.4495, 2.0000],
         [2.6458, 2.8284, 2.8284, 1.4142, 2.2361]]])
torch.sqrt(t1): tensor([[[3.0000, 2.6458, 2.6458, 1.7321, 2.8284],
         [1.0000, 1.7321, 2.0000, 1.4142, 1.0000],
         [2.4495, 2.8284, 2.8284, 2.4495, 2.8284],
         [2.4495, 2.0000, 1.7321, 1.4142, 2.2361]],

        [[2.6458, 2.0000, 2.4495, 3.0000, 2.8284],
         [2.2361, 2.4495, 2.6458, 2.4495, 1.0000],
         [1.0000, 2.8284, 2.2361, 2.0000, 3.0000],
         [1.7321, 3.0000, 3.0000, 2.4495, 1.7321]],

        [[2.8284, 2.4495, 2.2361, 2.6458, 2.2361],
         [1.7321, 1.4142, 2.6458, 2.6458, 2.8284],
         [1.4142, 1.4142, 1.7321, 2.4495, 2.0000],
         [2.6458, 2.8284, 2.8284, 1.4142, 2.2361]]])
t1**0.5: tensor([[[3.0000, 2.6458, 2.6458, 1.7321, 2.8284],
         [1.0000, 1.7321, 2.0000, 1.4142, 1.0000],
         [2.4495, 2.8284, 2.8284, 2.4495, 2.8284],
         [2.4495, 2.0000, 1.7321, 1.4142, 2.2361]],

        [[2.6458, 2.0000, 2.4495, 3.0000, 2.8284],
         [2.2361, 2.4495, 2.6458, 2.4495, 1.0000],
         [1.0000, 2.8284, 2.2361, 2.0000, 3.0000],
         [1.7321, 3.0000, 3.0000, 2.4495, 1.7321]],

        [[2.8284, 2.4495, 2.2361, 2.6458, 2.2361],
         [1.7321, 1.4142, 2.6458, 2.6458, 2.8284],
         [1.4142, 1.4142, 1.7321, 2.4495, 2.0000],
         [2.6458, 2.8284, 2.8284, 1.4142, 2.2361]]])
t1**(1/3): tensor([[[2.0801, 1.9129, 1.9129, 1.4422, 2.0000],
         [1.0000, 1.4422, 1.5874, 1.2599, 1.0000],
         [1.8171, 2.0000, 2.0000, 1.8171, 2.0000],
         [1.8171, 1.5874, 1.4422, 1.2599, 1.7100]],

        [[1.9129, 1.5874, 1.8171, 2.0801, 2.0000],
         [1.7100, 1.8171, 1.9129, 1.8171, 1.0000],
         [1.0000, 2.0000, 1.7100, 1.5874, 2.0801],
         [1.4422, 2.0801, 2.0801, 1.8171, 1.4422]],

        [[2.0000, 1.8171, 1.7100, 1.9129, 1.7100],
         [1.4422, 1.2599, 1.9129, 1.9129, 2.0000],
         [1.2599, 1.2599, 1.4422, 1.8171, 1.5874],
         [1.9129, 2.0000, 2.0000, 1.2599, 1.7100]]])
t1.exp(): tensor([[[8.1031e+03, 1.0966e+03, 1.0966e+03, 2.0086e+01, 2.9810e+03],
         [2.7183e+00, 2.0086e+01, 5.4598e+01, 7.3891e+00, 2.7183e+00],
         [4.0343e+02, 2.9810e+03, 2.9810e+03, 4.0343e+02, 2.9810e+03],
         [4.0343e+02, 5.4598e+01, 2.0086e+01, 7.3891e+00, 1.4841e+02]],

        [[1.0966e+03, 5.4598e+01, 4.0343e+02, 8.1031e+03, 2.9810e+03],
         [1.4841e+02, 4.0343e+02, 1.0966e+03, 4.0343e+02, 2.7183e+00],
         [2.7183e+00, 2.9810e+03, 1.4841e+02, 5.4598e+01, 8.1031e+03],
         [2.0086e+01, 8.1031e+03, 8.1031e+03, 4.0343e+02, 2.0086e+01]],

        [[2.9810e+03, 4.0343e+02, 1.4841e+02, 1.0966e+03, 1.4841e+02],
         [2.0086e+01, 7.3891e+00, 1.0966e+03, 1.0966e+03, 2.9810e+03],
         [7.3891e+00, 7.3891e+00, 2.0086e+01, 4.0343e+02, 5.4598e+01],
         [1.0966e+03, 2.9810e+03, 2.9810e+03, 7.3891e+00, 1.4841e+02]]])
torch.exp(t1): tensor([[[8.1031e+03, 1.0966e+03, 1.0966e+03, 2.0086e+01, 2.9810e+03],
         [2.7183e+00, 2.0086e+01, 5.4598e+01, 7.3891e+00, 2.7183e+00],
         [4.0343e+02, 2.9810e+03, 2.9810e+03, 4.0343e+02, 2.9810e+03],
         [4.0343e+02, 5.4598e+01, 2.0086e+01, 7.3891e+00, 1.4841e+02]],

        [[1.0966e+03, 5.4598e+01, 4.0343e+02, 8.1031e+03, 2.9810e+03],
         [1.4841e+02, 4.0343e+02, 1.0966e+03, 4.0343e+02, 2.7183e+00],
         [2.7183e+00, 2.9810e+03, 1.4841e+02, 5.4598e+01, 8.1031e+03],
         [2.0086e+01, 8.1031e+03, 8.1031e+03, 4.0343e+02, 2.0086e+01]],

        [[2.9810e+03, 4.0343e+02, 1.4841e+02, 1.0966e+03, 1.4841e+02],
         [2.0086e+01, 7.3891e+00, 1.0966e+03, 1.0966e+03, 2.9810e+03],
         [7.3891e+00, 7.3891e+00, 2.0086e+01, 4.0343e+02, 5.4598e+01],
         [1.0966e+03, 2.9810e+03, 2.9810e+03, 7.3891e+00, 1.4841e+02]]])
t1.log(): tensor([[[2.1972, 1.9459, 1.9459, 1.0986, 2.0794],
         [0.0000, 1.0986, 1.3863, 0.6931, 0.0000],
         [1.7918, 2.0794, 2.0794, 1.7918, 2.0794],
         [1.7918, 1.3863, 1.0986, 0.6931, 1.6094]],

        [[1.9459, 1.3863, 1.7918, 2.1972, 2.0794],
         [1.6094, 1.7918, 1.9459, 1.7918, 0.0000],
         [0.0000, 2.0794, 1.6094, 1.3863, 2.1972],
         [1.0986, 2.1972, 2.1972, 1.7918, 1.0986]],

        [[2.0794, 1.7918, 1.6094, 1.9459, 1.6094],
         [1.0986, 0.6931, 1.9459, 1.9459, 2.0794],
         [0.6931, 0.6931, 1.0986, 1.7918, 1.3863],
         [1.9459, 2.0794, 2.0794, 0.6931, 1.6094]]])
t1.log2(): tensor([[[3.1699, 2.8074, 2.8074, 1.5850, 3.0000],
         [0.0000, 1.5850, 2.0000, 1.0000, 0.0000],
         [2.5850, 3.0000, 3.0000, 2.5850, 3.0000],
         [2.5850, 2.0000, 1.5850, 1.0000, 2.3219]],

        [[2.8074, 2.0000, 2.5850, 3.1699, 3.0000],
         [2.3219, 2.5850, 2.8074, 2.5850, 0.0000],
         [0.0000, 3.0000, 2.3219, 2.0000, 3.1699],
         [1.5850, 3.1699, 3.1699, 2.5850, 1.5850]],

        [[3.0000, 2.5850, 2.3219, 2.8074, 2.3219],
         [1.5850, 1.0000, 2.8074, 2.8074, 3.0000],
         [1.0000, 1.0000, 1.5850, 2.5850, 2.0000],
         [2.8074, 3.0000, 3.0000, 1.0000, 2.3219]]])
t1.log10(): tensor([[[0.9542, 0.8451, 0.8451, 0.4771, 0.9031],
         [0.0000, 0.4771, 0.6021, 0.3010, 0.0000],
         [0.7782, 0.9031, 0.9031, 0.7782, 0.9031],
         [0.7782, 0.6021, 0.4771, 0.3010, 0.6990]],

        [[0.8451, 0.6021, 0.7782, 0.9542, 0.9031],
         [0.6990, 0.7782, 0.8451, 0.7782, 0.0000],
         [0.0000, 0.9031, 0.6990, 0.6021, 0.9542],
         [0.4771, 0.9542, 0.9542, 0.7782, 0.4771]],

        [[0.9031, 0.7782, 0.6990, 0.8451, 0.6990],
         [0.4771, 0.3010, 0.8451, 0.8451, 0.9031],
         [0.3010, 0.3010, 0.4771, 0.7782, 0.6021],
         [0.8451, 0.9031, 0.9031, 0.3010, 0.6990]]])
torch.log(t1): tensor([[[2.1972, 1.9459, 1.9459, 1.0986, 2.0794],
         [0.0000, 1.0986, 1.3863, 0.6931, 0.0000],
         [1.7918, 2.0794, 2.0794, 1.7918, 2.0794],
         [1.7918, 1.3863, 1.0986, 0.6931, 1.6094]],

        [[1.9459, 1.3863, 1.7918, 2.1972, 2.0794],
         [1.6094, 1.7918, 1.9459, 1.7918, 0.0000],
         [0.0000, 2.0794, 1.6094, 1.3863, 2.1972],
         [1.0986, 2.1972, 2.1972, 1.7918, 1.0986]],

        [[2.0794, 1.7918, 1.6094, 1.9459, 1.6094],
         [1.0986, 0.6931, 1.9459, 1.9459, 2.0794],
         [0.6931, 0.6931, 1.0986, 1.7918, 1.3863],
         [1.9459, 2.0794, 2.0794, 0.6931, 1.6094]]])

day02_03_张量的索引操作

• 简单行列索引: t1[0, 0], t1[0, :]
• 范围索引: t1[0:3, 1:4]
• 多维索引: t3[1,2,3]

"""
案例：
    演示 张量的索引操作
涉及到的API:
    简单行列索引
    列表索引
    范围索引
    多维索引
    布尔索引
需要掌握的：
    简单行列索引: t1[0, 0], t1[0, :]
    范围索引: t1[0:3, 1:4]
    (多维索引: t3[1,2,3])

"""

# 导包
import torch
# 0.设置随机种子
torch.manual_seed(60)
# 1.创建一个张量, 3*4
t1 = torch.randint(0,10,(3,4))
print(f"t1: {t1}, shape: {t1.shape}, dtype元素类型：{t1.dtype}")
print("-"*60)
# 2.简单行列索引
# 比如获取0,0位置的元素
print(f"t1[0,0]: {t1[0,0]}")
print("-"*60)
# 获取第1行
print(f"t1[0]: {t1[0]}")
print(f"t1[0,:]: {t1[0,:]}")
print("-"*60)
# 获取第1列t1[:,0]
print(f"t1[:,0]: {t1[:,0]}")
print("-"*60)

t1: tensor([[1, 7, 0, 8],
        [3, 1, 6, 5],
        [1, 0, 3, 9]]), shape: torch.Size([3, 4]), dtype元素类型：torch.int64
------------------------------------------------------------
t1[0,0]: 1
------------------------------------------------------------
t1[0]: tensor([1, 7, 0, 8])
t1[0,:]: tensor([1, 7, 0, 8])
------------------------------------------------------------
t1[:,0]: tensor([1, 3, 1])
------------------------------------------------------------

# 3.演示 列表索引
# 获取(0,1), (1,2)位置的元素
print(f"t1[[0,1],[1,2]]: {t1[[0, 1], [1, 2]]}")
# 获取(0,1), (2,2)位置的元素
print(f"t1[[0,2],[1,2]]: {t1[[0, 2], [1, 2]]}")
# 获取 第一行，第1，2，3列 的元素
print(f"t1[0,[0,1,2]]: {t1[0,[0,1,2]]}")
print("-"*60)
# 4.演示 范围索引，起始位置:结束位置(不包含):步长
# 获取前2行
print(f"t1[0:2,:]: {t1[0:2,:]}")
# 获取第2行到第3行t1[1:3]
print(f"t1[1:3]: {t1[1:3]}")
# 获取第2列到第3列t1[:,1:3]
print(f"t1[:,1:3]: {t1[:,1:3]}")
print("-"*60)

t1 = torch.randint(0,10,(5,6))
print(f"t1: {t1}, shape: {t1.shape}, dtype元素类型：{t1.dtype}")
# 获取奇数行，偶数列 的所有元素 t1[0::2,1::2]
print(f"t1[0::2,1::2]: {t1[0::2,1::2]}")

t1[[0,1],[1,2]]: tensor([7, 6])
t1[[0,2],[1,2]]: tensor([7, 3])
t1[0,[0,1,2]]: tensor([1, 7, 0])
------------------------------------------------------------
t1[0:2,:]: tensor([[1, 7, 0, 8],
        [3, 1, 6, 5]])
t1[1:3]: tensor([[3, 1, 6, 5],
        [1, 0, 3, 9]])
t1[:,1:3]: tensor([[7, 0],
        [1, 6],
        [0, 3]])
------------------------------------------------------------
t1: tensor([[4, 1, 6, 2, 7, 6],
        [2, 0, 5, 8, 6, 9],
        [8, 6, 0, 3, 3, 0],
        [0, 6, 7, 8, 8, 2],
        [5, 6, 1, 9, 8, 2]]), shape: torch.Size([5, 6]), dtype元素类型：torch.int64
t1[0::2,1::2]: tensor([[1, 2, 6],
        [6, 3, 0],
        [6, 9, 2]])

# 5. 演示 多维索引
# 创建一个多维张量，3*4*5
t3 = torch.randint(0,10,(3,4,5))
print(f"t3: {t3}, shape: {t3.shape}, dtype元素类型：{t3.dtype}")
# 获取0轴上索引为1的所有元素 t3[1]
print(f"t3[1]: {t3[1]}")
# 获取索引0，0，0的元素 t3[0,0,0]
print(f"t3[0,0,0]: {t3[0,0,0]}")
# 获取索引1，0，2的元素 t3[1，0，2]
print(f"t3[1，0，2]: {t3[1,0,2]}")

# 6. 演示 布尔索引
# 获取第一行中大于5的元素
print(f"t1[0]>5: {t1[0]>5}")
print(f"t1[0,t1[0]>5]: {t1[0,t1[0]>5]}")
# 获取第2列中大于5的元素
print(f"t1[:,1]>5: {t1[:,1]>5}")
print(f"t1[t1[:,1]>5,1]: {t1[t1[:,1]>5,1]}")
# 获取第2列中大于5的元素对应的行
print(f"t1[t1[:,1]>5,:]: {t1[t1[:,1]>5,:]}")
# 获取第2列中小于5的元素对应的行
print(f"t1[t1[:,1]<5,:]: {t1[t1[:,1]<5,:]}")

t3: tensor([[[3, 7, 1, 6, 7],
         [2, 0, 3, 2, 1],
         [7, 9, 8, 7, 0],
         [7, 8, 2, 7, 2]],

        [[0, 0, 7, 8, 0],
         [2, 1, 0, 0, 2],
         [9, 3, 8, 0, 5],
         [2, 4, 9, 1, 7]],

        [[7, 7, 7, 3, 5],
         [6, 0, 6, 6, 7],
         [0, 4, 8, 9, 5],
         [1, 1, 0, 2, 5]]]), shape: torch.Size([3, 4, 5]), dtype元素类型：torch.int64
t3[1]: tensor([[0, 0, 7, 8, 0],
        [2, 1, 0, 0, 2],
        [9, 3, 8, 0, 5],
        [2, 4, 9, 1, 7]])
t3[0,0,0]: 3
t3[1，0，2]: 7
t1[0]>5: tensor([False, False,  True, False,  True,  True])
t1[0,t1[0]>5]: tensor([6, 7, 6])
t1[:,1]>5: tensor([False, False,  True,  True,  True])
t1[t1[:,1]>5,1]: tensor([6, 6, 6])
t1[t1[:,1]>5,:]: tensor([[8, 6, 0, 3, 3, 0],
        [0, 6, 7, 8, 8, 2],
        [5, 6, 1, 9, 8, 2]])
t1[t1[:,1]<5,:]: tensor([[4, 1, 6, 2, 7, 6],
        [2, 0, 5, 8, 6, 9]])

day02_04_张量的形状操作

• reshape() 不改变张量内容的前提下，改变张量的形状，不改变元素的顺序
• unsqueeze() 在指定的轴/维度上增加一个维度（长度1），升维
• squeeze() 删除所有长度为1的维度，降维
• transpose() 交换维度，只能交换两个维度
• permute() 交换维度，可以交换多个维度
• view() 改变形状，要求是连续张量，张量中元素的顺序没有改变，没有经过transpose或permute等操作
• contiguous() 将非连续张量转换为连续张量
• is_contiguous() 判断张量是否是连续张量

"""
案例：
    演示 张量的形状操作
涉及到的API:
    reshape()       不改变张量内容的前提下，改变张量的形状，不改变元素的顺序
    unsqueeze()     在指定的轴/维度上增加一个维度（长度1），升维
    squeeze()       删除所有长度为1的维度，降维
    transpose()     交换维度，只能交换两个维度
    permute()       交换维度，可以交换多个维度
    view()          改变形状，要求是连续张量，张量中元素的顺序没有改变，
                    没有经过transpose或permute等操作
    contiguous()    将非连续张量转换为连续张量
    is_contiguous() 判断张量是否是连续张量

需要掌握的：
    reshape()
    unsqueeze()
    permute()
    view()

"""

# 导包
import torch
# 0.设置随机种子
torch.manual_seed(6)
# # 1.创建一个张量，3*4
t1 = torch.randint(0,10,(3,4))
print(f"t1: {t1}, shape: {t1.shape}, dtype元素类型：{t1.dtype}")
print("-"*60)
# # 2.演示 reshape
# 改为4*3
t2 = t1.reshape(4,3,1,1,1,1,1)
print(f"t2: {t2}, shape: {t2.shape}, dtype元素类型：{t2.dtype}")
# 改为2*6
t2 = t1.reshape(2,6)
print(f"t2: {t2}, shape: {t2.shape}, dtype元素类型：{t2.dtype}")
# # 改为8*2
# t2 = t1.reshape(8,-1)
# print(f"t2: {t2}, shape: {t2.shape}, dtype元素类型：{t2.dtype}")
# 3.演示 unsqueeze
# 在0轴上增加一个维度
t3 = t1.unsqueeze(dim=0)    # (1,3,4)
print(f"t3: {t3}, shape: {t3.shape}, dtype元素类型：{t3.dtype}")
# 在1轴上增加一个维度
t3 = t1.unsqueeze(dim=1)    # (3,1,4)
print(f"t3: {t3}, shape: {t3.shape}, dtype元素类型：{t3.dtype}")
# 在2轴上增加一个维度
t3 = t1.unsqueeze(dim=2)    # (3,4,1)
print(f"t3: {t3}, shape: {t3.shape}, dtype元素类型：{t3.dtype}")
# 在3轴上增加一个维度
t3 = t3.unsqueeze(dim=3)    # (3,4,1,1)
print(f"t3: {t3}, shape: {t3.shape}, dtype元素类型：{t3.dtype}")

# 4.演示 squeeze
# 降维，删除所有长度为1的维度/轴
t4 = t3.squeeze()   # (3,4,1,1) -> (3,4)
print(f"t4: {t4}, shape: {t4.shape}, dtype元素类型：{t4.dtype}")

t1: tensor([[0, 1, 3, 2],
        [4, 7, 7, 6],
        [4, 8, 7, 9]]), shape: torch.Size([3, 4]), dtype元素类型：torch.int64
------------------------------------------------------------
t2: tensor([[[[[[[0]]]]],




         [[[[[1]]]]],




         [[[[[3]]]]]],





        [[[[[[2]]]]],




         [[[[[4]]]]],




         [[[[[7]]]]]],





        [[[[[[7]]]]],




         [[[[[6]]]]],




         [[[[[4]]]]]],





        [[[[[[8]]]]],




         [[[[[7]]]]],




         [[[[[9]]]]]]]), shape: torch.Size([4, 3, 1, 1, 1, 1, 1]), dtype元素类型：torch.int64
t2: tensor([[0, 1, 3, 2, 4, 7],
        [7, 6, 4, 8, 7, 9]]), shape: torch.Size([2, 6]), dtype元素类型：torch.int64
t3: tensor([[[0, 1, 3, 2],
         [4, 7, 7, 6],
         [4, 8, 7, 9]]]), shape: torch.Size([1, 3, 4]), dtype元素类型：torch.int64
t3: tensor([[[0, 1, 3, 2]],

        [[4, 7, 7, 6]],

        [[4, 8, 7, 9]]]), shape: torch.Size([3, 1, 4]), dtype元素类型：torch.int64
t3: tensor([[[0],
         [1],
         [3],
         [2]],

        [[4],
         [7],
         [7],
         [6]],

        [[4],
         [8],
         [7],
         [9]]]), shape: torch.Size([3, 4, 1]), dtype元素类型：torch.int64
t3: tensor([[[[0]],

         [[1]],

         [[3]],

         [[2]]],


        [[[4]],

         [[7]],

         [[7]],

         [[6]]],


        [[[4]],

         [[8]],

         [[7]],

         [[9]]]]), shape: torch.Size([3, 4, 1, 1]), dtype元素类型：torch.int64
t4: tensor([[0, 1, 3, 2],
        [4, 7, 7, 6],
        [4, 8, 7, 9]]), shape: torch.Size([3, 4]), dtype元素类型：torch.int64

# 5. 演示 transpose, permute
# 使用 transpose 交换维度
t5 = t1.transpose(0,1)   # (3,4) -> (4,3)
print(f"t5: {t5}, shape: {t5.shape}, dtype元素类型：{t5.dtype}")
# 使用 permute 交换维度，第一个位置为新的张量的0轴
t6 = t1.permute(1,0)
print(f"t6: {t6}, shape: {t6.shape}, dtype元素类型：{t6.dtype}")
# 使用 permute 交互多个维度, 图片数据HWC(0,1,2) -> CHW (2,0,1)
t1 = torch.randint(0,10,(2,3,4))
print(f"t1: {t1}, shape: {t1.shape}, dtype元素类型：{t1.dtype}")
t7 = t1.permute(2,0,1)  # (4,2,3)
print(f"t7: {t7}, shape: {t7.shape}, dtype元素类型：{t7.dtype}")

# 6. 演示 view
# t8 = t1.view(-1)
t9 = t7.contiguous()
print(f"t9: {t9}, shape: {t9.shape}, dtype元素类型：{t9.dtype}")
t8 = t7.contiguous().view(4,6)
print(f"t8: {t8}, shape: {t8.shape}, dtype元素类型：{t8.dtype}")
print(t7.is_contiguous())
print(t8.is_contiguous())
print(t9.is_contiguous())

t5: tensor([[0, 4, 4],
        [1, 7, 8],
        [3, 7, 7],
        [2, 6, 9]]), shape: torch.Size([4, 3]), dtype元素类型：torch.int64
t6: tensor([[0, 4, 4],
        [1, 7, 8],
        [3, 7, 7],
        [2, 6, 9]]), shape: torch.Size([4, 3]), dtype元素类型：torch.int64
t1: tensor([[[5, 5, 7, 2],
         [3, 9, 8, 4],
         [6, 1, 6, 4]],

        [[2, 4, 9, 9],
         [0, 7, 1, 2],
         [3, 3, 2, 0]]]), shape: torch.Size([2, 3, 4]), dtype元素类型：torch.int64
t7: tensor([[[5, 3, 6],
         [2, 0, 3]],

        [[5, 9, 1],
         [4, 7, 3]],

        [[7, 8, 6],
         [9, 1, 2]],

        [[2, 4, 4],
         [9, 2, 0]]]), shape: torch.Size([4, 2, 3]), dtype元素类型：torch.int64
t9: tensor([[[5, 3, 6],
         [2, 0, 3]],

        [[5, 9, 1],
         [4, 7, 3]],

        [[7, 8, 6],
         [9, 1, 2]],

        [[2, 4, 4],
         [9, 2, 0]]]), shape: torch.Size([4, 2, 3]), dtype元素类型：torch.int64
t8: tensor([[5, 3, 6, 2, 0, 3],
        [5, 9, 1, 4, 7, 3],
        [7, 8, 6, 9, 1, 2],
        [2, 4, 4, 9, 2, 0]]), shape: torch.Size([4, 6]), dtype元素类型：torch.int64
False
True
True

day02_05_张量的拼接

• torch.cat() 按指定维度拼接张量，不改变维度数量，除了要拼接的维度，其他维度的形状必须相同 (m, n) + (k, n) -> (m+k, n). numpy.concatenate()
• torch.stack() 在新的维度上堆叠张量，会改变维度数量，所有张量的形状必须相同 (m, n) + (m, n) -> (2, m, n). numpy.stack()

"""
演示：
    演示 张量的拼接操作
涉及到的API:
    torch.cat()     
        按指定维度拼接张量，不改变维度数量，除了要拼接的维度，其他维度的形状必须相同   (m, n) + (k, n) -> (m+k, n)
    torch.stack()   
        在新的维度上拼接张量，增加了一个新的维度，会改变维度数量，所有张量的形状必须相同   (m, n) + (m, n) -> (2, m, n)

"""

import torch

# 0.设置随机种子
torch.manual_seed(6)
# 1.创建随机张量
t1 = torch.randint(1,10,(2,3))
print(f"t1: {t1}, t1.shape: {t1.shape}")
t2 = torch.randint(1,10,(2,3))
print(f"t2: {t2}, t2.shape: {t2.shape}")

# 2.演示 torch.cat()
# 按0轴拼接
t3 = torch.cat((t1,t2), dim=0)  # (2,3) + (2,3) -> (4,3)
print(f"t3: {t3}, t3.shape: {t3.shape}")

# 按1轴拼接
t3 = torch.cat((t1,t2), dim=1)  # (2,3) + (2,3) -> (2,6)
print(f"t3: {t3}, t3.shape: {t3.shape}")

# 按2轴拼接
# t3 = torch.cat((t1,t2), dim=2)  # (2,3) + (2,3) -> (2,3,?)
# print(f"t3: {t3}, t3.shape: {t3.shape}")

t1: tensor([[9, 7, 7],
        [3, 8, 1]]), t1.shape: torch.Size([2, 3])
t2: tensor([[3, 4, 2],
        [1, 6, 8]]), t2.shape: torch.Size([2, 3])
t3: tensor([[9, 7, 7],
        [3, 8, 1],
        [3, 4, 2],
        [1, 6, 8]]), t3.shape: torch.Size([4, 3])
t3: tensor([[9, 7, 7, 3, 4, 2],
        [3, 8, 1, 1, 6, 8]]), t3.shape: torch.Size([2, 6])

# 3.演示 torch.stack()
# 按0轴拼接
t3 = torch.stack((t1,t2), dim=0)  # (2,3) + (2,3) -> (2,2,3)
print(f"t3: {t3}, t3.shape: {t3.shape}")

# 按1轴拼接
t3 = torch.stack((t1,t2), dim=1)  # (2,3) + (2,3) -> (2,2,3)
print(f"t3: {t3}, t3.shape: {t3.shape}")

# 按2轴拼接
t3 = torch.stack((t1,t2), dim=2)  # (2,3) + (2,3) -> (2,3,2)
print(f"t3: {t3}, t3.shape: {t3.shape}")

# 按3轴拼接
# t3 = torch.stack((t1,t2), dim=3)  # (2,3) + (2,3) -> (2,3,?,2)
# print(f"t3: {t3}, t3.shape: {t3.shape}")

t3: tensor([[[9, 7, 7],
         [3, 8, 1]],

        [[3, 4, 2],
         [1, 6, 8]]]), t3.shape: torch.Size([2, 2, 3])
t3: tensor([[[9, 7, 7],
         [3, 4, 2]],

        [[3, 8, 1],
         [1, 6, 8]]]), t3.shape: torch.Size([2, 2, 3])
t3: tensor([[[9, 3],
         [7, 4],
         [7, 2]],

        [[3, 1],
         [8, 6],
         [1, 8]]]), t3.shape: torch.Size([2, 3, 2])

day02_06_自动微分模块入门案例

• requires_grad=True, pytorch提供自动微分功能

• 梯度 = 损失函数对模型参数的导数;

• 损失函数的梯度，无需手动计算，由自动微分模块在反向传播过程中自动计算，进一步由梯度来更新模型参数(权重w和偏置b);
• 梯度下降法更新权重：
  w新 = w旧 - 学习率 * 梯度
• 梯度/导数的理解
• 数值：在某一个点上，对函数求导得到的值就是该点的梯度/导数
• 类比：梯度就是上山下山最快的方向
• 在平面内，梯度就是某一点上的斜率
  • y = 2x^2 某一点x=1的梯度，就是这一点上的斜率
• 反向传播过程中如何计算梯度
  • 反向传播利用链式法则不断的从后向前求导，求出来的值就是梯度

训练神经网络时，常用反向传播算法来计算梯度（反向追溯计算图，利用链式法则计算梯度）。为了计算这些梯度，PyTorch内置了名为 torch.autograd 的自动微分模块。它支持任意计算图的自动梯度计算：

我们使用 backward 方法、grad 属性来实现梯度的计算和访问。

# 自动微分示例
x = torch.tensor([2.0, 3.0], requires_grad=True)
y = x**2+2
# y' = 2x, 4
print("y:", y)

y.sum().backward()  # 反向传播
print("x的梯度:", x.grad)

y: tensor([ 6., 11.], grad_fn=<AddBackward0>)
x的梯度: tensor([4., 6.])

"""
案例
    演示 自动微分模块如何计算梯度/导数

介绍：
    梯度：损失函数对模型参数的导数/梯度，损失函数的导函数的数值，自变量是模型参数w, b
    损失函数的梯度/导数，不需要手动计算，由自动微分模块 在backward反向传播中自动计算的，从而进一步更新模型参数
    梯度下降法更新模型参数公式：
        w新 = w旧 - 学习率 * 梯度

"""

# 导包
import torch

# 1.定义变量，记录初始权重
w = torch.tensor([10,20], requires_grad=True, dtype=torch.float32)  # 权重
print(f"初始权重w: {w}, requires_grad: {w.requires_grad}")
print(f"初始权重 w.data: {w.data}")
print(f"梯度 w.grad: {w.grad}")
# 2.定义损失函数
loss = 0.5*w**2  # loss' = w, 10
# w = [w1,w2] => loss = [0.5*w1^2, 0.5*w2^2]
print(f"loss: {loss}")
# 3.反向传播，计算梯度
# 因为神经网络训练中计算的损失是每个批次的平均损失
loss.mean().backward()  # w, 10
# loss.mean() = 0.5*(w1^2 + w2^2)/2
# d(loss.mean())/dw1 = 0.5*w1
# d(loss.mean())/dw2 = 0.5*w2
# d(loss.mean())/(dw1,dw2) = [0.5*w1, 0.5*w2] = [5,10]
# 4.打印梯度, w.grad
print(f"梯度 w.grad: {w.grad}")

# 5.更新参数，演示一步梯度下降
w.data = w.data - 0.01 * w.grad
print(f"更新后权重 w: {w}")

初始权重w: tensor([10., 20.], requires_grad=True), requires_grad: True
初始权重 w.data: tensor([10., 20.])
梯度 w.grad: None
loss: tensor([ 50., 200.], grad_fn=<MulBackward0>)
梯度 w.grad: tensor([ 5., 10.])
更新后权重 w: tensor([ 9.9500, 19.9000], requires_grad=True)

day02_07_梯度下降法求最小值案例

• 演示 梯度下降法求最小值, 循环实现 计算梯度, 更新参数
  1. 定义点 w=10 requires_grad=True dtlosspe=torch.float32
  2. 定义函数 loss = w**2 + 20
  3. 利用梯度下降法 循环迭代1000 求最优解
     • 3.1 正向计算(前向传播)
     • 3.2 梯度清零 w.grad.zero_()
     • 3.3 反向传播
     • 3.4 梯度更新 w.data = w.data - 0.01 * w.grad

演示梯度下降法

# 目标函数 & 导数
def f(x):
    return x**2 + 20

def grad(x):
    return 2 * x

# 准备绘图
x_vals = np.linspace(-10, 10, 200)
y_vals = f(x_vals)

plt.figure(figsize=(10,6))
plt.title("梯度下降法演示-二维曲线")
plt.plot(x_vals,y_vals, label="y = $w^{2}$ + 20")
plt.grid()
plt.legend()
plt.tight_layout()
plt.show()

# 梯度下降参数
lr = 0.1          # learning rate
x = 7            # 初始点
steps = 20        # 迭代次数

xs = [x]          # 保存每一步的 x
ys = [f(x)]       # 保存每一步的 y

# 梯度下降过程
for i in range(steps):
    g = grad(x)
    x = x - lr * g
    xs.append(x)
    ys.append(f(x))

# 绘制函数曲线
plt.figure(figsize=(10,6))
plt.plot(x_vals, y_vals, label=r"y = $w^{2}$ + 20")

# 绘制梯度下降路径
plt.scatter(xs, ys, color='red', s=30, label="梯度下降路径")
plt.plot(xs, ys, color='red', linestyle='--')

# 最终点标注
plt.scatter(xs[-1], ys[-1], color='green', s=60, label="最低点")

plt.grid()
plt.legend()
plt.title("梯度下降法演示-二维曲线")
plt.xlabel("w")
plt.ylabel("y")
plt.tight_layout()
plt.show()

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from matplotlib.animation import FuncAnimation, PillowWriter

# -----------------------------
# 1. 定义损失函数和梯度
# -----------------------------
def f(x, y):
    return x**2 + y**2

def grad_f(x, y):
    return np.array([2*x, 2*y])

# -----------------------------
# 2. 创建网格用于绘制 3D 曲面
# -----------------------------
x = np.linspace(-5, 5, 200)
y = np.linspace(-5, 5, 200)
X, Y = np.meshgrid(x, y)
Z = f(X, Y)

# -----------------------------
# 3. 梯度下降
# -----------------------------
lr = 0.1
steps = 20
point = np.array([4.0, 4.0])
trajectory = [point.copy()]

for _ in range(steps):
    grad = grad_f(point[0], point[1])
    point -= lr * grad
    trajectory.append(point.copy())

trajectory = np.array(trajectory)
Z_traj = f(trajectory[:,0], trajectory[:,1])

# -----------------------------
# 4. 绘制静态图（带箭头）
# -----------------------------
fig = plt.figure(figsize=(16,12))
ax = fig.add_subplot(111, projection='3d')
ax.set_title("梯度下降法演示：3D损失曲面 + 下降路径 + 梯度反方向箭头")

# 曲面
ax.plot_surface(X, Y, Z, alpha=0.75, cmap="viridis")

# 下降路径
ax.plot(trajectory[:,0], trajectory[:,1], Z_traj,
        color='red', marker='o', label="下降路径")

# 添加地面方向箭头（-梯度方向）
for i in range(len(trajectory)):
    x, y = trajectory[i]
    dx, dy = -grad_f(x, y)     # 梯度反方向
    ax.quiver(x, y, f(x,y), dx, dy, 0, 
              length=0.5, color="black")

ax.set_xlabel("w1")
ax.set_ylabel("w2")
ax.set_zlabel("Loss")
ax.legend()

plt.tight_layout()
plt.show()

# -----------------------------
# 5. 生成 GIF 动画
# -----------------------------
fig = plt.figure(figsize=(12,9))
ax = fig.add_subplot(111, projection='3d')

def update(frame):
    ax.cla()
    ax.plot_surface(X, Y, Z, alpha=0.75, cmap="viridis")

    # 当前路径
    ax.plot(trajectory[:frame+1,0], trajectory[:frame+1,1],
            Z_traj[:frame+1], color='red')

    # 当前点
    x, y = trajectory[frame]
    z = f(x,y)
    ax.scatter(x, y, z, color="red", s=80)

    # 地面方向箭头
    dx, dy = -grad_f(x, y)
    ax.quiver(x, y, z, dx, dy, 0, color="black", length=0.5)

    ax.set_title("梯度下降过程 (Step {})".format(frame))
    ax.set_xlabel("w1")
    ax.set_ylabel("w2")
    ax.set_zlabel("Loss")
    ax.set_zlim(0, 50)

ani = FuncAnimation(fig, update, frames=len(trajectory), interval=300)

# 保存 GIF
gif_path = "./data/gradient_descent.gif"
ani.save(gif_path, writer=PillowWriter(fps=3))

gif_path

'./data/gradient_descent.gif'

import numpy as np
from mpl_toolkits.mplot3d import Axes3D

# 定义函数及梯度
def f(x, y):
    return x**2 + y**2

def grad_f(x, y):
    return np.array([2*x, 2*y])

# 创建网格
x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)
X, Y = np.meshgrid(x, y)
Z = f(X, Y)

# 梯度下降初始化
lr = 0.1  # 学习率
steps = 25
point = np.array([4.0, 4.0])  # 起点
trajectory = [point.copy()]

# 梯度下降迭代
for _ in range(steps):
    grad = grad_f(point[0], point[1])
    point -= lr * grad
    trajectory.append(point.copy())

trajectory = np.array(trajectory)
Z_traj = f(trajectory[:,0], trajectory[:,1])

# 绘图
# Plot surface
fig = plt.figure(figsize=(16,12))
ax = fig.add_subplot(111, projection='3d')
ax.set_title("梯度下降法演示——三维曲面")
ax.plot_surface(X, Y, Z, alpha=0.75, cmap='viridis', label="z = $w_1^{2}$ + $w_2^{2}$")  # No colors specified
ax.set_xlabel(r"$w_1$")
ax.set_ylabel(r"$w_2$")
ax.legend()
plt.tight_layout()

fig = plt.figure(figsize=(16,12))
ax = fig.add_subplot(111, projection='3d')
ax.set_title("梯度下降法演示——三维曲面")
ax.plot_surface(X, Y, Z, alpha=0.75, cmap='viridis', label="z = $w_1^{2}$ + $w_2^{2}$")  # 半透明曲面
ax.plot(trajectory[:,0], trajectory[:,1], Z_traj, color='r', marker='o', label='梯度下降路径')

ax.set_xlabel(r"$w_1$")
ax.set_ylabel(r"$w_2$")
# ax.set_zlabel(r"z = $w_1^{2}$ + $w_2^{2}$")
ax.legend()
plt.tight_layout()
plt.show()

• 演示自动微分模块, 循环实现 计算梯度, 更新参数
  1. 定义点 w=10 requires_grad=True dtlosspe=torch.float32
  2. 定义函数 loss = w**2 + 20
  3. 利用梯度下降法 循环迭代1000 求最优解
     • 3.1 正向计算(前向传播)
     • 3.2 梯度清零 w.grad.zero_()
     • 3.3 反向传播
     • 3.4 梯度更新 w.data = w.data - 0.01 * w.grad

"""
案例：
    演示 自动微分模块案例 循环实现，计算梯度，更新参数

题目：
    # 求 loss = w**2 + 20 的极小值点 并打印loss是最小值时 w的值(梯度)
解题步骤：
    # 1 定义点 w=10 requires_grad=True  dtype=torch.float32
    # 2 定义函数 loss = w**2 + 20
    # 3 利用梯度下降法 循环迭代500 求最优解
        # 3.1 正向计算(前向传播)
        # 3.2 梯度清零 w.grad.zero_()
        # 3.3 反向传播
        # 3.4 梯度更新 w.data = w.data - 0.01 * w.grad

"""
# 求 loss = w**2 + 20 的极小值点 并打印loss是最小值时 w的值(梯度)
import torch

# 1 定义点 w=10 requires_grad=True  dtype=torch.float32
# 参数1：初始值；参数2：是否自动微分/求导；参数3：元素类型
w = torch.tensor([10,20], requires_grad=True, dtype=torch.float32)
print(f"初始值w: {w}")
# 2 定义函数 loss = w**2 + 20
loss = w ** 2 + 20  # 求导 2w [2w1, 2w2]
print(f"初始值loss: {loss}")
# 3 利用梯度下降法 循环迭代100 求最优解
print(f"开始时,权重初始值w: {w}")
print("(0.01 * w.grad): 无")
print(f"初始值loss: {loss}")
# 记录损失均值
loss_list = []
# 循环迭代500次
for i in range(500):
    # 3.1 正向计算(前向传播)
    # 求损失值
    loss = w ** 2 + 20
    # 3.2 梯度清零 w.grad.zero_(), 判断非空
    if w.grad is not None:
        w.grad.zero_()
    # 3.3 反向传播 .backward()
    loss.mean().backward()
    # 3.4 梯度更新 w.data = w.data - 0.01 * w.grad
    w.data = w.data - 0.01 * w.grad
    # print(f"第{i+1}次迭代, 梯度: {w.grad}")
    print(f"第{i+1}次迭代, 权重w: {w.data}, (0.01 * w.grad): {(0.01 * w.grad).data}, loss.mean(): {loss.mean().data}")
    # 添加到loss_list
    loss_list.append(loss.mean().item())

# 打印最终的结果
print(f"最终结果, 权重w: {w}, 梯度: {w.grad}, 损失均值loss.mean(): {loss.mean().data}")

初始值w: tensor([10., 20.], requires_grad=True)
初始值loss: tensor([120., 420.], grad_fn=<AddBackward0>)
开始时,权重初始值w: tensor([10., 20.], requires_grad=True)
(0.01 * w.grad): 无
初始值loss: tensor([120., 420.], grad_fn=<AddBackward0>)
第1次迭代, 权重w: tensor([ 9.9000, 19.8000]), (0.01 * w.grad): tensor([0.1000, 0.2000]), loss.mean(): 270.0
第2次迭代, 权重w: tensor([ 9.8010, 19.6020]), (0.01 * w.grad): tensor([0.0990, 0.1980]), loss.mean(): 265.0249938964844
第3次迭代, 权重w: tensor([ 9.7030, 19.4060]), (0.01 * w.grad): tensor([0.0980, 0.1960]), loss.mean(): 260.14898681640625
第4次迭代, 权重w: tensor([ 9.6060, 19.2119]), (0.01 * w.grad): tensor([0.0970, 0.1941]), loss.mean(): 255.37002563476562
第5次迭代, 权重w: tensor([ 9.5099, 19.0198]), (0.01 * w.grad): tensor([0.0961, 0.1921]), loss.mean(): 250.68617248535156
第6次迭代, 权重w: tensor([ 9.4148, 18.8296]), (0.01 * w.grad): tensor([0.0951, 0.1902]), loss.mean(): 246.0955047607422
第7次迭代, 权重w: tensor([ 9.3207, 18.6413]), (0.01 * w.grad): tensor([0.0941, 0.1883]), loss.mean(): 241.59619140625
第8次迭代, 权重w: tensor([ 9.2274, 18.4549]), (0.01 * w.grad): tensor([0.0932, 0.1864]), loss.mean(): 237.18643188476562
第9次迭代, 权重w: tensor([ 9.1352, 18.2703]), (0.01 * w.grad): tensor([0.0923, 0.1845]), loss.mean(): 232.86441040039062
第10次迭代, 权重w: tensor([ 9.0438, 18.0876]), (0.01 * w.grad): tensor([0.0914, 0.1827]), loss.mean(): 228.62840270996094
第11次迭代, 权重w: tensor([ 8.9534, 17.9068]), (0.01 * w.grad): tensor([0.0904, 0.1809]), loss.mean(): 224.47671508789062
第12次迭代, 权重w: tensor([ 8.8638, 17.7277]), (0.01 * w.grad): tensor([0.0895, 0.1791]), loss.mean(): 220.4076385498047
第13次迭代, 权重w: tensor([ 8.7752, 17.5504]), (0.01 * w.grad): tensor([0.0886, 0.1773]), loss.mean(): 216.41952514648438
第14次迭代, 权重w: tensor([ 8.6875, 17.3749]), (0.01 * w.grad): tensor([0.0878, 0.1755]), loss.mean(): 212.51080322265625
第15次迭代, 权重w: tensor([ 8.6006, 17.2012]), (0.01 * w.grad): tensor([0.0869, 0.1737]), loss.mean(): 208.6798095703125
第16次迭代, 权重w: tensor([ 8.5146, 17.0292]), (0.01 * w.grad): tensor([0.0860, 0.1720]), loss.mean(): 204.92507934570312
第17次迭代, 权重w: tensor([ 8.4294, 16.8589]), (0.01 * w.grad): tensor([0.0851, 0.1703]), loss.mean(): 201.2450408935547
第18次迭代, 权重w: tensor([ 8.3451, 16.6903]), (0.01 * w.grad): tensor([0.0843, 0.1686]), loss.mean(): 197.6382598876953
第19次迭代, 权重w: tensor([ 8.2617, 16.5234]), (0.01 * w.grad): tensor([0.0835, 0.1669]), loss.mean(): 194.10325622558594
第20次迭代, 权重w: tensor([ 8.1791, 16.3581]), (0.01 * w.grad): tensor([0.0826, 0.1652]), loss.mean(): 190.63861083984375
第21次迭代, 权重w: tensor([ 8.0973, 16.1946]), (0.01 * w.grad): tensor([0.0818, 0.1636]), loss.mean(): 187.24290466308594
第22次迭代, 权重w: tensor([ 8.0163, 16.0326]), (0.01 * w.grad): tensor([0.0810, 0.1619]), loss.mean(): 183.91476440429688
第23次迭代, 权重w: tensor([ 7.9361, 15.8723]), (0.01 * w.grad): tensor([0.0802, 0.1603]), loss.mean(): 180.65286254882812
第24次迭代, 权重w: tensor([ 7.8568, 15.7136]), (0.01 * w.grad): tensor([0.0794, 0.1587]), loss.mean(): 177.45587158203125
第25次迭代, 权重w: tensor([ 7.7782, 15.5564]), (0.01 * w.grad): tensor([0.0786, 0.1571]), loss.mean(): 174.322509765625
第26次迭代, 权重w: tensor([ 7.7004, 15.4009]), (0.01 * w.grad): tensor([0.0778, 0.1556]), loss.mean(): 171.25149536132812
第27次迭代, 权重w: tensor([ 7.6234, 15.2469]), (0.01 * w.grad): tensor([0.0770, 0.1540]), loss.mean(): 168.2415771484375
第28次迭代, 权重w: tensor([ 7.5472, 15.0944]), (0.01 * w.grad): tensor([0.0762, 0.1525]), loss.mean(): 165.29156494140625
第29次迭代, 权重w: tensor([ 7.4717, 14.9434]), (0.01 * w.grad): tensor([0.0755, 0.1509]), loss.mean(): 162.40025329589844
第30次迭代, 权重w: tensor([ 7.3970, 14.7940]), (0.01 * w.grad): tensor([0.0747, 0.1494]), loss.mean(): 159.56649780273438
第31次迭代, 权重w: tensor([ 7.3230, 14.6461]), (0.01 * w.grad): tensor([0.0740, 0.1479]), loss.mean(): 156.78912353515625
第32次迭代, 权重w: tensor([ 7.2498, 14.4996]), (0.01 * w.grad): tensor([0.0732, 0.1465]), loss.mean(): 154.06703186035156
第33次迭代, 权重w: tensor([ 7.1773, 14.3546]), (0.01 * w.grad): tensor([0.0725, 0.1450]), loss.mean(): 151.3990936279297
第34次迭代, 权重w: tensor([ 7.1055, 14.2111]), (0.01 * w.grad): tensor([0.0718, 0.1435]), loss.mean(): 148.7842559814453
第35次迭代, 权重w: tensor([ 7.0345, 14.0690]), (0.01 * w.grad): tensor([0.0711, 0.1421]), loss.mean(): 146.22145080566406
第36次迭代, 权重w: tensor([ 6.9641, 13.9283]), (0.01 * w.grad): tensor([0.0703, 0.1407]), loss.mean(): 143.7096405029297
第37次迭代, 权重w: tensor([ 6.8945, 13.7890]), (0.01 * w.grad): tensor([0.0696, 0.1393]), loss.mean(): 141.24781799316406
第38次迭代, 权重w: tensor([ 6.8255, 13.6511]), (0.01 * w.grad): tensor([0.0689, 0.1379]), loss.mean(): 138.83499145507812
第39次迭代, 权重w: tensor([ 6.7573, 13.5146]), (0.01 * w.grad): tensor([0.0683, 0.1365]), loss.mean(): 136.47018432617188
第40次迭代, 权重w: tensor([ 6.6897, 13.3794]), (0.01 * w.grad): tensor([0.0676, 0.1351]), loss.mean(): 134.15240478515625
第41次迭代, 权重w: tensor([ 6.6228, 13.2456]), (0.01 * w.grad): tensor([0.0669, 0.1338]), loss.mean(): 131.8807830810547
第42次迭代, 权重w: tensor([ 6.5566, 13.1132]), (0.01 * w.grad): tensor([0.0662, 0.1325]), loss.mean(): 129.6543426513672
第43次迭代, 权重w: tensor([ 6.4910, 12.9820]), (0.01 * w.grad): tensor([0.0656, 0.1311]), loss.mean(): 127.47222137451172
第44次迭代, 权重w: tensor([ 6.4261, 12.8522]), (0.01 * w.grad): tensor([0.0649, 0.1298]), loss.mean(): 125.33351135253906
第45次迭代, 权重w: tensor([ 6.3619, 12.7237]), (0.01 * w.grad): tensor([0.0643, 0.1285]), loss.mean(): 123.23737335205078
第46次迭代, 权重w: tensor([ 6.2982, 12.5965]), (0.01 * w.grad): tensor([0.0636, 0.1272]), loss.mean(): 121.18295288085938
第47次迭代, 权重w: tensor([ 6.2353, 12.4705]), (0.01 * w.grad): tensor([0.0630, 0.1260]), loss.mean(): 119.16940307617188
第48次迭代, 权重w: tensor([ 6.1729, 12.3458]), (0.01 * w.grad): tensor([0.0624, 0.1247]), loss.mean(): 117.19593048095703
第49次迭代, 权重w: tensor([ 6.1112, 12.2223]), (0.01 * w.grad): tensor([0.0617, 0.1235]), loss.mean(): 115.26172637939453
第50次迭代, 权重w: tensor([ 6.0501, 12.1001]), (0.01 * w.grad): tensor([0.0611, 0.1222]), loss.mean(): 113.36602020263672
第51次迭代, 权重w: tensor([ 5.9896, 11.9791]), (0.01 * w.grad): tensor([0.0605, 0.1210]), loss.mean(): 111.50802612304688
第52次迭代, 权重w: tensor([ 5.9297, 11.8593]), (0.01 * w.grad): tensor([0.0599, 0.1198]), loss.mean(): 109.68702697753906
第53次迭代, 权重w: tensor([ 5.8704, 11.7407]), (0.01 * w.grad): tensor([0.0593, 0.1186]), loss.mean(): 107.90225219726562
第54次迭代, 权重w: tensor([ 5.8117, 11.6233]), (0.01 * w.grad): tensor([0.0587, 0.1174]), loss.mean(): 106.15299224853516
第55次迭代, 权重w: tensor([ 5.7535, 11.5071]), (0.01 * w.grad): tensor([0.0581, 0.1162]), loss.mean(): 104.43855285644531
第56次迭代, 权重w: tensor([ 5.6960, 11.3920]), (0.01 * w.grad): tensor([0.0575, 0.1151]), loss.mean(): 102.75823974609375
第57次迭代, 权重w: tensor([ 5.6391, 11.2781]), (0.01 * w.grad): tensor([0.0570, 0.1139]), loss.mean(): 101.11134338378906
第58次迭代, 权重w: tensor([ 5.5827, 11.1653]), (0.01 * w.grad): tensor([0.0564, 0.1128]), loss.mean(): 99.49722290039062
第59次迭代, 权重w: tensor([ 5.5268, 11.0537]), (0.01 * w.grad): tensor([0.0558, 0.1117]), loss.mean(): 97.91523742675781
第60次迭代, 权重w: tensor([ 5.4716, 10.9431]), (0.01 * w.grad): tensor([0.0553, 0.1105]), loss.mean(): 96.36473083496094
第61次迭代, 权重w: tensor([ 5.4168, 10.8337]), (0.01 * w.grad): tensor([0.0547, 0.1094]), loss.mean(): 94.84506225585938
第62次迭代, 权重w: tensor([ 5.3627, 10.7254]), (0.01 * w.grad): tensor([0.0542, 0.1083]), loss.mean(): 93.35565185546875
第63次迭代, 权重w: tensor([ 5.3091, 10.6181]), (0.01 * w.grad): tensor([0.0536, 0.1073]), loss.mean(): 91.89586639404297
第64次迭代, 权重w: tensor([ 5.2560, 10.5119]), (0.01 * w.grad): tensor([0.0531, 0.1062]), loss.mean(): 90.46513366699219
第65次迭代, 权重w: tensor([ 5.2034, 10.4068]), (0.01 * w.grad): tensor([0.0526, 0.1051]), loss.mean(): 89.06288146972656
第66次迭代, 权重w: tensor([ 5.1514, 10.3027]), (0.01 * w.grad): tensor([0.0520, 0.1041]), loss.mean(): 87.68852233886719
第67次迭代, 权重w: tensor([ 5.0999, 10.1997]), (0.01 * w.grad): tensor([0.0515, 0.1030]), loss.mean(): 86.34152221679688
第68次迭代, 权重w: tensor([ 5.0489, 10.0977]), (0.01 * w.grad): tensor([0.0510, 0.1020]), loss.mean(): 85.02132415771484
第69次迭代, 权重w: tensor([4.9984, 9.9967]), (0.01 * w.grad): tensor([0.0505, 0.1010]), loss.mean(): 83.72740173339844
第70次迭代, 权重w: tensor([4.9484, 9.8968]), (0.01 * w.grad): tensor([0.0500, 0.1000]), loss.mean(): 82.459228515625
第71次迭代, 权重w: tensor([4.8989, 9.7978]), (0.01 * w.grad): tensor([0.0495, 0.0990]), loss.mean(): 81.21629333496094
第72次迭代, 权重w: tensor([4.8499, 9.6998]), (0.01 * w.grad): tensor([0.0490, 0.0980]), loss.mean(): 79.99809265136719
第73次迭代, 权重w: tensor([4.8014, 9.6028]), (0.01 * w.grad): tensor([0.0485, 0.0970]), loss.mean(): 78.80413055419922
第74次迭代, 权重w: tensor([4.7534, 9.5068]), (0.01 * w.grad): tensor([0.0480, 0.0960]), loss.mean(): 77.63392639160156
第75次迭代, 权重w: tensor([4.7059, 9.4117]), (0.01 * w.grad): tensor([0.0475, 0.0951]), loss.mean(): 76.48701477050781
第76次迭代, 权重w: tensor([4.6588, 9.3176]), (0.01 * w.grad): tensor([0.0471, 0.0941]), loss.mean(): 75.36292266845703
第77次迭代, 权重w: tensor([4.6122, 9.2244]), (0.01 * w.grad): tensor([0.0466, 0.0932]), loss.mean(): 74.26119995117188
第78次迭代, 权重w: tensor([4.5661, 9.1322]), (0.01 * w.grad): tensor([0.0461, 0.0922]), loss.mean(): 73.18140411376953
第79次迭代, 权重w: tensor([4.5204, 9.0409]), (0.01 * w.grad): tensor([0.0457, 0.0913]), loss.mean(): 72.12310028076172
第80次迭代, 权重w: tensor([4.4752, 8.9505]), (0.01 * w.grad): tensor([0.0452, 0.0904]), loss.mean(): 71.08584594726562
第81次迭代, 权重w: tensor([4.4305, 8.8610]), (0.01 * w.grad): tensor([0.0448, 0.0895]), loss.mean(): 70.06924438476562
第82次迭代, 权重w: tensor([4.3862, 8.7723]), (0.01 * w.grad): tensor([0.0443, 0.0886]), loss.mean(): 69.0728759765625
第83次迭代, 权重w: tensor([4.3423, 8.6846]), (0.01 * w.grad): tensor([0.0439, 0.0877]), loss.mean(): 68.09632110595703
第84次迭代, 权重w: tensor([4.2989, 8.5978]), (0.01 * w.grad): tensor([0.0434, 0.0868]), loss.mean(): 67.13920593261719
第85次迭代, 权重w: tensor([4.2559, 8.5118]), (0.01 * w.grad): tensor([0.0430, 0.0860]), loss.mean(): 66.20112609863281
第86次迭代, 权重w: tensor([4.2133, 8.4267]), (0.01 * w.grad): tensor([0.0426, 0.0851]), loss.mean(): 65.28173065185547
第87次迭代, 权重w: tensor([4.1712, 8.3424]), (0.01 * w.grad): tensor([0.0421, 0.0843]), loss.mean(): 64.38062286376953
第88次迭代, 权重w: tensor([4.1295, 8.2590]), (0.01 * w.grad): tensor([0.0417, 0.0834]), loss.mean(): 63.4974479675293
第89次迭代, 权重w: tensor([4.0882, 8.1764]), (0.01 * w.grad): tensor([0.0413, 0.0826]), loss.mean(): 62.63184356689453
第90次迭代, 权重w: tensor([4.0473, 8.0946]), (0.01 * w.grad): tensor([0.0409, 0.0818]), loss.mean(): 61.783470153808594
第91次迭代, 权重w: tensor([4.0068, 8.0137]), (0.01 * w.grad): tensor([0.0405, 0.0809]), loss.mean(): 60.95197677612305
第92次迭代, 权重w: tensor([3.9668, 7.9336]), (0.01 * w.grad): tensor([0.0401, 0.0801]), loss.mean(): 60.13703918457031
第93次迭代, 权重w: tensor([3.9271, 7.8542]), (0.01 * w.grad): tensor([0.0397, 0.0793]), loss.mean(): 59.33831024169922
第94次迭代, 权重w: tensor([3.8878, 7.7757]), (0.01 * w.grad): tensor([0.0393, 0.0785]), loss.mean(): 58.55548095703125
第95次迭代, 权重w: tensor([3.8490, 7.6979]), (0.01 * w.grad): tensor([0.0389, 0.0778]), loss.mean(): 57.7882194519043
第96次迭代, 权重w: tensor([3.8105, 7.6209]), (0.01 * w.grad): tensor([0.0385, 0.0770]), loss.mean(): 57.03623962402344
第97次迭代, 权重w: tensor([3.7724, 7.5447]), (0.01 * w.grad): tensor([0.0381, 0.0762]), loss.mean(): 56.29921340942383
第98次迭代, 权重w: tensor([3.7346, 7.4693]), (0.01 * w.grad): tensor([0.0377, 0.0754]), loss.mean(): 55.57685852050781
第99次迭代, 权重w: tensor([3.6973, 7.3946]), (0.01 * w.grad): tensor([0.0373, 0.0747]), loss.mean(): 54.86888122558594
第100次迭代, 权重w: tensor([3.6603, 7.3206]), (0.01 * w.grad): tensor([0.0370, 0.0739]), loss.mean(): 54.17499542236328
第101次迭代, 权重w: tensor([3.6237, 7.2474]), (0.01 * w.grad): tensor([0.0366, 0.0732]), loss.mean(): 53.494911193847656
第102次迭代, 权重w: tensor([3.5875, 7.1750]), (0.01 * w.grad): tensor([0.0362, 0.0725]), loss.mean(): 52.82836151123047
第103次迭代, 权重w: tensor([3.5516, 7.1032]), (0.01 * w.grad): tensor([0.0359, 0.0717]), loss.mean(): 52.175071716308594
第104次迭代, 权重w: tensor([3.5161, 7.0322]), (0.01 * w.grad): tensor([0.0355, 0.0710]), loss.mean(): 51.5347900390625
第105次迭代, 权重w: tensor([3.4809, 6.9619]), (0.01 * w.grad): tensor([0.0352, 0.0703]), loss.mean(): 50.907249450683594
第106次迭代, 权重w: tensor([3.4461, 6.8922]), (0.01 * w.grad): tensor([0.0348, 0.0696]), loss.mean(): 50.292198181152344
第107次迭代, 权重w: tensor([3.4117, 6.8233]), (0.01 * w.grad): tensor([0.0345, 0.0689]), loss.mean(): 49.68937683105469
第108次迭代, 权重w: tensor([3.3775, 6.7551]), (0.01 * w.grad): tensor([0.0341, 0.0682]), loss.mean(): 49.09855651855469
第109次迭代, 权重w: tensor([3.3438, 6.6875]), (0.01 * w.grad): tensor([0.0338, 0.0676]), loss.mean(): 48.51949691772461
第110次迭代, 权重w: tensor([3.3103, 6.6207]), (0.01 * w.grad): tensor([0.0334, 0.0669]), loss.mean(): 47.95196533203125
第111次迭代, 权重w: tensor([3.2772, 6.5545]), (0.01 * w.grad): tensor([0.0331, 0.0662]), loss.mean(): 47.39571762084961
第112次迭代, 权重w: tensor([3.2445, 6.4889]), (0.01 * w.grad): tensor([0.0328, 0.0655]), loss.mean(): 46.850547790527344
第113次迭代, 权重w: tensor([3.2120, 6.4240]), (0.01 * w.grad): tensor([0.0324, 0.0649]), loss.mean(): 46.316219329833984
第114次迭代, 权重w: tensor([3.1799, 6.3598]), (0.01 * w.grad): tensor([0.0321, 0.0642]), loss.mean(): 45.79252624511719
第115次迭代, 权重w: tensor([3.1481, 6.2962]), (0.01 * w.grad): tensor([0.0318, 0.0636]), loss.mean(): 45.279258728027344
第116次迭代, 权重w: tensor([3.1166, 6.2332]), (0.01 * w.grad): tensor([0.0315, 0.0630]), loss.mean(): 44.77619934082031
第117次迭代, 权重w: tensor([3.0854, 6.1709]), (0.01 * w.grad): tensor([0.0312, 0.0623]), loss.mean(): 44.28315353393555
第118次迭代, 权重w: tensor([3.0546, 6.1092]), (0.01 * w.grad): tensor([0.0309, 0.0617]), loss.mean(): 43.79991912841797
第119次迭代, 权重w: tensor([3.0240, 6.0481]), (0.01 * w.grad): tensor([0.0305, 0.0611]), loss.mean(): 43.32630157470703
第120次迭代, 权重w: tensor([2.9938, 5.9876]), (0.01 * w.grad): tensor([0.0302, 0.0605]), loss.mean(): 42.86210632324219
第121次迭代, 权重w: tensor([2.9639, 5.9277]), (0.01 * w.grad): tensor([0.0299, 0.0599]), loss.mean(): 42.40715026855469
第122次迭代, 权重w: tensor([2.9342, 5.8685]), (0.01 * w.grad): tensor([0.0296, 0.0593]), loss.mean(): 41.96125030517578
第123次迭代, 权重w: tensor([2.9049, 5.8098]), (0.01 * w.grad): tensor([0.0293, 0.0587]), loss.mean(): 41.52421569824219
第124次迭代, 权重w: tensor([2.8758, 5.7517]), (0.01 * w.grad): tensor([0.0290, 0.0581]), loss.mean(): 41.09588623046875
第125次迭代, 权重w: tensor([2.8471, 5.6942]), (0.01 * w.grad): tensor([0.0288, 0.0575]), loss.mean(): 40.67607879638672
第126次迭代, 权重w: tensor([2.8186, 5.6372]), (0.01 * w.grad): tensor([0.0285, 0.0569]), loss.mean(): 40.264625549316406
第127次迭代, 权重w: tensor([2.7904, 5.5808]), (0.01 * w.grad): tensor([0.0282, 0.0564]), loss.mean(): 39.861358642578125
第128次迭代, 权重w: tensor([2.7625, 5.5250]), (0.01 * w.grad): tensor([0.0279, 0.0558]), loss.mean(): 39.46611785888672
第129次迭代, 权重w: tensor([2.7349, 5.4698]), (0.01 * w.grad): tensor([0.0276, 0.0553]), loss.mean(): 39.07874298095703
第130次迭代, 权重w: tensor([2.7075, 5.4151]), (0.01 * w.grad): tensor([0.0273, 0.0547]), loss.mean(): 38.699073791503906
第131次迭代, 权重w: tensor([2.6805, 5.3609]), (0.01 * w.grad): tensor([0.0271, 0.0542]), loss.mean(): 38.326961517333984
第132次迭代, 权重w: tensor([2.6537, 5.3073]), (0.01 * w.grad): tensor([0.0268, 0.0536]), loss.mean(): 37.96225357055664
第133次迭代, 权重w: tensor([2.6271, 5.2543]), (0.01 * w.grad): tensor([0.0265, 0.0531]), loss.mean(): 37.60480499267578
第134次迭代, 权重w: tensor([2.6009, 5.2017]), (0.01 * w.grad): tensor([0.0263, 0.0525]), loss.mean(): 37.25446701049805
第135次迭代, 权重w: tensor([2.5748, 5.1497]), (0.01 * w.grad): tensor([0.0260, 0.0520]), loss.mean(): 36.911102294921875
第136次迭代, 权重w: tensor([2.5491, 5.0982]), (0.01 * w.grad): tensor([0.0257, 0.0515]), loss.mean(): 36.57456970214844
第137次迭代, 权重w: tensor([2.5236, 5.0472]), (0.01 * w.grad): tensor([0.0255, 0.0510]), loss.mean(): 36.24473571777344
第138次迭代, 权重w: tensor([2.4984, 4.9967]), (0.01 * w.grad): tensor([0.0252, 0.0505]), loss.mean(): 35.92146682739258
第139次迭代, 权重w: tensor([2.4734, 4.9468]), (0.01 * w.grad): tensor([0.0250, 0.0500]), loss.mean(): 35.60462951660156
第140次迭代, 权重w: tensor([2.4487, 4.8973]), (0.01 * w.grad): tensor([0.0247, 0.0495]), loss.mean(): 35.294097900390625
第141次迭代, 权重w: tensor([2.4242, 4.8483]), (0.01 * w.grad): tensor([0.0245, 0.0490]), loss.mean(): 34.989742279052734
第142次迭代, 权重w: tensor([2.3999, 4.7998]), (0.01 * w.grad): tensor([0.0242, 0.0485]), loss.mean(): 34.69144821166992
第143次迭代, 权重w: tensor([2.3759, 4.7518]), (0.01 * w.grad): tensor([0.0240, 0.0480]), loss.mean(): 34.39908981323242
第144次迭代, 权重w: tensor([2.3522, 4.7043]), (0.01 * w.grad): tensor([0.0238, 0.0475]), loss.mean(): 34.112548828125
第145次迭代, 权重w: tensor([2.3286, 4.6573]), (0.01 * w.grad): tensor([0.0235, 0.0470]), loss.mean(): 33.83170700073242
第146次迭代, 权重w: tensor([2.3054, 4.6107]), (0.01 * w.grad): tensor([0.0233, 0.0466]), loss.mean(): 33.55645751953125
第147次迭代, 权重w: tensor([2.2823, 4.5646]), (0.01 * w.grad): tensor([0.0231, 0.0461]), loss.mean(): 33.28668212890625
第148次迭代, 权重w: tensor([2.2595, 4.5190]), (0.01 * w.grad): tensor([0.0228, 0.0456]), loss.mean(): 33.022274017333984
第149次迭代, 权重w: tensor([2.2369, 4.4738]), (0.01 * w.grad): tensor([0.0226, 0.0452]), loss.mean(): 32.76313400268555
第150次迭代, 权重w: tensor([2.2145, 4.4290]), (0.01 * w.grad): tensor([0.0224, 0.0447]), loss.mean(): 32.50914764404297
第151次迭代, 权重w: tensor([2.1924, 4.3847]), (0.01 * w.grad): tensor([0.0221, 0.0443]), loss.mean(): 32.260215759277344
第152次迭代, 权重w: tensor([2.1704, 4.3409]), (0.01 * w.grad): tensor([0.0219, 0.0438]), loss.mean(): 32.0162353515625
第153次迭代, 权重w: tensor([2.1487, 4.2975]), (0.01 * w.grad): tensor([0.0217, 0.0434]), loss.mean(): 31.77711296081543
第154次迭代, 权重w: tensor([2.1273, 4.2545]), (0.01 * w.grad): tensor([0.0215, 0.0430]), loss.mean(): 31.542749404907227
第155次迭代, 权重w: tensor([2.1060, 4.2120]), (0.01 * w.grad): tensor([0.0213, 0.0425]), loss.mean(): 31.313047409057617
第156次迭代, 权重w: tensor([2.0849, 4.1698]), (0.01 * w.grad): tensor([0.0211, 0.0421]), loss.mean(): 31.087915420532227
第157次迭代, 权重w: tensor([2.0641, 4.1281]), (0.01 * w.grad): tensor([0.0208, 0.0417]), loss.mean(): 30.867267608642578
第158次迭代, 权重w: tensor([2.0434, 4.0869]), (0.01 * w.grad): tensor([0.0206, 0.0413]), loss.mean(): 30.65100860595703
第159次迭代, 权重w: tensor([2.0230, 4.0460]), (0.01 * w.grad): tensor([0.0204, 0.0409]), loss.mean(): 30.43905258178711
第160次迭代, 权重w: tensor([2.0028, 4.0055]), (0.01 * w.grad): tensor([0.0202, 0.0405]), loss.mean(): 30.231313705444336
第161次迭代, 权重w: tensor([1.9827, 3.9655]), (0.01 * w.grad): tensor([0.0200, 0.0401]), loss.mean(): 30.027711868286133
第162次迭代, 权重w: tensor([1.9629, 3.9258]), (0.01 * w.grad): tensor([0.0198, 0.0397]), loss.mean(): 29.82815933227539
第163次迭代, 权重w: tensor([1.9433, 3.8866]), (0.01 * w.grad): tensor([0.0196, 0.0393]), loss.mean(): 29.632579803466797
第164次迭代, 权重w: tensor([1.9239, 3.8477]), (0.01 * w.grad): tensor([0.0194, 0.0389]), loss.mean(): 29.44089126586914
第165次迭代, 权重w: tensor([1.9046, 3.8092]), (0.01 * w.grad): tensor([0.0192, 0.0385]), loss.mean(): 29.25301742553711
第166次迭代, 权重w: tensor([1.8856, 3.7711]), (0.01 * w.grad): tensor([0.0190, 0.0381]), loss.mean(): 29.068885803222656
第167次迭代, 权重w: tensor([1.8667, 3.7334]), (0.01 * w.grad): tensor([0.0189, 0.0377]), loss.mean(): 28.888412475585938
第168次迭代, 权重w: tensor([1.8480, 3.6961]), (0.01 * w.grad): tensor([0.0187, 0.0373]), loss.mean(): 28.711532592773438
第169次迭代, 权重w: tensor([1.8296, 3.6591]), (0.01 * w.grad): tensor([0.0185, 0.0370]), loss.mean(): 28.53817367553711
第170次迭代, 权重w: tensor([1.8113, 3.6225]), (0.01 * w.grad): tensor([0.0183, 0.0366]), loss.mean(): 28.368263244628906
第171次迭代, 权重w: tensor([1.7932, 3.5863]), (0.01 * w.grad): tensor([0.0181, 0.0362]), loss.mean(): 28.201736450195312
第172次迭代, 权重w: tensor([1.7752, 3.5504]), (0.01 * w.grad): tensor([0.0179, 0.0359]), loss.mean(): 28.03852081298828
第173次迭代, 权重w: tensor([1.7575, 3.5149]), (0.01 * w.grad): tensor([0.0178, 0.0355]), loss.mean(): 27.878555297851562
第174次迭代, 权重w: tensor([1.7399, 3.4798]), (0.01 * w.grad): tensor([0.0176, 0.0351]), loss.mean(): 27.721771240234375
第175次迭代, 权重w: tensor([1.7225, 3.4450]), (0.01 * w.grad): tensor([0.0174, 0.0348]), loss.mean(): 27.56810760498047
第176次迭代, 权重w: tensor([1.7053, 3.4105]), (0.01 * w.grad): tensor([0.0172, 0.0344]), loss.mean(): 27.417503356933594
第177次迭代, 权重w: tensor([1.6882, 3.3764]), (0.01 * w.grad): tensor([0.0171, 0.0341]), loss.mean(): 27.269893646240234
第178次迭代, 权重w: tensor([1.6713, 3.3427]), (0.01 * w.grad): tensor([0.0169, 0.0338]), loss.mean(): 27.12522315979004
第179次迭代, 权重w: tensor([1.6546, 3.3093]), (0.01 * w.grad): tensor([0.0167, 0.0334]), loss.mean(): 26.98343276977539
第180次迭代, 权重w: tensor([1.6381, 3.2762]), (0.01 * w.grad): tensor([0.0165, 0.0331]), loss.mean(): 26.84446144104004
第181次迭代, 权重w: tensor([1.6217, 3.2434]), (0.01 * w.grad): tensor([0.0164, 0.0328]), loss.mean(): 26.708255767822266
第182次迭代, 权重w: tensor([1.6055, 3.2110]), (0.01 * w.grad): tensor([0.0162, 0.0324]), loss.mean(): 26.57476234436035
第183次迭代, 权重w: tensor([1.5894, 3.1789]), (0.01 * w.grad): tensor([0.0161, 0.0321]), loss.mean(): 26.443923950195312
第184次迭代, 权重w: tensor([1.5735, 3.1471]), (0.01 * w.grad): tensor([0.0159, 0.0318]), loss.mean(): 26.315689086914062
第185次迭代, 权重w: tensor([1.5578, 3.1156]), (0.01 * w.grad): tensor([0.0157, 0.0315]), loss.mean(): 26.190006256103516
第186次迭代, 权重w: tensor([1.5422, 3.0844]), (0.01 * w.grad): tensor([0.0156, 0.0312]), loss.mean(): 26.06682586669922
第187次迭代, 权重w: tensor([1.5268, 3.0536]), (0.01 * w.grad): tensor([0.0154, 0.0308]), loss.mean(): 25.94609832763672
第188次迭代, 权重w: tensor([1.5115, 3.0231]), (0.01 * w.grad): tensor([0.0153, 0.0305]), loss.mean(): 25.827770233154297
第189次迭代, 权重w: tensor([1.4964, 2.9928]), (0.01 * w.grad): tensor([0.0151, 0.0302]), loss.mean(): 25.711795806884766
第190次迭代, 权重w: tensor([1.4814, 2.9629]), (0.01 * w.grad): tensor([0.0150, 0.0299]), loss.mean(): 25.598133087158203
第191次迭代, 权重w: tensor([1.4666, 2.9333]), (0.01 * w.grad): tensor([0.0148, 0.0296]), loss.mean(): 25.48672866821289
第192次迭代, 权重w: tensor([1.4520, 2.9039]), (0.01 * w.grad): tensor([0.0147, 0.0293]), loss.mean(): 25.377544403076172
第193次迭代, 权重w: tensor([1.4374, 2.8749]), (0.01 * w.grad): tensor([0.0145, 0.0290]), loss.mean(): 25.270530700683594
第194次迭代, 权重w: tensor([1.4231, 2.8461]), (0.01 * w.grad): tensor([0.0144, 0.0287]), loss.mean(): 25.165647506713867
第195次迭代, 权重w: tensor([1.4088, 2.8177]), (0.01 * w.grad): tensor([0.0142, 0.0285]), loss.mean(): 25.062850952148438
第196次迭代, 权重w: tensor([1.3948, 2.7895]), (0.01 * w.grad): tensor([0.0141, 0.0282]), loss.mean(): 24.962100982666016
第197次迭代, 权重w: tensor([1.3808, 2.7616]), (0.01 * w.grad): tensor([0.0139, 0.0279]), loss.mean(): 24.863353729248047
第198次迭代, 权重w: tensor([1.3670, 2.7340]), (0.01 * w.grad): tensor([0.0138, 0.0276]), loss.mean(): 24.76657485961914
第199次迭代, 权重w: tensor([1.3533, 2.7067]), (0.01 * w.grad): tensor([0.0137, 0.0273]), loss.mean(): 24.67171859741211
第200次迭代, 权重w: tensor([1.3398, 2.6796]), (0.01 * w.grad): tensor([0.0135, 0.0271]), loss.mean(): 24.578750610351562
第201次迭代, 权重w: tensor([1.3264, 2.6528]), (0.01 * w.grad): tensor([0.0134, 0.0268]), loss.mean(): 24.487632751464844
第202次迭代, 权重w: tensor([1.3131, 2.6263]), (0.01 * w.grad): tensor([0.0133, 0.0265]), loss.mean(): 24.398330688476562
第203次迭代, 权重w: tensor([1.3000, 2.6000]), (0.01 * w.grad): tensor([0.0131, 0.0263]), loss.mean(): 24.310802459716797
第204次迭代, 权重w: tensor([1.2870, 2.5740]), (0.01 * w.grad): tensor([0.0130, 0.0260]), loss.mean(): 24.225017547607422
第205次迭代, 权重w: tensor([1.2741, 2.5483]), (0.01 * w.grad): tensor([0.0129, 0.0257]), loss.mean(): 24.140941619873047
第206次迭代, 权重w: tensor([1.2614, 2.5228]), (0.01 * w.grad): tensor([0.0127, 0.0255]), loss.mean(): 24.058536529541016
第207次迭代, 权重w: tensor([1.2488, 2.4976]), (0.01 * w.grad): tensor([0.0126, 0.0252]), loss.mean(): 23.977771759033203
第208次迭代, 权重w: tensor([1.2363, 2.4726]), (0.01 * w.grad): tensor([0.0125, 0.0250]), loss.mean(): 23.89861297607422
第209次迭代, 权重w: tensor([1.2239, 2.4479]), (0.01 * w.grad): tensor([0.0124, 0.0247]), loss.mean(): 23.821029663085938
第210次迭代, 权重w: tensor([1.2117, 2.4234]), (0.01 * w.grad): tensor([0.0122, 0.0245]), loss.mean(): 23.744991302490234
第211次迭代, 权重w: tensor([1.1996, 2.3991]), (0.01 * w.grad): tensor([0.0121, 0.0242]), loss.mean(): 23.670467376708984
第212次迭代, 权重w: tensor([1.1876, 2.3751]), (0.01 * w.grad): tensor([0.0120, 0.0240]), loss.mean(): 23.597423553466797
第213次迭代, 权重w: tensor([1.1757, 2.3514]), (0.01 * w.grad): tensor([0.0119, 0.0238]), loss.mean(): 23.525836944580078
第214次迭代, 权重w: tensor([1.1639, 2.3279]), (0.01 * w.grad): tensor([0.0118, 0.0235]), loss.mean(): 23.455673217773438
第215次迭代, 权重w: tensor([1.1523, 2.3046]), (0.01 * w.grad): tensor([0.0116, 0.0233]), loss.mean(): 23.386903762817383
第216次迭代, 权重w: tensor([1.1408, 2.2816]), (0.01 * w.grad): tensor([0.0115, 0.0230]), loss.mean(): 23.319503784179688
第217次迭代, 权重w: tensor([1.1294, 2.2587]), (0.01 * w.grad): tensor([0.0114, 0.0228]), loss.mean(): 23.25344467163086
第218次迭代, 权重w: tensor([1.1181, 2.2362]), (0.01 * w.grad): tensor([0.0113, 0.0226]), loss.mean(): 23.188701629638672
第219次迭代, 权重w: tensor([1.1069, 2.2138]), (0.01 * w.grad): tensor([0.0112, 0.0224]), loss.mean(): 23.125247955322266
第220次迭代, 权重w: tensor([1.0958, 2.1917]), (0.01 * w.grad): tensor([0.0111, 0.0221]), loss.mean(): 23.063053131103516
第221次迭代, 权重w: tensor([1.0849, 2.1697]), (0.01 * w.grad): tensor([0.0110, 0.0219]), loss.mean(): 23.002099990844727
第222次迭代, 权重w: tensor([1.0740, 2.1480]), (0.01 * w.grad): tensor([0.0108, 0.0217]), loss.mean(): 22.942358016967773
第223次迭代, 权重w: tensor([1.0633, 2.1266]), (0.01 * w.grad): tensor([0.0107, 0.0215]), loss.mean(): 22.883804321289062
第224次迭代, 权重w: tensor([1.0526, 2.1053]), (0.01 * w.grad): tensor([0.0106, 0.0213]), loss.mean(): 22.826416015625
第225次迭代, 权重w: tensor([1.0421, 2.0842]), (0.01 * w.grad): tensor([0.0105, 0.0211]), loss.mean(): 22.770172119140625
第226次迭代, 权重w: tensor([1.0317, 2.0634]), (0.01 * w.grad): tensor([0.0104, 0.0208]), loss.mean(): 22.715045928955078
第227次迭代, 权重w: tensor([1.0214, 2.0428]), (0.01 * w.grad): tensor([0.0103, 0.0206]), loss.mean(): 22.661014556884766
第228次迭代, 权重w: tensor([1.0112, 2.0223]), (0.01 * w.grad): tensor([0.0102, 0.0204]), loss.mean(): 22.608060836791992
第229次迭代, 权重w: tensor([1.0011, 2.0021]), (0.01 * w.grad): tensor([0.0101, 0.0202]), loss.mean(): 22.55615997314453
第230次迭代, 权重w: tensor([0.9910, 1.9821]), (0.01 * w.grad): tensor([0.0100, 0.0200]), loss.mean(): 22.505292892456055
第231次迭代, 权重w: tensor([0.9811, 1.9623]), (0.01 * w.grad): tensor([0.0099, 0.0198]), loss.mean(): 22.4554386138916
第232次迭代, 权重w: tensor([0.9713, 1.9427]), (0.01 * w.grad): tensor([0.0098, 0.0196]), loss.mean(): 22.406574249267578
第233次迭代, 权重w: tensor([0.9616, 1.9232]), (0.01 * w.grad): tensor([0.0097, 0.0194]), loss.mean(): 22.358684539794922
第234次迭代, 权重w: tensor([0.9520, 1.9040]), (0.01 * w.grad): tensor([0.0096, 0.0192]), loss.mean(): 22.311744689941406
第235次迭代, 权重w: tensor([0.9425, 1.8850]), (0.01 * w.grad): tensor([0.0095, 0.0190]), loss.mean(): 22.265743255615234
第236次迭代, 权重w: tensor([0.9331, 1.8661]), (0.01 * w.grad): tensor([0.0094, 0.0188]), loss.mean(): 22.220653533935547
第237次迭代, 权重w: tensor([0.9237, 1.8474]), (0.01 * w.grad): tensor([0.0093, 0.0187]), loss.mean(): 22.176464080810547
第238次迭代, 权重w: tensor([0.9145, 1.8290]), (0.01 * w.grad): tensor([0.0092, 0.0185]), loss.mean(): 22.13315200805664
第239次迭代, 权重w: tensor([0.9053, 1.8107]), (0.01 * w.grad): tensor([0.0091, 0.0183]), loss.mean(): 22.090702056884766
第240次迭代, 权重w: tensor([0.8963, 1.7926]), (0.01 * w.grad): tensor([0.0091, 0.0181]), loss.mean(): 22.049097061157227
第241次迭代, 权重w: tensor([0.8873, 1.7746]), (0.01 * w.grad): tensor([0.0090, 0.0179]), loss.mean(): 22.008319854736328
第242次迭代, 权重w: tensor([0.8784, 1.7569]), (0.01 * w.grad): tensor([0.0089, 0.0177]), loss.mean(): 21.968353271484375
第243次迭代, 权重w: tensor([0.8697, 1.7393]), (0.01 * w.grad): tensor([0.0088, 0.0176]), loss.mean(): 21.929183959960938
第244次迭代, 权重w: tensor([0.8610, 1.7219]), (0.01 * w.grad): tensor([0.0087, 0.0174]), loss.mean(): 21.890792846679688
第245次迭代, 权重w: tensor([0.8524, 1.7047]), (0.01 * w.grad): tensor([0.0086, 0.0172]), loss.mean(): 21.853166580200195
第246次迭代, 权重w: tensor([0.8438, 1.6877]), (0.01 * w.grad): tensor([0.0085, 0.0170]), loss.mean(): 21.816287994384766
第247次迭代, 权重w: tensor([0.8354, 1.6708]), (0.01 * w.grad): tensor([0.0084, 0.0169]), loss.mean(): 21.78014373779297
第248次迭代, 权重w: tensor([0.8270, 1.6541]), (0.01 * w.grad): tensor([0.0084, 0.0167]), loss.mean(): 21.744720458984375
第249次迭代, 权重w: tensor([0.8188, 1.6375]), (0.01 * w.grad): tensor([0.0083, 0.0165]), loss.mean(): 21.709999084472656
第250次迭代, 权重w: tensor([0.8106, 1.6212]), (0.01 * w.grad): tensor([0.0082, 0.0164]), loss.mean(): 21.67597007751465
第251次迭代, 权重w: tensor([0.8025, 1.6050]), (0.01 * w.grad): tensor([0.0081, 0.0162]), loss.mean(): 21.64261817932129
第252次迭代, 权重w: tensor([0.7945, 1.5889]), (0.01 * w.grad): tensor([0.0080, 0.0160]), loss.mean(): 21.60993194580078
第253次迭代, 权重w: tensor([0.7865, 1.5730]), (0.01 * w.grad): tensor([0.0079, 0.0159]), loss.mean(): 21.577892303466797
第254次迭代, 权重w: tensor([0.7786, 1.5573]), (0.01 * w.grad): tensor([0.0079, 0.0157]), loss.mean(): 21.546493530273438
第255次迭代, 权重w: tensor([0.7709, 1.5417]), (0.01 * w.grad): tensor([0.0078, 0.0156]), loss.mean(): 21.515716552734375
第256次迭代, 权重w: tensor([0.7631, 1.5263]), (0.01 * w.grad): tensor([0.0077, 0.0154]), loss.mean(): 21.485553741455078
第257次迭代, 权重w: tensor([0.7555, 1.5110]), (0.01 * w.grad): tensor([0.0076, 0.0153]), loss.mean(): 21.45599365234375
第258次迭代, 权重w: tensor([0.7480, 1.4959]), (0.01 * w.grad): tensor([0.0076, 0.0151]), loss.mean(): 21.427017211914062
第259次迭代, 权重w: tensor([0.7405, 1.4810]), (0.01 * w.grad): tensor([0.0075, 0.0150]), loss.mean(): 21.39862060546875
第260次迭代, 权重w: tensor([0.7331, 1.4662]), (0.01 * w.grad): tensor([0.0074, 0.0148]), loss.mean(): 21.37078857421875
第261次迭代, 权重w: tensor([0.7257, 1.4515]), (0.01 * w.grad): tensor([0.0073, 0.0147]), loss.mean(): 21.343509674072266
第262次迭代, 权重w: tensor([0.7185, 1.4370]), (0.01 * w.grad): tensor([0.0073, 0.0145]), loss.mean(): 21.3167724609375
第263次迭代, 权重w: tensor([0.7113, 1.4226]), (0.01 * w.grad): tensor([0.0072, 0.0144]), loss.mean(): 21.290569305419922
第264次迭代, 权重w: tensor([0.7042, 1.4084]), (0.01 * w.grad): tensor([0.0071, 0.0142]), loss.mean(): 21.2648868560791
第265次迭代, 权重w: tensor([0.6972, 1.3943]), (0.01 * w.grad): tensor([0.0070, 0.0141]), loss.mean(): 21.239715576171875
第266次迭代, 权重w: tensor([0.6902, 1.3804]), (0.01 * w.grad): tensor([0.0070, 0.0139]), loss.mean(): 21.215045928955078
第267次迭代, 权重w: tensor([0.6833, 1.3666]), (0.01 * w.grad): tensor([0.0069, 0.0138]), loss.mean(): 21.190866470336914
第268次迭代, 权重w: tensor([0.6764, 1.3529]), (0.01 * w.grad): tensor([0.0068, 0.0137]), loss.mean(): 21.16716766357422
第269次迭代, 权重w: tensor([0.6697, 1.3394]), (0.01 * w.grad): tensor([0.0068, 0.0135]), loss.mean(): 21.14394187927246
第270次迭代, 权重w: tensor([0.6630, 1.3260]), (0.01 * w.grad): tensor([0.0067, 0.0134]), loss.mean(): 21.121177673339844
第271次迭代, 权重w: tensor([0.6564, 1.3127]), (0.01 * w.grad): tensor([0.0066, 0.0133]), loss.mean(): 21.098865509033203
第272次迭代, 权重w: tensor([0.6498, 1.2996]), (0.01 * w.grad): tensor([0.0066, 0.0131]), loss.mean(): 21.07699966430664
第273次迭代, 权重w: tensor([0.6433, 1.2866]), (0.01 * w.grad): tensor([0.0065, 0.0130]), loss.mean(): 21.055564880371094
第274次迭代, 权重w: tensor([0.6369, 1.2737]), (0.01 * w.grad): tensor([0.0064, 0.0129]), loss.mean(): 21.034561157226562
第275次迭代, 权重w: tensor([0.6305, 1.2610]), (0.01 * w.grad): tensor([0.0064, 0.0127]), loss.mean(): 21.013973236083984
第276次迭代, 权重w: tensor([0.6242, 1.2484]), (0.01 * w.grad): tensor([0.0063, 0.0126]), loss.mean(): 20.993793487548828
第277次迭代, 权重w: tensor([0.6179, 1.2359]), (0.01 * w.grad): tensor([0.0062, 0.0125]), loss.mean(): 20.974018096923828
第278次迭代, 权重w: tensor([0.6118, 1.2235]), (0.01 * w.grad): tensor([0.0062, 0.0124]), loss.mean(): 20.954635620117188
第279次迭代, 权重w: tensor([0.6056, 1.2113]), (0.01 * w.grad): tensor([0.0061, 0.0122]), loss.mean(): 20.935638427734375
第280次迭代, 权重w: tensor([0.5996, 1.1992]), (0.01 * w.grad): tensor([0.0061, 0.0121]), loss.mean(): 20.91701889038086
第281次迭代, 权重w: tensor([0.5936, 1.1872]), (0.01 * w.grad): tensor([0.0060, 0.0120]), loss.mean(): 20.89876937866211
第282次迭代, 权重w: tensor([0.5877, 1.1753]), (0.01 * w.grad): tensor([0.0059, 0.0119]), loss.mean(): 20.880884170532227
第283次迭代, 权重w: tensor([0.5818, 1.1636]), (0.01 * w.grad): tensor([0.0059, 0.0118]), loss.mean(): 20.863353729248047
第284次迭代, 权重w: tensor([0.5760, 1.1519]), (0.01 * w.grad): tensor([0.0058, 0.0116]), loss.mean(): 20.846174240112305
第285次迭代, 权重w: tensor([0.5702, 1.1404]), (0.01 * w.grad): tensor([0.0058, 0.0115]), loss.mean(): 20.829334259033203
第286次迭代, 权重w: tensor([0.5645, 1.1290]), (0.01 * w.grad): tensor([0.0057, 0.0114]), loss.mean(): 20.81283187866211
第287次迭代, 权重w: tensor([0.5589, 1.1177]), (0.01 * w.grad): tensor([0.0056, 0.0113]), loss.mean(): 20.796655654907227
第288次迭代, 权重w: tensor([0.5533, 1.1065]), (0.01 * w.grad): tensor([0.0056, 0.0112]), loss.mean(): 20.78080177307129
第289次迭代, 权重w: tensor([0.5477, 1.0955]), (0.01 * w.grad): tensor([0.0055, 0.0111]), loss.mean(): 20.7652645111084
第290次迭代, 权重w: tensor([0.5423, 1.0845]), (0.01 * w.grad): tensor([0.0055, 0.0110]), loss.mean(): 20.75003433227539
第291次迭代, 权重w: tensor([0.5368, 1.0737]), (0.01 * w.grad): tensor([0.0054, 0.0108]), loss.mean(): 20.735111236572266
第292次迭代, 权重w: tensor([0.5315, 1.0629]), (0.01 * w.grad): tensor([0.0054, 0.0107]), loss.mean(): 20.720481872558594
第293次迭代, 权重w: tensor([0.5262, 1.0523]), (0.01 * w.grad): tensor([0.0053, 0.0106]), loss.mean(): 20.70614242553711
第294次迭代, 权重w: tensor([0.5209, 1.0418]), (0.01 * w.grad): tensor([0.0053, 0.0105]), loss.mean(): 20.69209098815918
第295次迭代, 权重w: tensor([0.5157, 1.0314]), (0.01 * w.grad): tensor([0.0052, 0.0104]), loss.mean(): 20.67831802368164
第296次迭代, 权重w: tensor([0.5105, 1.0211]), (0.01 * w.grad): tensor([0.0052, 0.0103]), loss.mean(): 20.66482162475586
第297次迭代, 权重w: tensor([0.5054, 1.0108]), (0.01 * w.grad): tensor([0.0051, 0.0102]), loss.mean(): 20.651588439941406
第298次迭代, 权重w: tensor([0.5004, 1.0007]), (0.01 * w.grad): tensor([0.0051, 0.0101]), loss.mean(): 20.638622283935547
第299次迭代, 权重w: tensor([0.4954, 0.9907]), (0.01 * w.grad): tensor([0.0050, 0.0100]), loss.mean(): 20.62591552734375
第300次迭代, 权重w: tensor([0.4904, 0.9808]), (0.01 * w.grad): tensor([0.0050, 0.0099]), loss.mean(): 20.613460540771484
第301次迭代, 权重w: tensor([0.4855, 0.9710]), (0.01 * w.grad): tensor([0.0049, 0.0098]), loss.mean(): 20.60125160217285
第302次迭代, 权重w: tensor([0.4806, 0.9613]), (0.01 * w.grad): tensor([0.0049, 0.0097]), loss.mean(): 20.58928680419922
第303次迭代, 权重w: tensor([0.4758, 0.9517]), (0.01 * w.grad): tensor([0.0048, 0.0096]), loss.mean(): 20.577560424804688
第304次迭代, 权重w: tensor([0.4711, 0.9422]), (0.01 * w.grad): tensor([0.0048, 0.0095]), loss.mean(): 20.56606674194336
第305次迭代, 权重w: tensor([0.4664, 0.9327]), (0.01 * w.grad): tensor([0.0047, 0.0094]), loss.mean(): 20.55480194091797
第306次迭代, 权重w: tensor([0.4617, 0.9234]), (0.01 * w.grad): tensor([0.0047, 0.0093]), loss.mean(): 20.54376220703125
第307次迭代, 权重w: tensor([0.4571, 0.9142]), (0.01 * w.grad): tensor([0.0046, 0.0092]), loss.mean(): 20.532939910888672
第308次迭代, 权重w: tensor([0.4525, 0.9050]), (0.01 * w.grad): tensor([0.0046, 0.0091]), loss.mean(): 20.522335052490234
第309次迭代, 权重w: tensor([0.4480, 0.8960]), (0.01 * w.grad): tensor([0.0045, 0.0091]), loss.mean(): 20.511940002441406
第310次迭代, 权重w: tensor([0.4435, 0.8870]), (0.01 * w.grad): tensor([0.0045, 0.0090]), loss.mean(): 20.501752853393555
第311次迭代, 权重w: tensor([0.4391, 0.8782]), (0.01 * w.grad): tensor([0.0044, 0.0089]), loss.mean(): 20.49176788330078
第312次迭代, 权重w: tensor([0.4347, 0.8694]), (0.01 * w.grad): tensor([0.0044, 0.0088]), loss.mean(): 20.48198127746582
第313次迭代, 权重w: tensor([0.4303, 0.8607]), (0.01 * w.grad): tensor([0.0043, 0.0087]), loss.mean(): 20.472389221191406
第314次迭代, 权重w: tensor([0.4260, 0.8521]), (0.01 * w.grad): tensor([0.0043, 0.0086]), loss.mean(): 20.462989807128906
第315次迭代, 权重w: tensor([0.4218, 0.8436]), (0.01 * w.grad): tensor([0.0043, 0.0085]), loss.mean(): 20.453777313232422
第316次迭代, 权重w: tensor([0.4176, 0.8351]), (0.01 * w.grad): tensor([0.0042, 0.0084]), loss.mean(): 20.444746017456055
第317次迭代, 权重w: tensor([0.4134, 0.8268]), (0.01 * w.grad): tensor([0.0042, 0.0084]), loss.mean(): 20.435895919799805
第318次迭代, 权重w: tensor([0.4093, 0.8185]), (0.01 * w.grad): tensor([0.0041, 0.0083]), loss.mean(): 20.427221298217773
第319次迭代, 权重w: tensor([0.4052, 0.8103]), (0.01 * w.grad): tensor([0.0041, 0.0082]), loss.mean(): 20.418720245361328
第320次迭代, 权重w: tensor([0.4011, 0.8022]), (0.01 * w.grad): tensor([0.0041, 0.0081]), loss.mean(): 20.41038703918457
第321次迭代, 权重w: tensor([0.3971, 0.7942]), (0.01 * w.grad): tensor([0.0040, 0.0080]), loss.mean(): 20.4022216796875
第322次迭代, 权重w: tensor([0.3931, 0.7863]), (0.01 * w.grad): tensor([0.0040, 0.0079]), loss.mean(): 20.394214630126953
第323次迭代, 权重w: tensor([0.3892, 0.7784]), (0.01 * w.grad): tensor([0.0039, 0.0079]), loss.mean(): 20.386371612548828
第324次迭代, 权重w: tensor([0.3853, 0.7706]), (0.01 * w.grad): tensor([0.0039, 0.0078]), loss.mean(): 20.378681182861328
第325次迭代, 权重w: tensor([0.3815, 0.7629]), (0.01 * w.grad): tensor([0.0039, 0.0077]), loss.mean(): 20.37114715576172
第326次迭代, 权重w: tensor([0.3776, 0.7553]), (0.01 * w.grad): tensor([0.0038, 0.0076]), loss.mean(): 20.36376190185547
第327次迭代, 权重w: tensor([0.3739, 0.7477]), (0.01 * w.grad): tensor([0.0038, 0.0076]), loss.mean(): 20.356521606445312
第328次迭代, 权重w: tensor([0.3701, 0.7402]), (0.01 * w.grad): tensor([0.0037, 0.0075]), loss.mean(): 20.34942626953125
第329次迭代, 权重w: tensor([0.3664, 0.7328]), (0.01 * w.grad): tensor([0.0037, 0.0074]), loss.mean(): 20.34247398376465
第330次迭代, 权重w: tensor([0.3628, 0.7255]), (0.01 * w.grad): tensor([0.0037, 0.0073]), loss.mean(): 20.33565902709961
第331次迭代, 权重w: tensor([0.3591, 0.7183]), (0.01 * w.grad): tensor([0.0036, 0.0073]), loss.mean(): 20.3289794921875
第332次迭代, 权重w: tensor([0.3555, 0.7111]), (0.01 * w.grad): tensor([0.0036, 0.0072]), loss.mean(): 20.322433471679688
第333次迭代, 权重w: tensor([0.3520, 0.7040]), (0.01 * w.grad): tensor([0.0036, 0.0071]), loss.mean(): 20.316015243530273
第334次迭代, 权重w: tensor([0.3485, 0.6969]), (0.01 * w.grad): tensor([0.0035, 0.0070]), loss.mean(): 20.30972671508789
第335次迭代, 权重w: tensor([0.3450, 0.6900]), (0.01 * w.grad): tensor([0.0035, 0.0070]), loss.mean(): 20.30356216430664
第336次迭代, 权重w: tensor([0.3415, 0.6831]), (0.01 * w.grad): tensor([0.0034, 0.0069]), loss.mean(): 20.297523498535156
第337次迭代, 权重w: tensor([0.3381, 0.6762]), (0.01 * w.grad): tensor([0.0034, 0.0068]), loss.mean(): 20.291601181030273
第338次迭代, 权重w: tensor([0.3347, 0.6695]), (0.01 * w.grad): tensor([0.0034, 0.0068]), loss.mean(): 20.285799026489258
第339次迭代, 权重w: tensor([0.3314, 0.6628]), (0.01 * w.grad): tensor([0.0033, 0.0067]), loss.mean(): 20.280113220214844
第340次迭代, 权重w: tensor([0.3281, 0.6561]), (0.01 * w.grad): tensor([0.0033, 0.0066]), loss.mean(): 20.274538040161133
第341次迭代, 权重w: tensor([0.3248, 0.6496]), (0.01 * w.grad): tensor([0.0033, 0.0066]), loss.mean(): 20.269073486328125
第342次迭代, 权重w: tensor([0.3215, 0.6431]), (0.01 * w.grad): tensor([0.0032, 0.0065]), loss.mean(): 20.26371955871582
第343次迭代, 权重w: tensor([0.3183, 0.6367]), (0.01 * w.grad): tensor([0.0032, 0.0064]), loss.mean(): 20.258472442626953
第344次迭代, 权重w: tensor([0.3151, 0.6303]), (0.01 * w.grad): tensor([0.0032, 0.0064]), loss.mean(): 20.253328323364258
第345次迭代, 权重w: tensor([0.3120, 0.6240]), (0.01 * w.grad): tensor([0.0032, 0.0063]), loss.mean(): 20.248287200927734
第346次迭代, 权重w: tensor([0.3089, 0.6177]), (0.01 * w.grad): tensor([0.0031, 0.0062]), loss.mean(): 20.243345260620117
第347次迭代, 权重w: tensor([0.3058, 0.6116]), (0.01 * w.grad): tensor([0.0031, 0.0062]), loss.mean(): 20.238502502441406
第348次迭代, 权重w: tensor([0.3027, 0.6054]), (0.01 * w.grad): tensor([0.0031, 0.0061]), loss.mean(): 20.23375701904297
第349次迭代, 权重w: tensor([0.2997, 0.5994]), (0.01 * w.grad): tensor([0.0030, 0.0061]), loss.mean(): 20.22910499572754
第350次迭代, 权重w: tensor([0.2967, 0.5934]), (0.01 * w.grad): tensor([0.0030, 0.0060]), loss.mean(): 20.224546432495117
第351次迭代, 权重w: tensor([0.2937, 0.5875]), (0.01 * w.grad): tensor([0.0030, 0.0059]), loss.mean(): 20.220077514648438
第352次迭代, 权重w: tensor([0.2908, 0.5816]), (0.01 * w.grad): tensor([0.0029, 0.0059]), loss.mean(): 20.2156982421875
第353次迭代, 权重w: tensor([0.2879, 0.5758]), (0.01 * w.grad): tensor([0.0029, 0.0058]), loss.mean(): 20.211406707763672
第354次迭代, 权重w: tensor([0.2850, 0.5700]), (0.01 * w.grad): tensor([0.0029, 0.0058]), loss.mean(): 20.207199096679688
第355次迭代, 权重w: tensor([0.2822, 0.5643]), (0.01 * w.grad): tensor([0.0029, 0.0057]), loss.mean(): 20.203075408935547
第356次迭代, 权重w: tensor([0.2793, 0.5587]), (0.01 * w.grad): tensor([0.0028, 0.0056]), loss.mean(): 20.199033737182617
第357次迭代, 权重w: tensor([0.2765, 0.5531]), (0.01 * w.grad): tensor([0.0028, 0.0056]), loss.mean(): 20.195072174072266
第358次迭代, 权重w: tensor([0.2738, 0.5476]), (0.01 * w.grad): tensor([0.0028, 0.0055]), loss.mean(): 20.191192626953125
第359次迭代, 权重w: tensor([0.2710, 0.5421]), (0.01 * w.grad): tensor([0.0027, 0.0055]), loss.mean(): 20.18738555908203
第360次迭代, 权重w: tensor([0.2683, 0.5367]), (0.01 * w.grad): tensor([0.0027, 0.0054]), loss.mean(): 20.183658599853516
第361次迭代, 权重w: tensor([0.2656, 0.5313]), (0.01 * w.grad): tensor([0.0027, 0.0054]), loss.mean(): 20.180002212524414
第362次迭代, 权重w: tensor([0.2630, 0.5260]), (0.01 * w.grad): tensor([0.0027, 0.0053]), loss.mean(): 20.176422119140625
第363次迭代, 权重w: tensor([0.2604, 0.5207]), (0.01 * w.grad): tensor([0.0026, 0.0053]), loss.mean(): 20.172910690307617
第364次迭代, 权重w: tensor([0.2578, 0.5155]), (0.01 * w.grad): tensor([0.0026, 0.0052]), loss.mean(): 20.16946792602539
第365次迭代, 权重w: tensor([0.2552, 0.5104]), (0.01 * w.grad): tensor([0.0026, 0.0052]), loss.mean(): 20.166095733642578
第366次迭代, 权重w: tensor([0.2526, 0.5053]), (0.01 * w.grad): tensor([0.0026, 0.0051]), loss.mean(): 20.162792205810547
第367次迭代, 权重w: tensor([0.2501, 0.5002]), (0.01 * w.grad): tensor([0.0025, 0.0051]), loss.mean(): 20.1595516204834
第368次迭代, 权重w: tensor([0.2476, 0.4952]), (0.01 * w.grad): tensor([0.0025, 0.0050]), loss.mean(): 20.156375885009766
第369次迭代, 权重w: tensor([0.2451, 0.4902]), (0.01 * w.grad): tensor([0.0025, 0.0050]), loss.mean(): 20.15326499938965
第370次迭代, 权重w: tensor([0.2427, 0.4853]), (0.01 * w.grad): tensor([0.0025, 0.0049]), loss.mean(): 20.15021514892578
第371次迭代, 权重w: tensor([0.2402, 0.4805]), (0.01 * w.grad): tensor([0.0024, 0.0049]), loss.mean(): 20.14722442626953
第372次迭代, 权重w: tensor([0.2378, 0.4757]), (0.01 * w.grad): tensor([0.0024, 0.0048]), loss.mean(): 20.14429473876953
第373次迭代, 权重w: tensor([0.2355, 0.4709]), (0.01 * w.grad): tensor([0.0024, 0.0048]), loss.mean(): 20.14142417907715
第374次迭代, 权重w: tensor([0.2331, 0.4662]), (0.01 * w.grad): tensor([0.0024, 0.0047]), loss.mean(): 20.13861083984375
第375次迭代, 权重w: tensor([0.2308, 0.4616]), (0.01 * w.grad): tensor([0.0023, 0.0047]), loss.mean(): 20.135852813720703
第376次迭代, 权重w: tensor([0.2285, 0.4569]), (0.01 * w.grad): tensor([0.0023, 0.0046]), loss.mean(): 20.133148193359375
第377次迭代, 权重w: tensor([0.2262, 0.4524]), (0.01 * w.grad): tensor([0.0023, 0.0046]), loss.mean(): 20.1304988861084
第378次迭代, 权重w: tensor([0.2239, 0.4479]), (0.01 * w.grad): tensor([0.0023, 0.0045]), loss.mean(): 20.12790298461914
第379次迭代, 权重w: tensor([0.2217, 0.4434]), (0.01 * w.grad): tensor([0.0022, 0.0045]), loss.mean(): 20.125356674194336
第380次迭代, 权重w: tensor([0.2195, 0.4389]), (0.01 * w.grad): tensor([0.0022, 0.0044]), loss.mean(): 20.122861862182617
第381次迭代, 权重w: tensor([0.2173, 0.4345]), (0.01 * w.grad): tensor([0.0022, 0.0044]), loss.mean(): 20.12041664123535
第382次迭代, 权重w: tensor([0.2151, 0.4302]), (0.01 * w.grad): tensor([0.0022, 0.0043]), loss.mean(): 20.11802101135254
第383次迭代, 权重w: tensor([0.2130, 0.4259]), (0.01 * w.grad): tensor([0.0022, 0.0043]), loss.mean(): 20.115673065185547
第384次迭代, 权重w: tensor([0.2108, 0.4216]), (0.01 * w.grad): tensor([0.0021, 0.0043]), loss.mean(): 20.11336898803711
第385次迭代, 权重w: tensor([0.2087, 0.4174]), (0.01 * w.grad): tensor([0.0021, 0.0042]), loss.mean(): 20.111114501953125
第386次迭代, 权重w: tensor([0.2066, 0.4133]), (0.01 * w.grad): tensor([0.0021, 0.0042]), loss.mean(): 20.108901977539062
第387次迭代, 权重w: tensor([0.2046, 0.4091]), (0.01 * w.grad): tensor([0.0021, 0.0041]), loss.mean(): 20.106735229492188
第388次迭代, 权重w: tensor([0.2025, 0.4050]), (0.01 * w.grad): tensor([0.0020, 0.0041]), loss.mean(): 20.104612350463867
第389次迭代, 权重w: tensor([0.2005, 0.4010]), (0.01 * w.grad): tensor([0.0020, 0.0041]), loss.mean(): 20.102529525756836
第390次迭代, 权重w: tensor([0.1985, 0.3970]), (0.01 * w.grad): tensor([0.0020, 0.0040]), loss.mean(): 20.10049057006836
第391次迭代, 权重w: tensor([0.1965, 0.3930]), (0.01 * w.grad): tensor([0.0020, 0.0040]), loss.mean(): 20.09848976135254
第392次迭代, 权重w: tensor([0.1945, 0.3891]), (0.01 * w.grad): tensor([0.0020, 0.0039]), loss.mean(): 20.09653091430664
第393次迭代, 权重w: tensor([0.1926, 0.3852]), (0.01 * w.grad): tensor([0.0019, 0.0039]), loss.mean(): 20.094608306884766
第394次迭代, 权重w: tensor([0.1907, 0.3813]), (0.01 * w.grad): tensor([0.0019, 0.0039]), loss.mean(): 20.09272575378418
第395次迭代, 权重w: tensor([0.1888, 0.3775]), (0.01 * w.grad): tensor([0.0019, 0.0038]), loss.mean(): 20.09088134765625
第396次迭代, 权重w: tensor([0.1869, 0.3737]), (0.01 * w.grad): tensor([0.0019, 0.0038]), loss.mean(): 20.089073181152344
第397次迭代, 权重w: tensor([0.1850, 0.3700]), (0.01 * w.grad): tensor([0.0019, 0.0037]), loss.mean(): 20.087299346923828
第398次迭代, 权重w: tensor([0.1832, 0.3663]), (0.01 * w.grad): tensor([0.0019, 0.0037]), loss.mean(): 20.08556365966797
第399次迭代, 权重w: tensor([0.1813, 0.3626]), (0.01 * w.grad): tensor([0.0018, 0.0037]), loss.mean(): 20.083860397338867
第400次迭代, 权重w: tensor([0.1795, 0.3590]), (0.01 * w.grad): tensor([0.0018, 0.0036]), loss.mean(): 20.082191467285156
第401次迭代, 权重w: tensor([0.1777, 0.3554]), (0.01 * w.grad): tensor([0.0018, 0.0036]), loss.mean(): 20.080554962158203
第402次迭代, 权重w: tensor([0.1759, 0.3519]), (0.01 * w.grad): tensor([0.0018, 0.0036]), loss.mean(): 20.07895278930664
第403次迭代, 权重w: tensor([0.1742, 0.3483]), (0.01 * w.grad): tensor([0.0018, 0.0035]), loss.mean(): 20.077381134033203
第404次迭代, 权重w: tensor([0.1724, 0.3449]), (0.01 * w.grad): tensor([0.0017, 0.0035]), loss.mean(): 20.07583999633789
第405次迭代, 权重w: tensor([0.1707, 0.3414]), (0.01 * w.grad): tensor([0.0017, 0.0034]), loss.mean(): 20.07433319091797
第406次迭代, 权重w: tensor([0.1690, 0.3380]), (0.01 * w.grad): tensor([0.0017, 0.0034]), loss.mean(): 20.072853088378906
第407次迭代, 权重w: tensor([0.1673, 0.3346]), (0.01 * w.grad): tensor([0.0017, 0.0034]), loss.mean(): 20.07140350341797
第408次迭代, 权重w: tensor([0.1656, 0.3313]), (0.01 * w.grad): tensor([0.0017, 0.0033]), loss.mean(): 20.06998062133789
第409次迭代, 权重w: tensor([0.1640, 0.3280]), (0.01 * w.grad): tensor([0.0017, 0.0033]), loss.mean(): 20.068588256835938
第410次迭代, 权重w: tensor([0.1623, 0.3247]), (0.01 * w.grad): tensor([0.0016, 0.0033]), loss.mean(): 20.067224502563477
第411次迭代, 权重w: tensor([0.1607, 0.3214]), (0.01 * w.grad): tensor([0.0016, 0.0032]), loss.mean(): 20.065887451171875
第412次迭代, 权重w: tensor([0.1591, 0.3182]), (0.01 * w.grad): tensor([0.0016, 0.0032]), loss.mean(): 20.0645751953125
第413次迭代, 权重w: tensor([0.1575, 0.3150]), (0.01 * w.grad): tensor([0.0016, 0.0032]), loss.mean(): 20.063289642333984
第414次迭代, 权重w: tensor([0.1559, 0.3119]), (0.01 * w.grad): tensor([0.0016, 0.0032]), loss.mean(): 20.062030792236328
第415次迭代, 权重w: tensor([0.1544, 0.3088]), (0.01 * w.grad): tensor([0.0016, 0.0031]), loss.mean(): 20.0607967376709
第416次迭代, 权重w: tensor([0.1528, 0.3057]), (0.01 * w.grad): tensor([0.0015, 0.0031]), loss.mean(): 20.059585571289062
第417次迭代, 权重w: tensor([0.1513, 0.3026]), (0.01 * w.grad): tensor([0.0015, 0.0031]), loss.mean(): 20.058401107788086
第418次迭代, 权重w: tensor([0.1498, 0.2996]), (0.01 * w.grad): tensor([0.0015, 0.0030]), loss.mean(): 20.057239532470703
第419次迭代, 权重w: tensor([0.1483, 0.2966]), (0.01 * w.grad): tensor([0.0015, 0.0030]), loss.mean(): 20.05609893798828
第420次迭代, 权重w: tensor([0.1468, 0.2936]), (0.01 * w.grad): tensor([0.0015, 0.0030]), loss.mean(): 20.05498504638672
第421次迭代, 权重w: tensor([0.1454, 0.2907]), (0.01 * w.grad): tensor([0.0015, 0.0029]), loss.mean(): 20.053890228271484
第422次迭代, 权重w: tensor([0.1439, 0.2878]), (0.01 * w.grad): tensor([0.0015, 0.0029]), loss.mean(): 20.052818298339844
第423次迭代, 权重w: tensor([0.1425, 0.2849]), (0.01 * w.grad): tensor([0.0014, 0.0029]), loss.mean(): 20.05176544189453
第424次迭代, 权重w: tensor([0.1410, 0.2821]), (0.01 * w.grad): tensor([0.0014, 0.0028]), loss.mean(): 20.050735473632812
第425次迭代, 权重w: tensor([0.1396, 0.2792]), (0.01 * w.grad): tensor([0.0014, 0.0028]), loss.mean(): 20.049724578857422
第426次迭代, 权重w: tensor([0.1382, 0.2765]), (0.01 * w.grad): tensor([0.0014, 0.0028]), loss.mean(): 20.048736572265625
第427次迭代, 权重w: tensor([0.1368, 0.2737]), (0.01 * w.grad): tensor([0.0014, 0.0028]), loss.mean(): 20.047767639160156
第428次迭代, 权重w: tensor([0.1355, 0.2710]), (0.01 * w.grad): tensor([0.0014, 0.0027]), loss.mean(): 20.046815872192383
第429次迭代, 权重w: tensor([0.1341, 0.2682]), (0.01 * w.grad): tensor([0.0014, 0.0027]), loss.mean(): 20.04588508605957
第430次迭代, 权重w: tensor([0.1328, 0.2656]), (0.01 * w.grad): tensor([0.0013, 0.0027]), loss.mean(): 20.044971466064453
第431次迭代, 权重w: tensor([0.1315, 0.2629]), (0.01 * w.grad): tensor([0.0013, 0.0027]), loss.mean(): 20.044076919555664
第432次迭代, 权重w: tensor([0.1301, 0.2603]), (0.01 * w.grad): tensor([0.0013, 0.0026]), loss.mean(): 20.04319953918457
第433次迭代, 权重w: tensor([0.1288, 0.2577]), (0.01 * w.grad): tensor([0.0013, 0.0026]), loss.mean(): 20.042339324951172
第434次迭代, 权重w: tensor([0.1275, 0.2551]), (0.01 * w.grad): tensor([0.0013, 0.0026]), loss.mean(): 20.04149627685547
第435次迭代, 权重w: tensor([0.1263, 0.2525]), (0.01 * w.grad): tensor([0.0013, 0.0026]), loss.mean(): 20.040672302246094
第436次迭代, 权重w: tensor([0.1250, 0.2500]), (0.01 * w.grad): tensor([0.0013, 0.0025]), loss.mean(): 20.03986358642578
第437次迭代, 权重w: tensor([0.1238, 0.2475]), (0.01 * w.grad): tensor([0.0013, 0.0025]), loss.mean(): 20.0390682220459
第438次迭代, 权重w: tensor([0.1225, 0.2450]), (0.01 * w.grad): tensor([0.0012, 0.0025]), loss.mean(): 20.038291931152344
第439次迭代, 权重w: tensor([0.1213, 0.2426]), (0.01 * w.grad): tensor([0.0012, 0.0025]), loss.mean(): 20.03752899169922
第440次迭代, 权重w: tensor([0.1201, 0.2402]), (0.01 * w.grad): tensor([0.0012, 0.0024]), loss.mean(): 20.036781311035156
第441次迭代, 权重w: tensor([0.1189, 0.2378]), (0.01 * w.grad): tensor([0.0012, 0.0024]), loss.mean(): 20.036048889160156
第442次迭代, 权重w: tensor([0.1177, 0.2354]), (0.01 * w.grad): tensor([0.0012, 0.0024]), loss.mean(): 20.03533363342285
第443次迭代, 权重w: tensor([0.1165, 0.2330]), (0.01 * w.grad): tensor([0.0012, 0.0024]), loss.mean(): 20.034629821777344
第444次迭代, 权重w: tensor([0.1154, 0.2307]), (0.01 * w.grad): tensor([0.0012, 0.0023]), loss.mean(): 20.0339412689209
第445次迭代, 权重w: tensor([0.1142, 0.2284]), (0.01 * w.grad): tensor([0.0012, 0.0023]), loss.mean(): 20.03326416015625
第446次迭代, 权重w: tensor([0.1131, 0.2261]), (0.01 * w.grad): tensor([0.0011, 0.0023]), loss.mean(): 20.032604217529297
第447次迭代, 权重w: tensor([0.1119, 0.2239]), (0.01 * w.grad): tensor([0.0011, 0.0023]), loss.mean(): 20.031953811645508
第448次迭代, 权重w: tensor([0.1108, 0.2216]), (0.01 * w.grad): tensor([0.0011, 0.0022]), loss.mean(): 20.03131866455078
第449次迭代, 权重w: tensor([0.1097, 0.2194]), (0.01 * w.grad): tensor([0.0011, 0.0022]), loss.mean(): 20.03069496154785
第450次迭代, 权重w: tensor([0.1086, 0.2172]), (0.01 * w.grad): tensor([0.0011, 0.0022]), loss.mean(): 20.03008460998535
第451次迭代, 权重w: tensor([0.1075, 0.2150]), (0.01 * w.grad): tensor([0.0011, 0.0022]), loss.mean(): 20.02948760986328
第452次迭代, 权重w: tensor([0.1064, 0.2129]), (0.01 * w.grad): tensor([0.0011, 0.0022]), loss.mean(): 20.028900146484375
第453次迭代, 权重w: tensor([0.1054, 0.2108]), (0.01 * w.grad): tensor([0.0011, 0.0021]), loss.mean(): 20.028324127197266
第454次迭代, 权重w: tensor([0.1043, 0.2086]), (0.01 * w.grad): tensor([0.0011, 0.0021]), loss.mean(): 20.027759552001953
第455次迭代, 权重w: tensor([0.1033, 0.2066]), (0.01 * w.grad): tensor([0.0010, 0.0021]), loss.mean(): 20.02720832824707
第456次迭代, 权重w: tensor([0.1022, 0.2045]), (0.01 * w.grad): tensor([0.0010, 0.0021]), loss.mean(): 20.02666664123535
第457次迭代, 权重w: tensor([0.1012, 0.2024]), (0.01 * w.grad): tensor([0.0010, 0.0020]), loss.mean(): 20.026134490966797
第458次迭代, 权重w: tensor([0.1002, 0.2004]), (0.01 * w.grad): tensor([0.0010, 0.0020]), loss.mean(): 20.025615692138672
第459次迭代, 权重w: tensor([0.0992, 0.1984]), (0.01 * w.grad): tensor([0.0010, 0.0020]), loss.mean(): 20.025104522705078
第460次迭代, 权重w: tensor([0.0982, 0.1964]), (0.01 * w.grad): tensor([0.0010, 0.0020]), loss.mean(): 20.02460479736328
第461次迭代, 权重w: tensor([0.0972, 0.1945]), (0.01 * w.grad): tensor([0.0010, 0.0020]), loss.mean(): 20.02411651611328
第462次迭代, 权重w: tensor([0.0963, 0.1925]), (0.01 * w.grad): tensor([0.0010, 0.0019]), loss.mean(): 20.023635864257812
第463次迭代, 权重w: tensor([0.0953, 0.1906]), (0.01 * w.grad): tensor([0.0010, 0.0019]), loss.mean(): 20.02316665649414
第464次迭代, 权重w: tensor([0.0943, 0.1887]), (0.01 * w.grad): tensor([0.0010, 0.0019]), loss.mean(): 20.022705078125
第465次迭代, 权重w: tensor([0.0934, 0.1868]), (0.01 * w.grad): tensor([0.0009, 0.0019]), loss.mean(): 20.022254943847656
第466次迭代, 权重w: tensor([0.0925, 0.1849]), (0.01 * w.grad): tensor([0.0009, 0.0019]), loss.mean(): 20.02181053161621
第467次迭代, 权重w: tensor([0.0915, 0.1831]), (0.01 * w.grad): tensor([0.0009, 0.0018]), loss.mean(): 20.021377563476562
第468次迭代, 权重w: tensor([0.0906, 0.1813]), (0.01 * w.grad): tensor([0.0009, 0.0018]), loss.mean(): 20.020950317382812
第469次迭代, 权重w: tensor([0.0897, 0.1794]), (0.01 * w.grad): tensor([0.0009, 0.0018]), loss.mean(): 20.02053451538086
第470次迭代, 权重w: tensor([0.0888, 0.1777]), (0.01 * w.grad): tensor([0.0009, 0.0018]), loss.mean(): 20.020126342773438
第471次迭代, 权重w: tensor([0.0879, 0.1759]), (0.01 * w.grad): tensor([0.0009, 0.0018]), loss.mean(): 20.019725799560547
第472次迭代, 权重w: tensor([0.0871, 0.1741]), (0.01 * w.grad): tensor([0.0009, 0.0018]), loss.mean(): 20.019332885742188
第473次迭代, 权重w: tensor([0.0862, 0.1724]), (0.01 * w.grad): tensor([0.0009, 0.0017]), loss.mean(): 20.01894760131836
第474次迭代, 权重w: tensor([0.0853, 0.1707]), (0.01 * w.grad): tensor([0.0009, 0.0017]), loss.mean(): 20.018569946289062
第475次迭代, 权重w: tensor([0.0845, 0.1689]), (0.01 * w.grad): tensor([0.0009, 0.0017]), loss.mean(): 20.018199920654297
第476次迭代, 权重w: tensor([0.0836, 0.1673]), (0.01 * w.grad): tensor([0.0008, 0.0017]), loss.mean(): 20.017839431762695
第477次迭代, 权重w: tensor([0.0828, 0.1656]), (0.01 * w.grad): tensor([0.0008, 0.0017]), loss.mean(): 20.017484664916992
第478次迭代, 权重w: tensor([0.0820, 0.1639]), (0.01 * w.grad): tensor([0.0008, 0.0017]), loss.mean(): 20.017135620117188
第479次迭代, 权重w: tensor([0.0811, 0.1623]), (0.01 * w.grad): tensor([0.0008, 0.0016]), loss.mean(): 20.016796112060547
第480次迭代, 权重w: tensor([0.0803, 0.1607]), (0.01 * w.grad): tensor([0.0008, 0.0016]), loss.mean(): 20.016460418701172
第481次迭代, 权重w: tensor([0.0795, 0.1591]), (0.01 * w.grad): tensor([0.0008, 0.0016]), loss.mean(): 20.016132354736328
第482次迭代, 权重w: tensor([0.0787, 0.1575]), (0.01 * w.grad): tensor([0.0008, 0.0016]), loss.mean(): 20.015811920166016
第483次迭代, 权重w: tensor([0.0779, 0.1559]), (0.01 * w.grad): tensor([0.0008, 0.0016]), loss.mean(): 20.0154972076416
第484次迭代, 权重w: tensor([0.0772, 0.1543]), (0.01 * w.grad): tensor([0.0008, 0.0016]), loss.mean(): 20.01519012451172
第485次迭代, 权重w: tensor([0.0764, 0.1528]), (0.01 * w.grad): tensor([0.0008, 0.0015]), loss.mean(): 20.0148868560791
第486次迭代, 权重w: tensor([0.0756, 0.1513]), (0.01 * w.grad): tensor([0.0008, 0.0015]), loss.mean(): 20.014591217041016
第487次迭代, 权重w: tensor([0.0749, 0.1498]), (0.01 * w.grad): tensor([0.0008, 0.0015]), loss.mean(): 20.014301300048828
第488次迭代, 权重w: tensor([0.0741, 0.1483]), (0.01 * w.grad): tensor([0.0007, 0.0015]), loss.mean(): 20.014015197753906
第489次迭代, 权重w: tensor([0.0734, 0.1468]), (0.01 * w.grad): tensor([0.0007, 0.0015]), loss.mean(): 20.013736724853516
第490次迭代, 权重w: tensor([0.0727, 0.1453]), (0.01 * w.grad): tensor([0.0007, 0.0015]), loss.mean(): 20.013463973999023
第491次迭代, 权重w: tensor([0.0719, 0.1439]), (0.01 * w.grad): tensor([0.0007, 0.0015]), loss.mean(): 20.013195037841797
第492次迭代, 权重w: tensor([0.0712, 0.1424]), (0.01 * w.grad): tensor([0.0007, 0.0014]), loss.mean(): 20.01293182373047
第493次迭代, 权重w: tensor([0.0705, 0.1410]), (0.01 * w.grad): tensor([0.0007, 0.0014]), loss.mean(): 20.012676239013672
第494次迭代, 权重w: tensor([0.0698, 0.1396]), (0.01 * w.grad): tensor([0.0007, 0.0014]), loss.mean(): 20.01242446899414
第495次迭代, 权重w: tensor([0.0691, 0.1382]), (0.01 * w.grad): tensor([0.0007, 0.0014]), loss.mean(): 20.012176513671875
第496次迭代, 权重w: tensor([0.0684, 0.1368]), (0.01 * w.grad): tensor([0.0007, 0.0014]), loss.mean(): 20.011934280395508
第497次迭代, 权重w: tensor([0.0677, 0.1354]), (0.01 * w.grad): tensor([0.0007, 0.0014]), loss.mean(): 20.011695861816406
第498次迭代, 权重w: tensor([0.0670, 0.1341]), (0.01 * w.grad): tensor([0.0007, 0.0014]), loss.mean(): 20.011463165283203
第499次迭代, 权重w: tensor([0.0664, 0.1327]), (0.01 * w.grad): tensor([0.0007, 0.0013]), loss.mean(): 20.011234283447266
第500次迭代, 权重w: tensor([0.0657, 0.1314]), (0.01 * w.grad): tensor([0.0007, 0.0013]), loss.mean(): 20.011011123657227
最终结果, 权重w: tensor([0.0657, 0.1314], requires_grad=True), 梯度: tensor([0.0664, 0.1327]), 损失均值loss.mean(): 20.011011123657227

# 绘制损失曲线
iterations = range(500)
plt.figure(figsize=(12,8))
plt.plot(iterations,loss_list)
plt.xlabel("迭代次数")
plt.ylabel("损失均值loss.mean")
plt.grid()
plt.show()

常见面试题

1. 矩阵A形状(4,5),矩阵B形状(5,4),A和B的矩阵乘法结果形状是什么？

• 矩阵A 和 矩阵B 的矩阵乘法结果形状为 (4,4)

2. pytorch中求均值、求指数、求对数的API是什么？

• 均值：torch.mean() 或 tensor.mean()
• 指数：torch.exp() 或 tensor.exp()
• 对数：torch.log() 或 tensor.log()

3. reshape和view有什么区别？

• reshape 和 view 都可以改变张量的形状，并且不改变元素顺序。
• 主要区别：
  • 1.连续性要求上，view 只能作用于 连续张量，非连续张量则会报错；reshape 可以处理 连续或非连续张量，必要时会复制数据。
  • 2.共享内存上，view 返回的张量 共享原张量内存，修改会影响原张量；reshape 不一定共享内存，有时会复制数据。

4. pytorch中哪个属性来设置开启梯度计算，哪个属性来获取梯度，哪个方法来计算梯度？

• 开启梯度计算，使用requires_grad=True
• 获取梯度，使用tensor.grad
• 计算梯度，使用loss.backward()

代码作业

• 1.使用torch.tensor()创建两个形状为(3,4)的张量t1和t2，计算(t1+t2-2)*2, 并打印。
• 2.使用torch.arange创建一个形状为(3,4)的张量t1,创建一个形状为(3,4)的随机张量t2，计算t1*t2,然后将t2转换形状为(4,3)，注意不要改变t2中元素顺序，计算t1@t2,并打印。
• 3.使用torch.randint()创建一个形状为(3,4)的随机整数张量,求所有元素的均值 和 第1个轴的均值，并打印。(注意元素类型转换)
• 4.使用torch.randint()创建一个形状为(3,4)的张量，获取第2个轴的 索引为1的所有数据，然后获取第二个轴的 索引为1的 大于5的元素 对应的 第一个轴的数据，并打印。
• 5.创建两个形状为(3,4)的随机张量t1和t2，都转换形状为(4,3), 然后按0轴进行拼接，得到形状为(8,3)的张量，并打印。
• 6.创建一个形状为(3)的随机张量w，开启requires_grad, 计算loss = w**2 + 20, 使用loss.mean().backward()获取梯度，并打印梯度w.grad。（尝试手动计算梯度）