2021-01-13 16:46:36

new/dl-pt-workshop/1.md

@@ -79,19 +79,24 @@ GPU 最初是为了加速图形渲染中的计算而开发的，尤其是对于
 
 在 PyTorch 中，可以通过使用 **torch.cuda** 包将变量分配给 CUDA，如以下代码片段所示：
 
-x =火炬.Tensor（10）.random_（0，10）
-
-x.to（“不同”）
+```py
+x = torch.Tensor(10).random_(0, 10)
+x.to("cuda")
+```
 
 在这里，第一行代码创建了一个张量，该张量填充有随机整数（介于 0 和 10 之间）。 第二行代码将该张量分配给 CUDA，以便所有与该张量有关的计算都由 GPU 而不是 CPU 处理。 要将变量分配回 CPU，请使用以下代码片段：
 
-x.to（“ cpu”）
+```py
+x.to("cpu")
+```
 
 在 CUDA 中，当解决深度学习数据问题时，优良作法是分配保存网络架构的模型以及输入数据。 这将确保在训练过程中执行的所有计算均由 GPU 处理。
 
 但是，只有在您的计算机具有可用的 GPU 且您已将 CUDA 软件包安装了 PyTorch 的情况下，才能进行此分配。 要验证您是否能够在 CUDA 中分配变量，请使用以下代码段：
 
-torch.cuda.is_available（）
+```py
+torch.cuda.is_available()
+```
 
 如果前一行代码的输出为 **True** ，那么您都准备开始在 CUDA 中分配变量。
 
@@ -113,23 +118,30 @@ torch.cuda.is_available（）
 
 类似于 NumPy 阵列或任何其他类似矩阵的结构，PyTorch 张量可以具有所需的任意多个尺寸。 可以使用以下代码片段在 PyTorch 中定义一维张量（**tensor_1**）和二维张量（**tensor_2**）：
 
-te nsor_1 = torch.tensor（[1,1,0,2]）
-
-张量 _2 = torch.tensor（[[0,0,2,1,2]，[1,0,2,2,0]]）
+```py
+tensor_1 = torch.tensor([1,1,0,2])
+tensor_2 = torch.tensor([[0,0,2,1,2],[1,0,2,2,0]])
+```
 
 请注意，前面的代码片段中的数字没有含义。 重要的是不同维度的定义，其中用随机数填充。 根据前面的代码段，第一个张量在一个维度上的大小为 4，而第二张量在两个维度中的每个维度的大小为 5，可以通过使用**形状**进行验证 张量变量的]属性，如下所示：
 
+```py
 tensor_1.shape
+```
 
 输出为 **torch.Size（[4]）**。
 
-张量 _2.shape
+```py
+tensor_2.shape
+```
 
 输出为 **torch.Size（[2]，[5]）**。
 
 使用支持 GPU 的计算机时，将进行以下修改以定义张量：
 
-张量= torch.tensor（[1,1,0,2]）。cuda（）
+```py
+tensor = torch.tensor([1,1,0,2]).cuda
+```
 
 使用 PyTorch 张量创建伪数据非常简单，类似于您在 NumPy 中执行的操作。 例如， **torch.randn（）**返回一个用括号内指定尺寸的随机数填充的张量，而 **torch.randint（）**返回一个以整数填充的张量（最小 和最大值可以定义）括号内定义的尺寸：
 
@@ -137,11 +149,11 @@ tensor_1.shape
 
 此处显示的代码段使用反斜杠（**\**）将逻辑划分为多行。 执行代码时，Python 将忽略反斜杠，并将下一行中的代码视为当前行的直接延续。
 
-example_1 = torch.randn（3,3）
-
-example_2 = torch.randint（low = 0，high = 2，\
-
-size =（3,3））。type（torch.FloatTensor）
+```py
+example_1 = torch.randn(3,3)
+example_2 = torch.randint(low=0, high=2, \
+                          size=(3,3)).type(torch.FloatTensor)
+```
 
 可以看出， **example_1** 是填充有随机数的二维张量，每个维的大小等于 3，而 **example_2** 是填充有 0 和 2 的二维张量。 1s（**高**参数是上限上限），每个尺寸的大小等于 3。
 
@@ -157,47 +169,46 @@ size =（3,3））。type（torch.FloatTensor）
 
 1.  Import the PyTorch library called **torch**:
 
