@作者:润森

PyTorch 是什么?

这是一个基于 Python 的科学计算包,适用于两组受众:

NumPy 是利用 GPU 强大功能的替代方案。

提供具有最大灵活性和速度的深度学习研究平台。

张量

张量类似于 NumPy 的 n 维数组。此外,张量也可以用在 GPU 上来加速计算。

让我们构造一个简单的张量并检查输出。首先,让我们看看我们如何构建一个 3 的 5 × 未初始化矩阵:

进口火炬

x u003d 火炬.empty(5, 3)

打印(x)

输出如下:

张量([[2.7298e+32, 4.5650e-41, 2.7298e+32],

[4.5650e-41, 0.0000e+00, 0.0000e+00],

[0.0000e+00, 0.0000e+00, 0.0000e+00],

[0.0000e+00, 0.0000e+00, 0.0000e+00],

[0.0000e+00, 0.0000e+00, 0.0000e+00]])

现在让我们构造一个随机初始化的矩阵:

x u003d 火炬.rand(5, 3)

打印(x)

输出:

张量([[1.1608e-01, 9.8966e-01, 1.2705e-01],

[A.8599Y-01, Ch.4429Y-01, P.7764J-01],

[x.8646J-01, 1.0449J-02, 4.2655J-01/],

[A.2087Y-01, i.6702Y-01, kh.1910J-01/],

[1.8414e-01, 2.0611e-01, 9.4652e-04]])

直接从数据构造张量:

x u003d torch.tensor([5.5, 3])

打印(x)

输出:

张量([5.5000, 3.0000])

创建一个统一的长张量。

x u003d torch.LongTensor(3, 4)

x

张量([[94006673833344, 210453397554, 206158430253, 193273528374],

[ 214748364849, 210453397588, 249108103216, 223338299441],

[ 210453397562, 197568495665, 206158430257, 240518168626]])

浮动张量。

x u003d torch.FloatTensor(3, 4)

x

张量([[-3.1152e-18, 3.0670e-41, 3.5032e-44, 0.0000e+00],

[ 南, p.0670y-41, 1.hak+28, 1.0795j+27],

[ 1.0899j+27, A. Tai`a +20, 1.7465j+19, 1.dz+31/]])

在范围内创建张量

torch.arange(10, dtypeu003dtorch.float)

张量([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])

重塑张量

x u003d torch.arange(10, dtypeu003dtorch.float)

x

张量([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])

利用。视图重构张量。

x.view(2, 5)

张量([[0., 1., 2., 3., 4.],

[5., 6., 7., 8., 9.]])

-1。根据张量的大小自动识别维度。

x.view(5, -1)

张量([[0., 1.],

[2., 3.],

[4., 5.],

[6., 7.],

[8., 9.]])

改变张量轴

改变张量轴:两种方法 view 和 permute

view 改变张量的顺序,而 permute 只改变轴。

x1 u003d torch.tensor([[1., 2., 3.], [4., 5., 6.]])

打印(“x1:\n”,x1)

打印(“\nx1.shape:\n”,x1.shape)

print("\nx1.view(3, -1): \n", x1.view(3, -1))

print("\nx1.permute(1, 0):\n",x1.permute(1, 0))

x1:

张量([[1., 2., 3.],

[4., 5., 6.]])

x1.形状:

火炬大小([2, 3])

x1.view(3, -1):

张量([[1., 2.],

[3., 4.],

[5., 6.]])

x1.permute (1, 0):

张量([[1., 4.],

[2., 5.],

[3., 6.]])

张量运算

在下面的示例中,我们将查看加法运算:

y u003d 火炬.rand(5, 3)

打印(x + y)

输出:

张量([[0.5429, 1.7372, 1.0293],

[0.5418, 0.6088, 1.0718],

[1.3894, 0.5148, 1.2892],

[0.9626, 0.7522, 0.9633],

[0.7547, 0.9931, 0.2709]])

Resize:如果要调整张量的形状,可以使用“torch.view”:

x u003d 火炬.randn(4, 4)

y u003d x.view(16)

Size - 1 是从其他维度推断出来的

z u003d x.view(-1, 8)

打印(x.size(), y.size(), z.size())

输出:

火炬.Size([4, 4]) 火炬.Size([16]) 火炬.Size([2, 8])

PyTorch和NumPy的转换

NumPy 是一个 Python 编程语言库,它增加了对大型和多维数组和矩阵的支持,以及对这些数组进行操作的大量高级数学函数。

将 Torch 中的 Tensor 转换为 NumPy 数组很容易,反之亦然!

Torch 张量和 NumPy 数组将共享它们的底层内存位置,改变一个会改变另一个。

将 Torch 张量转换为 NumPy 数组:

a u003d 火炬.ones(5)

打印(一)

输出:张量([1., 1., 1., 1., 1.])

b u003d a.numpy()

打印(b)

输出:[1., 1., 1., 1., 1.]

让我们执行求和运算并检查值的变化:

a.添加_(1)

打印(一)

打印(b)

输出:

张量([2., 2., 2., 2., 2.])

[2. 2. 2. 2. 2.]

将 NumPy 数组转换为 Torch 张量:

将 numpy 导入为否

a u003d np.ones(5)

b u003d torch.from_numpy(a)

np.add(a, 1, outu003da)

打印(一)

打印(b)

输出:

[2. 2. 2. 2. 2.]

张量([2., 2., 2., 2., 2.], dtypeu003dtorch.float64)

所以,如您所见,就是这么简单!

接下来,在这篇 PyTorch 教程博客上,我们来看看 PyTorch 的 AutoGrad 模块。

AutoGrad

autograd 包为张量上的所有操作提供自动推导。

它是由 run 定义的框架,这意味着您的反向传播是由您的代码运行方式定义的,并且每次迭代都可能不同。

• torch.autograd.function(函数的反向传播)

• torch.autograd.functional(计算图的反向传播)

• torch.autograd.gradcheck(数值梯度检查)

• torch.autograd.anomaly_mode(自动推导时检测错误生成路径)

• torch.autograd.grad_mode(设置是否需要渐变)

• model.eval() 和torch no_ grad()

• torch.autograd.profiler(提供函数级别统计)

接下来,使用 Autograd 进行反向传播。

如果需要_gradu003dTrue,则张量对象会跟踪它是如何创建的。

x u003d torch.tensor([1., 2., 3.], 需要_grad u003d True)

打印('x:', x)

y u003d torch.tensor([10., 20., 30.], 需要_grad u003d True)

打印('y:', y)

z u003d x + y

打印('\nz u003d x + y')

打印('z:', z)

x: 张量([1., 2., 3.], 要求_gradu003dTrue)

y: 张量([10., 20., 30.], 需要_gradu003dTrue)

z u003d x + y

z: 张量([11., 22., 33.], grad_fnu003d<AddBackward0>)

因为 requires_gradu003dTrue,所以 Z 知道它是由两个张量相加生成的,z u003d x + y。

s u003d z.sum()

印刷品

张量(66., grad_fnu003d<SumBackward0>)

s 是由其数字的总和创建的。当我们调用backward()时,反向传播从s开始。然后你可以计算梯度。

s.backward()

print('x.grad:', x.grad)

print('y.grad:', y.grad)

x.grad: 张量([1., 1., 1.])

y.grad: 张量([1., 1., 1.])

下面的例子是导数X/log的计算

进口火炬

x u003d torch.tensor([0.5, 0.75], 需要_gradu003dTrue)

1 / x

y u003d torch.log(x[0] * x[1])

y.backward()

x.grad #张量([2.0000, 1.3333])