命名张量（Named Tensors）允许用户将显式名称与Tensor的维度关联起来，便于对Tensor进行其他操作。笔者推荐使用维度的名称进行维度操作，这样可以避免重复计算Tensor每个维度的位置。支持命名张量的工厂函数（factory functions）有tensor、empty、ones、zeros、randn等。

下面举例说明命名张量的使用，其中N代表batch_size，C代表通道数，H代表高度，W代表宽度。

In: # 命名张量API在后续还有可能还有变化，系统会提示warning，在此忽略
    import warnings
    warnings.filterwarnings("ignore")
    # 直接使用names参数创建命名张量
    imgs = t.randn(1, 2, 2, 3, names=('N', 'C', 'H', 'W'))
    imgs.names
 
 Out:('N', 'C', 'H', 'W')
 
 In: # 查看旋转操作造成的维度变换
    imgs_rotate = imgs.transpose(2, 3)
    imgs_rotate.names
 Out:('N', 'C', 'W', 'H')
 
 In: # 通过refine_names对未命名的张量命名，不需要名字的维度可以用None表示
    another_imgs = t.rand(1, 3, 2, 2)
    another_imgs = another_imgs.refine_names('N', None, 'H', 'W')
    another_imgs.names
 Out:('N', None, 'H', 'W')
 
 In: # 修改部分维度的名称
    renamed_imgs = imgs.rename(H='height', W='width')
    renamed_imgs.names
 Out:('N', 'C', 'height', 'width')
 
 In: # 通过维度的名称做维度转换
    convert_imgs = renamed_imgs.align_to('N', 'height', 'width','C')
    convert_imgs.names
 Out:('N', 'height', 'width', 'C')

在进行张量的运算时，命名张量可以提供更高的安全性。例如，在进行Tensor的加法时，如果两个Tensor的维度名称没有对齐，那么即使它们的维度相同也无法进行计算。

In: a = t.randn(1, 2, 2, 3, names=('N', 'C', 'H', 'W'))
    b = t.randn(1, 2, 2, 3, names=('N', 'H', 'C', 'W'))
    # a + b 
    # 报错，RuntimeError: Error when attempting to broadcast dims ['N', 'C', 'H', 'W'] and dims ['N', 'H', 'C', 'W']: dim 'H' and dim 'C' are at the same position from the right but do not match.

2. Tensor与NumPy

Tensor在底层设计上参考了NumPy数组，它们彼此之间的相互转换非常简单高效。因为NumPy中已经封装了常用操作，同时与Tensor之间在某些情况下共享内存，所以当遇到CPU Tensor不支持的操作时，可以先将其转成NumPy数组，完成相应处理后再转回Tensor。由于这样的操作开销很小，所以在实际应用中经常进行二者的相互转换，下面举例说明：

In: import numpy as np
    a = np.ones([2, 3], dtype=np.float32)
    aOut:array([[1., 1., 1.],
           [1., 1., 1.]], dtype=float32)In: # 从NumPy数组转化为Tensor，由于dtype为float32，所以a和b共享内存
    b = t.from_numpy(a)
    # 该种情况下，使用t.Tensor创建的Tensor与NumPy数组仍然共享内存
    # b = t.Tensor(a)
    bOut:tensor([[1., 1., 1.],
            [1., 1., 1.]])In: # 此时，NumPy数组和Tensor是共享内存的
    a[0, 1] = -1
    b # 修改a的值，b的值也会被修改Out:tensor([[ 1., -1.,  1.],
            [ 1.,  1.,  1.]])

注意：使用torch.Tensor()创建的张量默认dtype为float32，如果NumPy的数据类型与默认类型不一致，那么数据仅会被复制，不会共享内存。

In: a = np.ones([2, 3])
    # 注意和上面的a的区别（dtype不是float32）
    a.dtypeOut:dtype('float64')In: b = t.Tensor(a) # 此处进行拷贝，不共享内存
    b.dtypeOut:torch.float32In: c = t.from_numpy(a) # 注意c的类型（DoubleTensor）
    cOut:tensor([[1., 1., 1.],
            [1., 1., 1.]], dtype=torch.float64)In: a[0, 1] = -1
    print(b) # b与a不共享内存，所以即使a改变了，b也不变
    print(c) # c与a共享内存Out:tensor([[1., 1., 1.],
            [1., 1., 1.]])
    tensor([[ 1., -1.,  1.],
            [ 1.,  1.,  1.]], dtype=torch.float64)

