使用pytorch进行张量计算、自动求导和神经网络构建功能

import torch
x = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], requires_grad=True)
print(x)

import torch
x = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], requires_grad=True)
print(x.shape) # 获取张量的形状，返回一个torch.Size对象
print(x.dtype) # 获取张量的数据类型，返回一个torch.dtype对象
print(x.device) # 获取张量所在的设备，返回一个torch.device对象

import torch
x = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], requires_grad=True)
print(x.size()) # 获取张量的形状，与shape属性等价，返回一个torch.Size对象
print(x.data_ptr()) # 获取张量在内存中的起始地址（整数）
print(x.numel()) # 获取张量中元素的个数（整数）
print(x.dim()) # 获取张量的维度（整数）
print(x.view(3, 2)) # 改变张量的形状，返回一个新的视图（不改变原始数据），要求元素个数不变
print(x.reshape(3, -1)) # 改变张量的形状，返回一个新的视图（不改变原始数据），-1表示自动推断该维度大小
print(x.squeeze()) # 去除所有大小为1 的维度，并返回一个新视图（不改变原始数据）
print(x.unsqueeze(1)) # 在指定位置插入一个大小为1 的维度，并返回一个新视图（不改变原始数据）

import torch
x = torch.tensor([[1.0, 2.0], [3.0, 4.0]])
y = torch.tensor([[5.0, 6.0], [7.0, 8.0]])
z = torch.add(x, y) # 等价于z = x + y 或者 z = x.add(y)
print(z)
w = torch.sub(x, y) # 等价于w = x - y 或者 w = x.sub(y)
print(w)
v = torch.mul(x, y) # 等价于v = x * y 或者 v = x.mul(y)，注意这是逐元素相乘
print(v)
u = torch.div(x, y) # 等价于u = x / y 或者 u = x.div(y)，注意这是逐元素相除
print(u)
t = torch.dot(x.view(-1), y.view(-1)) # 计算x和y的点积，注意要先将它们展平为一维向量
print(t)
s = torch.cross(x.view(2,-1), y.view(2,-1)) # 计算x和y的叉积，注意要先将它们展平为二维矩阵
print(s)

import torch
x = torch.ones(5,3) # 形状为[5,3]的张量
y = torch.ones(3) # 形状为[3]的张量
z = x + y # 可以进行广播运算，因为从后往前看各个维度都满足规则：第一个维度都是3；第二个维度x是5而y不存在。
print(z.shape) # 广播后得到形状为[5,3]的结果

a = torch.ones(2,1) # 形状为[2,1]的张量
b = a.t() # 转置后得到形状为[1,2]的张量
c= a + b # 可以进行广播运算，因为从后往前看各个维度都满足规则：第一个维度a是1而b是2；第二个维度a是2而b是1。
print(c.shape) # 广播后得到形状为[2,2]的结果

d= a * b.t

d = a * b.t() # 不能进行广播运算，因为从后往前看各个维度都不满足规则：第一个维度a是1而b是2；第二个维度a是2而b是1。
print(d.shape) # 会报错：RuntimeError: The size of tensor a (1) must match the size of tensor b (2) at non-singleton dimension 0

import torch
import numpy as np
a = np.array([[1, 2], [3, 4]]) # 创建一个numpy数组
b = torch.from_numpy(a) # 使用torch.from_numpy()函数将数组转换为张量
c = b.numpy() # 使用numpy()方法将张量转换为数组
print(type(a)) # 输出<class 'numpy.ndarray'>
print(type(b)) # 输出<class 'torch.Tensor'>
print(type(c)) # 输出<class 'numpy.ndarray'>

import torch
import numpy as np
a = np.array([[1, 2], [3, 4]]) # 创建一个numpy数组
b = torch.from_numpy(a) # 使用torch.from_numpy()函数将数组转换为张量
c = b.numpy() # 使用numpy()方法将张量转换为数组
print(type(a)) # 输出<class 'numpy.ndarray'>
print(type(b)) # 输出<class 'torch.Tensor'>
print(type(c)) # 输出<class 'numpy.ndarray'>

import torch
import numpy as np
a = np.array([[1, 2], [3, 4]]) # 创建一个numpy数组
b = torch.from_numpy(a) # 使用torch.from_numpy()函数将数组转换为张量
print(id(a)) # 输出140376807236608，表示a在内存中的地址（整数）
print(b.data_ptr()) # 输出140376807236608，表示b在内存中的起始地址（整数），与a相同，说明共享了内存空间

a[0][0] = 10 # 修改a中第一个元素为10
print(a) # 输出[[10  2] [ 3  4]]
print(b) # 输出tensor([[10,  2], [ 3,  4]])，说明b也跟着改变了

b[0][1] = -10 # 修改b中第二个元素为-10
print(b) # 输出tensor([[ 10, -10], [ 3,   4]])
print(a) # 输出[[ 10 -10] [ 3   4]]，说明a也跟着改变了

c = b.to(torch.float32) # 将b从int64类型转换为float32类型，并赋值给c
d = c.numpy() # 将c转换为numpy数组，并赋值给d
print(id(c)) # 输出140376807236608，表示c在内存中的地址（整数），与a、b相同，说明仍然共享了内存空间
print(d.data_ptr())

print(id(d)) # 输出140376807236608，表示d在内存中的地址（整数），与a、b、c相同，说明仍然共享了内存空间

