torch张量与函数表达式写法

如何表达x y x^2y

通常一个输入是成批的，即有batch个样本为一组一起输入

input.shape为------（batch，input_length）

input_length通常为变量的长度，例：二元函数，input length=2

5个一组，二元函数，输入为（5,2）

张量input=

|----|----|
| x1 | y1 |
| x2 | y2 |
| x3 | y3 |
| x4 | y4 |
| x5 | y5 |

提取x向量：x=input[:,0]

提取x向量：y=input[:,1]

之后就是随心所欲地带入表达式来

x^2y= x**2*y

torch.stack,dim是沿着哪个方向堆叠

torch.stack 是 PyTorch 中的一个函数，用于将一系列张量沿着一个新的维度堆叠起来。这个新维度是用户指定的，它将成为返回张量的一个维度。

以下是 torch.stack 的基本用法：

复制代码

torch.stack(tensors, dim=0, out=None) -> Tensor

tensors: 一个张量序列。所有的张量都应该有相同的形状。
dim: 新的堆叠维度。这个维度将位于返回张量的第 dim 个位置。
out: （可选）输出张量。

例子

假设我们有三个形状为 (2, 3) 的张量，我们想要将它们沿着一个新的维度堆叠起来。

复制代码

import torch

# 创建三个形状为 (2, 3) 的张量
t1 = torch.tensor([[1, 2, 3], [4, 5, 6]])
t2 = torch.tensor([[7, 8, 9], [10, 11, 12]])
t3 = torch.tensor([[13, 14, 15], [16, 17, 18]])

# 将它们沿着一个新的维度堆叠起来
# 这里 dim=0，意味着新维度将位于最前面
stacked = torch.stack((t1, t2, t3), dim=0)

print(stacked)

tensor([[[ 1,  2,  3],
         [ 4,  5,  6]],

        [[ 7,  8,  9],
         [10, 11, 12]],

        [[13, 14, 15],
         [16, 17, 18]]])

返回的张量 stacked 的形状是 (3, 2, 3)。这是因为我们沿着新的第一个维度（dim=0）堆叠了三个形状为 (2, 3) 的张量。

如果我们想要沿着第二个维度堆叠，可以这样操作：

复制代码

# 将它们沿着第二个维度堆叠起来
stacked = torch.stack((t1, t2, t3), dim=1)

print(stacked)

输出将是：

复制代码

tensor([[[ 1,  2,  3],
         [ 7,  8,  9],
         [13, 14, 15]],

        [[ 4,  5,  6],
         [10, 11, 12],
         [16, 17, 18]]])

在这个例子中，返回的张量 stacked 的形状是 (2, 3, 3)，因为我们沿着第二个维度（dim=1）堆叠了三个张量。

注意，所有被堆叠的张量必须具有相同的形状，否则 torch.stack 将无法执行。

torch里的autograd里的jacobi求法

1.x的shape为（a,b）,f(x)输出为（c,）长度的向量。

autograd.functional.jacobian(f, x, create_graph=create_graph)输出形状是什么？

答案是：（c,a,b）

2.x的shape为（a,b）,f(x)输出为（a,c）

autograd.functional.jacobian(f, x, create_graph=create_graph)输出形状是什么？

答案是（a,c,a,b）

python 复制代码

import torch
from torch.autograd.functional import jacobian

# 假设 f 是一个函数，它接受一个形状为 (a, b) 的张量 x，并输出一个形状为 (c,) 的张量
def f(x):
    # (x2+y2+xy,x2+y,y3)
    fx=x[:,0],x[:,1],x[:,0]*x[:,1]#x[:,0]**2+x[:,1]**2+x[:,0]*x[:,1],x[:,0]**2+x[:,1],x[:,1]**3
    op=torch.stack(fx,dim=1)#为了让第一个维度为batch，dim取1表示横着排列
#     print("op.shape",op.shape)
#     op_sum=op.sum(dim=0)#让
#     print("op_Sum.shape",op_sum.shape)
    return op
    
# 假设 x 的形状为 (a, b)
a, b = 5, 2  # 示例维度
x = torch.randn(a, b)

# 计算 f 在 x 处的雅可比矩阵
J = jacobian(f, x)
print(x.shape)

print(f(x).shape)
# 检查雅可比矩阵的形状
print(J.shape)  # 应该输出 (c, a, b)

输出------

复制代码

torch.Size([5, 2])
torch.Size([5, 3])
torch.Size([5, 3, 5, 2])

这样比较乱，通常将不同批次的相同变量相加(dim=0de)

（,,）得到的这个东西去求jacobi，由于相加互不影响，结果是一样的

，减少计算了。

python 复制代码

import torch
from torch.autograd.functional import jacobian

# 假设 f 是一个函数，它接受一个形状为 (a, b) 的张量 x，并输出一个形状为 (c,) 的张量
def f(x):
    # (x2+y2+xy,x2+y,y3)
    fx=x[:,0],x[:,1],x[:,0]*x[:,1]#x[:,0]**2+x[:,1]**2+x[:,0]*x[:,1],x[:,0]**2+x[:,1],x[:,1]**3
    op=torch.stack(fx,dim=1)#为了让第一个维度为batch，dim取1表示横着排列
#     print("op.shape",op.shape)
    op_sum=op.sum(dim=0)#让不同批次同一位置的向量相加
#     print("op_Sum.shape",op_sum.shape)
    return op_sum
    
# 假设 x 的形状为 (a, b)
a, b = 5, 2  # 示例维度
x = torch.randn(a, b)

# 计算 f 在 x 处的雅可比矩阵
J = jacobian(f, x)
print(x.shape)

print(f(x).shape)
# 检查雅可比矩阵的形状
print(J.shape)  # 应该输出 (c, a, b)

输出

复制代码

torch.Size([5, 2])
torch.Size([3])
torch.Size([3, 5, 2])

f是(x,y,xy),J是如是算出的jacobi矩阵