注意：无论输入类型是什么，torch.tensor()都只进行进行数据拷贝，不会共享内存。读者需要注意torch.Tensor()，torch.from_numpy()与torch.tensor()在内存共享方面的区别。

In: a_tensor = t.tensor(a)
    a_tensor[0, 1] = 1
    a # a和a_tensor不共享内存Out:array([[ 1., -1.,  1.],
           [ 1.,  1.,  1.]])

除了使用上述操作完成NumPy和Tensor之间的数据转换，PyTorch还构建了torch.utils.dlpack模块。该模块可以实现PyTorch张量和DLPack内存张量结构之间的相互转换，因此，用户可以轻松实现不同深度学习框架的张量数据的交换。注意：转换后的DLPack张量与原PyTorch张量仍然是共享内存的。

3. Tensor的基本结构

Tensor的数据结构如图3-1所示。Tensor分为头信息区（Tensor）和存储区（Storage），头信息区主要保存Tensor的形状（size）、步长（stride）、数据类型（type）等信息，真正的数据在存储区保存成连续数组。头信息区元素占用内存较少，主要内存占用取决于Tensor中元素的数目，即存储区的大小。

一般来说，一个Tensor有与之对应的Storage，Storage是在data之上封装的接口。Tensor的内存地址指向Tensor的头（head），不同Tensor的头信息一般不同，但可能使用相同的Storage。关于Tensor的很多操作虽然创建了一个新的head，但是它们仍共享同一个Storage，下面举例说明。

In: a = t.arange(0, 6).float()
    b = a.view(2, 3)
    # Storage的内存地址一样，即它们是同一个Storage
    a.storage().data_ptr() == b.storage().data_ptr()
 Out:True
 
 In: # a改变，b也随之改变，因为它们共享Storage
    a[1] = 100
    b
 Out:tensor([[  0., 100.,   2.],
            [  3.,   4.,   5.]])
 
 In: # 对a进行索引操作，只改变了head信息，Storage相同
    c = a[2:] 
    a.storage().data_ptr() == c.storage().data_ptr()
 Out:True
 
 In: c.data_ptr(), a.data_ptr() # data_ptr返回Tensor首元素的内存地址
    # 可以看出两个内存地址相差8，这是因为2×4=8：相差两个元素，每个元素占4个字节(float)
    # 如果差值不是8，如16，那么可以用a.type()查看一下数据类型是不是torch.FloatTensor
 Out:(94880397551496, 94880397551488)
 
 In: c[0] = -100 # c[0]的内存地址对应a[2]的内存地址
    a
 Out:tensor([   0.,  100., -100.,    3.,    4.,    5.])
 
 In: d = t.Tensor(c.storage()) # d和c仍然共享内存
    d[0] = 6666
    b
 Out:tensor([[ 6.6660e+03,  1.0000e+02, -1.0000e+02],
            [ 3.0000e+00,  4.0000e+00,  5.0000e+00]])
 
 In: # 下面四个Tensor共享Storage
    a.storage().data_ptr() == b.storage().data_ptr() == c.storage().data_ptr() == d.storage().data_ptr()
 Out:True
 
 In: # c取得a的部分索引，改变了偏移量
    a.storage_offset(), c.storage_offset(), d.storage_offset()
 Out:(0, 2, 0)
 
 In: e = b[::2, ::2] # 隔2行/列取一个元素
    print(a.storage().data_ptr() == e.storage().data_ptr()) # 共享内存
    print(e.is_contiguous()) # e的存储空间是不连续的
 Out:True
    False

由此可见，绝大多数操作不是修改Tensor的Storage，而是修改了Tensor的头信息。这种做法更节省内存，同时提升了处理速度。此外，有些操作会导致Tensor不连续，这时需要调用tensor.contiguous()方法将它们变成连续的数据。该方法会复制数据到新的内存，不再与原来的数据共享Storage。

读者可以思考一个问题，高级索引一般不共享Storage，而基本索引共享Storage，这是为什么呢？（提示：基本索引可以通过修改Tensor的offset、stride和size实现，不用修改Storage的数据，高级索引则不行。）