1.数据类型

1.1 数据类型基础

image.png
python的int类型，在PyTorch里就可以用IntTensor来表示，只不过它的维度是0，称之为标量，标量经常用来计算Loss函数的值；python的int数组，可以用维度为1的IntTensor来表示。string的表达可以用one-hot，但是one-hot不能反应字符串之间的关系，在NLP领域有Embedding相关的内容可以表示。不属于本部分内容，后面有机会再描述。
有一些重要的表述需要区分一下Dimension, Size和Tensor。一般Dimension就是说这个变量的维度，比如二维矩阵的Dimension就是2，Size是具体指每个维度的长度，比如[2, 2]，Tension就是一个具体的值。
常用的类型IntTensor，FloatTensor, ByteTensor。注意，同一个数据是在CPU上计算还是GPU上计算，PyTorch可能会用不同类型来表示，例如上图的torch.FloatTensor和torch.cuda.FloatTensor的区别。

image.png

  1. # 类型推断
  2. import torch
  3. import numpy as np
  5. # 初始化一个2行3列的tensor
  6. # 生成一个Dimension为2 的tensor
  7. a = torch.randn(2, 3)
  9. # 返回torch.FloatTensor
  10. print(a.type())
  11. # 检验类型, 返回True
  12. print(isinstance(a, torch.FloatTensor))
  15. #下面示例在CPU和GPU的类型
  16. #返回False
  17. print(isinstance(a, torch.cuda.FloatTensor))
  18. a = a.cuda()
  19. #返回True
  20. print(isinstance(a, torch.cuda.FloatTensor))
  23. #dimension为0的标量，一般用于loss函数
  24. b = torch.tensor(1.0)
  25. # 返回torch.FloatTensor
  26. print(b.type())
  27. # 返回torch.Size([])
  28. print(b.shape)
  29. #返回0
  30. print(b.ndimension())
  31. #返回torch.Size([])
  32. print(b.size())
  34. #dimension为1，长度为1的张量
  35. #一般用于Bias
  36. c = torch.tensor([1.1])
  37. #返回tensor([1.1000])
  38. print(c)
  39. #直接指定长度为1的张量，会有一个随机数
  40. d = torch.FloatTensor(1)
  41. #使用numpy来初始化
  42. d = np.ones(2)

再来看一个Dimension为4的例子：

  1. import torch
  3. # 生成一个Dimension为2的张量
  4. # Dimension为2的张量一般用于表示Linear Input batch
  5. # 比如mnist照片[4, 784]就表示4张照片，每张的像素点是784个
  6. a = torch.randn(2, 3)
  7. # 打印 tensor([[-0.1650,  1.7424,  0.9895],
  8. #        [ 0.4871,  1.1065,  1.7918]])
  9. print(a)
  10. # torch.Size([2, 3])
  11. print(a.shape)
  12. # 返回2
  13. print(a.size(0))
  14. # 返回3
  15. print(a.shape(1))

1.2 数据创建

1.2.1 从numpy中创建

  1. import numpy as np
  2. import torch
  4. a = np.array([2, 3.3])
  5. b = torch.from_numpy(a)
  6. # 返回tensor([2.0000, 3.3000], dtype=torch.float64)
  7. print(b)
  9. a = np.ones([2,3])
  10. b = torch.from_numpy(a)
  11. # tensor([[1., 1., 1.],
  12. #         [1., 1., 1.]], dtype=torch.float64)
  13. print(b)

1.2.2 使用torch api创建

  1. # 从List导入
  3. import torch
  5. # tensor是接收现有的数据
  6. a = torch.tensor([2., 3.2])
  7. print(a)
  9. # FloatTensor传值
  10. b = torch.FloatTensor([2., 3.2])
  11. # FloatTensor传shape
  12. c = torch.FloatTensor(2, 3)
  13. # 返回tensor([2.0000, 3.2000])
  14. print(b)
  15. # 返回tensor([[1.3563e-19, 1.3563e-19, 1.3563e-19],
  16. #         [1.3563e-19, 1.2708e+31, 1.7182e+25]])
  17. print(c)
  19. # tensor([[ 2.0000,  3.2000],
  20. #        [ 1.0000, 22.3000]])
  21. a = torch.tensor([[2., 3.2], [1., 22.3]])
  22. print(a)

1.2.3 设置默认推断类型

  1. import torch
  2. a = torch.tensor([1.2, 3]).type()
  3. #torch.FloatTensor
  4. print(a)
  6. torch.set_default_tensor_type(torch.DoubleTensor)
  8. a = torch.tensor([1.2, 3]).type()
  9. #torch.DoubleTensor
  10. print(a)

1.2.4 随机初始化

  1. import torch
  3. # rand从N(0,1)分布来随机读取数据
  4. a = torch.randn(3, 3)
  5. print(a)
  7. # rand_like接收一个tensor为输入，返回一个类型一样的tensor
  8. b = torch.randn_like(a)
  9. print(b)
  11. # 也可以自己设置取值的范围
  12. # 第一个是开始值，第二个是最大值，取值包含开始值小于最大值
  13. # 第三个参数是shape
  14. a = torch.randint(1, 10, [3, 3])
  15. # tensor([[2, 6, 9],
  16. #        [8, 7, 8],
  17. #        [7, 4, 8]])
  18. print(a)