c[0][0] = 100.0 # 修改c中第一个元素为100.0
print(c) # 输出tensor([[100., -10.], [ 3.,   4.]])
print(d) # 输出[[100. -10.] [ 3.   4.]]，说明d也跟着改变了

d[0][1] = -100.0 # 修改d中第二个元素为-100.0
print(d) # 输出[[ 100. -100.] [   3.    4.]]
print(c) # 输出tensor([[ 100., -100.], [   3.,    4.]])，说明c也跟着改变了

e = b.to(torch.float64) # 将b从int64类型转换为float64类型，并赋值给e
f = e.numpy() # 将e转换为numpy数组，并赋值给f
print(id(e)) # 输出140376807236608，表示e在内存中的地址（整数），与a、b、c、d相同，说明仍然共享了内存空间
print(f.data_ptr()) # 输出140376807236608，表示f在内存中的起始地址（整数），与a、b、c、d、e相同，说明仍然共享了内存空间

g = b.to(torch.device('cuda')) # 将b从CPU移动到GPU，并赋值给g
h = g.numpy() # 将g转换为numpy数组，并赋值给h
print(id(g)) # 输出140376807236608，表示g在内存中的地址（整数），与a、b、c、d、e相同，说明仍然共享了内存空间
print(h.data_ptr()) # 报错：TypeError: can't convert cuda:0 device type tensor to numpy. Use Tensor.cpu() to copy the tensor to host memory first.

import torch
x = torch.tensor([2.0, 3.0], requires_grad=True)
y = x ** 2
print(y)
y.backward()
print(x.grad)

import torch
x = torch.tensor([2.0, 3.0], requires_grad=True) # 创建一个需要求导的张量x
y = x ** 2 # 对x进行平方运算，得到y
print(y) # 输出tensor([4., 9.], grad_fn=<PowBackward0>)
y.backward() # 对y进行反向传播，计算x的梯度
print(x.grad) # 输出tensor([4., 6.])

print(y.grad_fn) # 输出<PowBackward0 object at 0x7f8c1c1a5b80>

print(y.grad_fn.next_functions) # 输出((<AccumulateGrad object at 0x7f8c1c1a5b50>, 0),)

print(y.grad_fn.next_functions[0]) # 输出(<AccumulateGrad object at 0x7f8c1c1a5b50>, 0)

print(y.grad_fn.next_functions[0][0].variable) # 输出tensor([2., 3.], requires_grad=True)

print(y.grad_fn.saved_tensors) # 输出()

import torch
x = torch.tensor([2.0, 3.0], requires_grad=True) # 创建一个需要求导的张量x
y = x ** 2 # 对x进行平方运算，得到y
print(x.is_leaf) # 输出True，因为x是用户直接创建的
print(y.is_leaf) # 输出False，因为y是由x经过运算得到的
y.backward() # 对y进行反向传播，计算x和y的梯度
print(x.grad) # 输出tensor([4., 6.])，因为x是叶子节点，所以它的梯度被累加到了.grad属性中
print(y.grad) # 输出None，因为y是非叶子节点，并且没有使用retain_grad()方法来保存它的梯度

import torch
x = torch.tensor([2.0, 3.0], requires_grad=True) # 创建一个需要求导的张量x
y = x ** 2 # 对x进行平方运算，得到y
print(x.is_leaf) # 输出True，因为x是用户直接创建的
print(y.is_leaf) # 输出False，因为y是由x经过运算得到的
y.backward() # 对y进行反向传播，计算x和y的梯度
print(x.grad) # 输出tensor([4., 6.])，因为x是叶子节点，所以它的梯度被累加到了.grad属性中
print(y.grad) # 输出None，因为y是非叶子节点，并且没有使用retain_grad()方法来保存它的梯度

# 清除张量中已有的梯度值
x.grad.zero_()
# 或者清除优化器中已有的梯度值（如果有）
# optimizer.zero_grad()

# 禁止张量中新产生的梯度计算和累加
with torch.no_grad():
    z = x ** 3 # 对x进行立方运算，得到z
    print(z.requires_grad) # 输出False, 因为z不需要求导

import torch
import torch.nn as nn

# 定义线性回归模型 y = wx + b
class LinearRegression(nn.Module):
    def __init__(self):
        super(LinearRegression, self).__init__()
        self.linear = nn.Linear(1, 1) # 输入维度为1，输出维度为1

    def forward(self, x):
        y = self.linear(x) # 前向传播逻辑
        return y

# 创建模型实例
model = LinearRegression()
print(model)

# 创建损失函数（均方误差）和优化器（随机梯度下降）
criterion = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.

# 生成随机数据
x = torch.randn(100, 1) # 100个随机输入
y = 3 * x + 2 + torch.randn(100, 1) # 对应的输出，加上一些噪声

# 训练模型
epochs = 20 # 迭代次数
for epoch in range(epochs):
    # 前向传播，得到预测值
    y_pred = model(x)
    # 计算损失值
    loss = criterion(y_pred, y)
    # 反向传播，计算梯度
    loss.backward()
    # 更新参数
    optimizer.step()
    # 清零梯度
    optimizer.zero_grad()
    # 打印损失值和参数值
    print(f"Epoch {epoch}, loss: {loss.item():.4f}")
    for name, param in model.named_parameters():
        print(name, param.data)

# 测试模型
x_test = torch.tensor([[4.0]]) # 测试输入
y_test = model(x_test) # 预测输出
print(f"Predicted y for x = 4: {y_test.item():.4f}")