动手学深度学习day1

(所有代码均是利用pytorch语法)

基础知识

数据操作

创建数据；

1、可以使用 arange 创建一个行向量 x。这个行向量包含以0开始的前12个整数。
2、我们可以创建一个形状为（2,3,4）的张量。
我们希望使用全0、全1、其他常量。

x = torch.arange(12)
x 
#tensor([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

torch.zeros((2, 3, 4))
#tensor([[[0., 0., 0., 0.],
         [0., 0., 0., 0.],
         [0., 0., 0., 0.]],

        [[0., 0., 0., 0.],
         [0., 0., 0., 0.],
         [0., 0., 0., 0.]]])

torch.ones((2, 3, 4))
#tensor([[[1., 1., 1., 1.],
         [1., 1., 1., 1.],
         [1., 1., 1., 1.]],

        [[1., 1., 1., 1.],
         [1., 1., 1., 1.],
         [1., 1., 1., 1.]]])

3、从特定分布中随机采样的数字来初始化矩阵。 其中的每个元素都从均值为0、标准差为1的标准高斯分布（正态分布）中随机采样。

torch.randn(3, 4)
#tensor([[-0.5979,  0.6042, -1.1094, -0.9001],
        [ 1.3877,  0.1119,  0.2164,  0.7615],
        [-0.6081, -0.2789, -0.7933,  0.7229]])

torch.tensor([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
#tensor([[2, 1, 4, 3],
        [1, 2, 3, 4],
        [4, 3, 2, 1]])

读取数据形式

1、可以通过张量的shape属性来访问张量的形状 。如果只想知道张量中元素的总数，可以检查它的大小（size）。

x.shape
x.numel()

torch.Size([12])
12

2、要想改变一个张量的形状而不改变元素数量和元素值，可以调用reshape函数。 例如，可以把张量x从形状为（12,）的行向量转换为形状为（3,4）的矩阵。
同时，我们可以通过-1来调用此自动计算出维度的功能。 即我们可以用x.reshape(-1,4)或x.reshape(3,-1)来取代x.reshape(3,4)。

X = x.reshape(3, 4)
X

tensor([[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]])

利用运算符对数据进行运算

1、常见的标准算术运算符（+、-、*、/和**）都可以被升级为按元素运算。

x = torch.tensor([1.0, 2, 4, 8])
y = torch.tensor([2, 2, 2, 2])
x + y, x - y, x * y, x / y, x ** y  
# **运算符是求幂运算
torch.exp(x)
#结果为
(tensor([ 3.,  4.,  6., 10.]),
 tensor([-1.,  0.,  2.,  6.]),
 tensor([ 2.,  4.,  8., 16.]),
 tensor([0.5000, 1.0000, 2.0000, 4.0000]),
 tensor([ 1.,  4., 16., 64.]))
tensor([2.7183e+00, 7.3891e+00, 5.4598e+01, 2.9810e+03])

2、我们也可以把多个张量连结（concatenate）在一起， 把它们端对端地叠起来形成一个更大的张量。
我们沿行（轴-0，形状的第一个元素） 和按列（轴-1，形状的第二个元素）连结两个矩阵时，我们可以看到，第一个输出张量的轴-0长度（6）是两个输入张量轴-0长度的总和（3+3）； 第二个输出张量的轴-1长度（8）是两个输入张量轴-1长度的总和（4+4）。

X = torch.arange(12, dtype=torch.float32).reshape((3,4))
Y = torch.tensor([[2.0, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
torch.cat((X, Y), dim=0), torch.cat((X, Y), dim=1)

(tensor([[ 0.,  1.,  2.,  3.],
         [ 4.,  5.,  6.,  7.],
         [ 8.,  9., 10., 11.],
         [ 2.,  1.,  4.,  3.],
         [ 1.,  2.,  3.,  4.],
         [ 4.,  3.,  2.,  1.]]),
 tensor([[ 0.,  1.,  2.,  3.,  2.,  1.,  4.,  3.],
         [ 4.,  5.,  6.,  7.,  1.,  2.,  3.,  4.],
         [ 8.,  9., 10., 11.,  4.,  3.,  2.,  1.]]))

以X == Y为例： 对于每个位置，如果X和Y在该位置相等，则新张量中相应项的值为1。否则该位置为0。
对张量中的所有元素进行求和，会产生一个单元素张量。

X == Y
X.sum()

tensor([[False,  True, False,  True],
        [False, False, False, False],
        [False, False, False, False]])
 tensor(66.)

广播机制

如何在相同形状的两个张量上执行按元素操作？ 在某些情况下，即使形状不同，我们仍然可以通过调用 广播机制（broadcasting mechanism）来执行按元素操作。 这种机制的工作方式如下：首先，通过适当复制元素来扩展一个或两个数组， 以便在转换之后，两个张量具有相同的形状。 其次，对生成的数组执行按元素操作。

在大多数情况下，我们将沿着数组中长度为1的轴进行广播

a = torch.arange(3).reshape((3, 1))
b = torch.arange(2).reshape((1, 2))
a, b

(tensor([[0],
         [1],
         [2]]),
 tensor([[0, 1]]))

由于a和b分别是3×1和1×2矩阵，如果让它们相加，它们的形状不匹配。 我们将两个矩阵广播为一个更大的矩阵3×2，如下所示：矩阵a将复制列， 矩阵b将复制行，然后再按元素相加。

a + b

tensor([[0, 1],
        [1, 2],
        [2, 3]])

索引和切片

第一个元素的索引是0，最后一个元素索引是-1； 可以指定范围以包含第一个元素和最后一个之前的元素。

如下所示，我们可以用[-1]选择最后一个元素，可以用[1:3]选择第二个和第三个元素：

X[-1], X[1:3]

(tensor([ 8.,  9., 10., 11.]),
 tensor([[ 4.,  5.,  6.,  7.],
         [ 8.,  9., 10., 11.]]))

#除读取外，我们还可以通过指定索引来将元素写入矩阵。
X[1, 2] = 9
X
tensor([[ 0.,  1.,  2.,  3.],
        [ 4.,  5.,  9.,  7.],
        [ 8.,  9., 10., 11.]])

#[0:2, :]访问第1行和第2行，其中“:”代表沿轴1（列）的所有元素
X[0:2, :] = 12
X
tensor([[12., 12., 12., 12.],
        [12., 12., 12., 12.],
        [ 8.,  9., 10., 11.]])

笔记来源：动手学深度学习在线课程