1.3 索引与切片

1.3.1 直接选择维度

  1. import torch
  3. a = torch.rand(4, 3, 28, 28)
  4. # 对第一个维度的第一个元素进行索引, 并打印shape
  5. # 打印结果 torch.Size([3, 28, 28])
  6. print(a[0].shape)
  7. # 对第一个维度的第二个元素进行索引, 并打印shape
  8. # 打印结果 torch.Size([3, 28, 28])
  9. print(a[1].shape)
  11. # 对两个维度进行索引
  12. # 打印结果 torch.Size([28, 28])
  13. print(a[0, 0].shape)
  15. # 对四个维度进行索引，返回最终的一个标量
  16. # 打印结果 tensor(0.4392)
  17. print(a[0, 0, 2, 4])

1.3.2 从前/后开始选择

  1. # select first/last N
  2. a = torch.rand(4, 3, 28, 28)
  3. print(a.shape)
  5. # [num1]:[num2] 表示大于等于num1,小于num2
  6. # 选择第一个维度的前2个元素
  7. # 打印结果 torch.Size([2, 3, 28, 28])
  8. print(a[:2].shape)
  9. # :前后都没有值表示所有元素
  10. # 打印结果 torch.Size([2, 1, 28, 28])
  11. print(a[:2, :1, :, :].shape)
  12. # [num1]: 表示从num1开始到最后一个元素
  13. # 打印结果 torch.Size([2, 2, 28, 28])
  14. print(a[:2, 1:, :, :].shape)

1.3.3 按步长选择

  1. # select by steps
  2. # 按步长选择元素
  3. # 语法 num1:num2:num3 表示 开始值:结束值:步长
  4. a = torch.rand(4, 3, 28, 28)
  5. print(a.shape)
  6. # 打印结果 torch.Size([4, 3, 14, 14])
  7. print(a[:, :, ::2, ::2].shape)

1.3.4 指定index选择

  1. import torch
  3. a = torch.rand(4, 3, 28, 28)
  4. # 指定索引进行选择
  5. # 第一个参数指定维度，第二个参数给定一个数组，指定要采样的索引号
  6. b = a.index_select(0, torch.tensor([1]))
  7. # 打印结果 torch.Size([1, 3, 28, 28])
  8. print(b.shape)
  10. c = a.index_select(2, torch.arange(0, 8))
  11. # 打印结果 torch.Size([4, 3, 8, 28])
  12. print(c.shape)

1.4 维度变换

维度变换是机器学习、深度学习过程中非常常用的方法，PyTorch中一般包含四类操作：view/reshape, squeeze/unsequeeze, transpose/t/permute, expand/repeat。

1.4.1 view/reshape

view和reshape基本是同样的API，只不过是不同版本的PyTorch导致的，主要作用是将张量的shape进行变换，需要满足变换前的张量变换前不同维度的乘积和变换后不同维度的乘积相同，即prod值相等。实际中要注意，每种维度的变换应该具有其物理意义，不能无目的变换，变换会失去张量的物理意义。比如有张量tensor.Size([4,1,28,28])，假设我们可以理解为有4张图片，每张图片有1个通道，图片长和宽都是由28个像素点组成的。

1.4.2 squeeze/unsqueeze

有时候，两个张量操作时候，由于维度不一样，无法直接操作。一般，就会使用squeeze/unsqueeze来减少/增加对应的维度，以同步两个张量的维度。

1.4.3 t/transpose/permute

t是矩阵的转置操作，只适用于维度为2的张量。transpose是将张量的2个维度进行调换，要注意调换后物理内存上可能没有完成数据调换，所以要搭配contiguous()函数使用。在使用transpose和view搭配使用时候，一定要注意不能破坏张量的结构。详见示例。transpose一次操作只能调换两个维度，如a.transpose(1,3)，如果需要一次重排整个张量的结构，用permute更简单，如果a是torch.Size([4, 28, 28, 3]), 可以直接使用permute和维度索引来调换顺序，a.permute([0,2,3,1])详见示例。

1.4.4 expand/repeat