-    进口火炬
+    ```py
+    import torch
+    ```
 
 2.  Create tensors of the following ranks: **1**, **2**, and **3**.
 
     使用 **0** 和 **1** 之间的值填充张量。 张量的大小可以根据您的需要进行定义，前提是正确创建了等级：
 
-    张量 _1 = torch.tensor（[0.1,1,0.9,0.7,0.3]）
-
-    张量 _2 = torch.tensor（[[0,0.2,0.4,0.6]，[1,0.8,0.6,0.4]]）
-
-    tensor_3 = torch.tensor（[[[[0.3,0.6]，[1,0]]，\
-
-    [[0.3,0.6],[0,1]]])
+    ```py
+    tensor_1 = torch.tensor([0.1,1,0.9,0.7,0.3])
+    tensor_2 = torch.tensor([[0,0.2,0.4,0.6],[1,0.8,0.6,0.4]])
+    tensor_3 = torch.tensor([[[0.3,0.6],[1,0]], \
+                             [[0.3,0.6],[0,1]]])
+    ```
 
     如果您的计算机具有可用的 GPU，则可以使用 GPU 语法创建等效张量：
 
-    tensor_1 = torch.tensor（[0.1,1,0.9,0.7,0.3]）。c uda（）
-
-    张量 _2 = torch.tensor（[[0,0.2,0.4,0.6]，\
-
-    [1,0.8,0.6,0.4]]).cuda()
-
-    tensor_3 = torch.tensor（[[[[0.3,0.6]，[1,0]]，\
-
-    [[0.3,0.6],[0,1]]]).cuda()
+    ```py
+    tensor_1 = torch.tensor([0.1,1,0.9,0.7,0.3]).cuda()
+    tensor_2 = torch.tensor([[0,0.2,0.4,0.6], \
+                        [1,0.8,0.6,0.4]]).cuda()
+    tensor_3 = torch.tensor([[[0.3,0.6],[1,0]], \
+                         [[0.3,0.6],[0,1]]]).cuda()
+    ```
 
 3.  Print the shape of each of the tensors using the **shape** property, just as you would do with NumPy arrays:
 
-    打印（tensor_1.shape）
-
-    打印（tensor_2.shape）
-
-    打印（tensor_3.shape）
+    ```py
+    print(tensor_1.shape)
+    print(tensor_2.shape)
+    print(tensor_3.shape)
+    ```
 
     考虑到张量每个维度的大小可能会根据您的选择而变化，因此**打印**语句的输出应如下所示：
 
-    火炬。大小（[5]）
-
-    torch.Size（[2，4]）
-
-    torch.Size（[2，2，2]）
+    ```py
+    torch.Size([5])
+    torch.Size([2, 4])
+    torch.Size([2, 2, 2])
+    ```
 
     注意
 
@@ -249,13 +260,12 @@ PyTorch 已被许多研究人员和人工智能开发人员采用，这使其成
 
 要计算梯度，只需调用**向后（）**函数，如下所示：
 
-a = torch.tensor（[5.0，3.0]，require_grad = True）
-
-b = torch.tensor（[1.0，4.0]）
-
-ab =（（（a + b）** 2）.sum（）
-
-ab.backward（）
+```py
+a = torch.tensor([5.0, 3.0], requires_grad=True)
+b = torch.tensor([1.0, 4.0])
+ab = ((a + b) ** 2).sum()
+ab.backward()
+```
 
 在前面的代码中，创建了两个张量。 我们在这里使用 **require_grad** 参数来告诉 PyTorch 计算该张量的梯度。 但是，在构建神经网络时，不需要此参数。
 
@@ -263,15 +273,21 @@ ab.backward（）
 
 通过打印 **a** 和 **b** 的梯度，可以确认仅对第一个变量（**a**）计算梯度，而对第二个梯度进行计算 一个（**b**），则会引发错误：
 
-打印（a.grad.data）
+```py
+print(a.grad.data)
+```
 
 输出为**张量（[12.，14.]）**。
 
-打印（b.grad.data）
+```py
+print(b.grad.data)
+```
 
 输出如下：
 
-AttributeError：“ NoneType”对象没有属性“ data”
+```py
+AttributeError: 'NoneType' object has no attribute 'data'
+```
 
 ### PyTorch nn 模块