expand和repeat都可以将对应的维度的长度进行扩展，区别是Expand是逻辑扩展，不会复制数据，repeat是物理扩展，会占用内存，复制数据。详见示例。

  1. # view/reshape
  2. # Squeeze/unsqueeze
  3. # Transpose/t/permute
  4. # Expand/repeat
  6. import torch
  8. # view/reshape 通用，同numpy reshape
  9. a = torch.rand(4, 1, 28, 28)
  10. print(a.shape)
  11. # 物理意义相当于是把照片数量和通道合并在一起，把照片的行和高合并在一起
  12. b = a.view(4, 28 * 28)
  13. print(b.shape)
  15. # Squeeze 挤压 unsqueeze 展开
  16. # 在第一个维度前增加一个维度, 相当于增加一个group概念的物理意义
  17. # torch.Size([1, 4, 1, 28, 28])
  18. print(a.unsqueeze(0).shape)
  19. c = torch.tensor([1, 2])
  20. c = c.unsqueeze(0)
  21. print(c)
  22. c = c.view(2, 1)
  23. print(c)
  25. # 解决变换维度实现维度同步的例子
  26. b = torch.rand(32)
  27. f = torch.rand(4, 32, 14, 14)
  29. b = b.unsqueeze(1).unsqueeze(2).unsqueeze(0)
  30. # 返回torch.Size([1, 32, 1, 1])
  31. print(b.shape)
  32. # 后面就可以实现b和f 相加了
  34. # squeeze 维度删减
  35. # 不给参数，把所有能挤压的维度全部挤压
  36. # torch.Size([32])
  37. print(b.squeeze().shape)
  38. # 挤压掉第0维度, 返回 torch.Size([32,1,1])
  39. print(b.squeeze(0).shape)
  41. # 维度扩展Expand/repeat
  42. # 区别是Expand是逻辑扩展，不会复制数据，repeat是物理扩展，会占用内存，复制数据
  43. # torch.Size([1, 32, 1, 1])
  44. print(b.shape)
  45. # torch.Size([4, 32, 14, 14])
  46. print(b.expand(4, 32, 14, 14).shape)
  47. # 如果不想扩展其中某些维度，填-1就行了
  48. # 返回torch.Size([1, 32, 14, 1])
  49. print(b.expand(-1, 32, 14, -1).shape)
  51. # .t 适用于矩阵转置
  52. a = torch.randn(3, 4)
  53. print(a)
  54. a = a.t()
  55. print(a)
  57. # transpose 接收两个参数，包含要交换的两个维度
  58. # 需要配合contiguous()使用
  59. a = torch.randn(4, 3, 32, 32)
  60. print(a.shape)
  61. # 注意a1 破坏了结构
  62. a1 = a.transpose(1, 3).contiguous().view(4, 3 * 32 * 32).view(4, 3, 32, 32)
  63. a2 = a.transpose(1, 3).contiguous().view(4, 3 * 32 * 32).view(4, 32, 32, 3).transpose(1, 3)
  65. # tensor(False)
  66. print(torch.all(torch.eq(a, a1)))
  67. # tensor(True)
  68. print(torch.all(torch.eq(a, a2)))

另外再给一个综合一点的例子：

  1. import torch
  3. # 假设有一个学校，有5个班级，1班，2班， 3班，4班， 5班每个班级的同学都学语文，数学，英语, 物理4门科目
  4. # 每个班有3个学生，每个同学各科目分数分别是80,90,60,85
  5. a = torch.tensor([[[80, 90, 60, 85], [80, 90, 60, 85], [80, 90, 60, 85]],
  6.                   [[80, 90, 60, 85], [80, 90, 60, 85], [80, 90, 60, 85]],
  7.                   [[80, 90, 60, 85], [80, 90, 60, 85], [80, 90, 60, 85]]])
  9. print(a.shape)
  11. # 现在校长认为所有分数都比较低，要求每个同学所有分数增加5分
  12. b = torch.tensor(5)
  13. print(b.shape)
  15. # 我们需要将标量5进行变换
  16. b = b.unsqueeze(0).unsqueeze(0).expand_as(a)
  17. print(b.shape)
  18. c = a + b
  19. #tensor([[[85, 95, 65, 90],
  20. #         [85, 95, 65, 90],
  21. #         [85, 95, 65, 90]],
  22. #
  23. #        [[85, 95, 65, 90],
  24. #         [85, 95, 65, 90],
  25. #         [85, 95, 65, 90]],
  26. #
  27. #        [[85, 95, 65, 90],
  28. #         [85, 95, 65, 90],
  29. #         [85, 95, 65, 90]]])
  30. print(c)
  32. # 现在校长认为英语分数比较低，要求为每个同学英语分数再增加20分
  33. d = torch.tensor([0, 0, 20, 0])
  34. print(d.shape)
  36. d = d.unsqueeze(0).unsqueeze(0).expand_as(a)
  37. c = c + d
  38. #tensor([[[85, 95, 85, 90],
  39. #         [85, 95, 85, 90],
  40. #         [85, 95, 85, 90]],
  41. #
  42. #        [[85, 95, 85, 90],
  43. #         [85, 95, 85, 90],
  44. #         [85, 95, 85, 90]],
  45. #
  46. #        [[85, 95, 85, 90],
  47. #         [85, 95, 85, 90],
  48. #         [85, 95, 85, 90]]])
  49. print(c)

1.5 合并和分割

2. 数学基础

2.1 数学运算

2.2 统计属性

常见的统计属性，详见示例：

  • norm 求范数
  • mean sum 均值 求和
  • prod
  • max, min, argmin, argmax
  • kvthvalue, topk

2.2.1 范数

norm 不是normalize(正则化)
一范数是所有元素的绝对值求和
二范数是所有的元素的平方和，再开二次方

2.3 高阶操作