“ 基于libtorch的深度学习框架，其处理数据的主要基本单位是Tensor张量，我们可以把Tensor张量理解成矩阵，该矩阵的维度可以是1维、2维、3维，或更高维。”

本文我们来总结一下Tensor张量的常用操作。

01

打印张量的信息

打印张量的维度信息

要查看张量的维度信息，通常有两种方式：打印张量的sizes；或者直接调用张量类的print函数：

torch::Tensor b = torch::zeros({ 3, 5 });cout << b.sizes() << endl;   //方式一，只打印维度信息b.print();    //方式二，除了打印维度信息，数据类型也打印出来

运行结果：

打印张量的内容

torch::Tensor b = torch::zeros({ 3, 5 });cout << b << endl;

运行结果：

02

定义并初始化张量的值

定义一定维度的张量并初始化全部值为0

torch::Tensor b = torch::zeros({ 5, 7 });  //定义5行7列的0值张量cout << b << endl;

运行结果如下，得到5行7列的张量：

定义一定维度的张量并初始化全部值为1

auto b = torch::ones({ 3,4 });  //定义3行4列的1值张量cout << b << endl;

运行结果如下，得到3行4列的张量：

定义一定维度的单位张量

单位张量与单位向量是一个概念，即对角线值为1，其余值全部为0：

auto b = torch::eye(5);  //定义5*5单位张量cout << b << endl;

运行结果如下，得到5行5列的单位张量：

定义一定维度的张量并设置初始值

auto b = torch::full({ 3,4 }, 10);  //定义3行4列张量，并初始化全部值为0cout << b << endl;

运行结果如下，得到3行4列的张量：

此外，还可以使用另一个张量的形状作为模板，定义相同形状维度的张量，并填充初始值：

auto b = torch::full({ 3,4 }, 10);  //定义3行4列的张量b，并填充全部值为10auto a = torch::full_like(b, 2);   //定义与b相同形状的张量a，并填充初始值2auto a1 = torch::full_like(b, 2.5);  //定义与b相同形状的张量a，并填充初始值2.5auto a2 = torch::full_like(b.toType(kFloat), 2.5);  //定义与b相同形状的张量a，并填充初始值2.5cout << b << endl;cout << a << endl;cout << a1 << endl;cout << a2 << endl;

运行结果如下，我们注意到张量b的数据默认为long int型，那么使用full_like定义张量a、a1时，它们的数据类型也默认为long int型，即使a1填充值为2.5，也被自动截断为整型数2了。而a2则强行把b转换为float型，使a2也是float型数据，因此a2可以使用2.5来填充而不被自动截断为整型数了。

定义n行1列的张量，并指定初始值

auto b = torch::tensor({ 1,2,3,4,5,6,7,8 });  //定义8行1列的张量，并指定初始值cout  << b << endl;

运行结果如下，得到8行1列的张量：

定义一定维度的张量，并使用随机数初始化

//定义3行4列张量，并使用区间[0, 1)的符合均匀分布的随机数初始化auto r = torch::rand({ 3,4 });cout  << r << endl;//定义5行6列张量，并使用符合标准正态分布（均值为0，方差为1，即高斯白噪声）的随机数初始化r = torch::randn({ 5, 6 });cout  << r << endl;//定义5行5列张量，并使用区间[0, 10)的整型数初始化r = torch::randint(0, 10, { 5,5 });cout  << r << endl;

运行结果如下：

使用数组或某一段内存初始化张量

使用数组或某一段内存来初始化张量时，通常调用torch::from_blob函数来实现：

//使用数组来初始化张量内容int aa[4] = { 3,4,6,7 };auto aaaaa = torch::from_blob(aa, { 2, 2 }, torch::kInt);cout  << aaaaa << endl;//使用vector迭代容器来初始化张量内容vector<float> aaaa = { 3,4,6 };auto aaa = torch::from_blob(aaaa.data(), { 1, 1, 1, 3 }, torch::kFloat);cout  << aaa << endl;//使用Opencv的Mat来初始化张量内容，相当于把Mat转换为TensorMat x = Mat::zeros(5, 5, CV_32FC1);auto xx = torch::from_blob(x.data, { 1, 1, 5, 5 }, torch::kFloat);cout  << xx << endl;

运行结果如下：

神经网络的输入通常为一张单通道灰度图或一张三通道的彩色图，如果输入为Opencv Mat格式的三通道彩色图，我们需要格外注意数据维度的顺序，因为Mat格式的三通道图像与libtorch Tensor张量的数据维度是不一样的，前者是[Height, Width, channels]，后者是[channels, Height, Width]，如果展开成一维向量来看，Opencv Mat存储RGB图像的顺序为（每个R、G、B像素点交替存储）：

libtorch张量存储RGB图像的顺序为（依次存储所有的R、G、B像素点）：

因此将Mat格式的三通道图像转换为Tensor张量时，我们应该首先把[Height, Width, Channels]的Mat格式数据转换为[Height, Width, Channels]的Tensor张量，然后再调用Tensor张量的permute函数把数据的维度顺序调整为[Channels, Height, Width]即可。

Mat x1 = (Mat_<uchar>(5, 5) << 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25);Mat x2 = x1.clone();Mat x3 = x1.clone();vector<Mat> channels;channels.push_back(x1.clone());channels.push_back(x2.clone());channels.push_back(x3.clone());Mat x123;merge(channels, x123);  //合并成一张三通道图像cout << "[Height, Width, channels]格式的Mat:" << endl;cout << x123 << endl;//错误维度顺序示范auto x_t = torch::from_blob(x123.data, { 3, 5, 5 }, torch::kByte);cout << "直接将[Height, Width, channels]格式Mat转换为的[channels, Height, Width]格式的Tensor，维度不对应：" << endl;cout << x_t << endl;//建议的做法，确保Tensor张量的维度顺序为[channels, Height, Width]x_t = torch::from_blob(x123.data, { 5, 5, 3 }, torch::kByte);cout << "先将[Height, Width, channels]格式Mat转换为的[Height, Width, channels]格式的Tensor：" << endl;cout << x_t << endl;x_t = x_t.permute({ 2, 0, 1 });cout << "再调整Tensor的维度顺序：[Height, Width, channels]-->[channels, Height, Width]：" << endl;cout << x_t << endl;

运行结果：

此外，调用torch::from_blob函数建立的Tensor张量，与传入的指针是共用内存的，该张量并没有重新开辟一段内存，这一点需要注意。如果需要开辟内存，则通过调用clone函数来执行深拷贝：

int aa[4] = { 3,4,6,7 };auto aaaaa = torch::from_blob(aa, { 2, 2 }, torch::kInt).clone();

03

张量的拼接

按列拼接

两个张量可以按列拼接的前提条件是它们的行数一样，否则拼接会出错：

torch::Tensor a1 = torch::rand({ 2,3 });  //2行3列torch::Tensor a2 = torch::rand({ 2,1 });  //2行1列torch::Tensor cat_1 = torch::cat({ a1, a2 }, 1); //dim参数为1表示按列拼接std::cout << a1 << std::endl;std::cout << a2 << std::endl;std::cout << cat_1 << std::endl;

运行结果：

按行拼接

两个张量可以按行拼接的前提条件是它们的列数一样，否则拼接会出错：

torch::Tensor a1 = torch::rand({ 2,3 });  //2行3列torch::Tensor a2 = torch::rand({ 1,3 });  //1行3列torch::Tensor cat_1 = torch::cat({ a1, a2 }, 0);  //dim参数为0表示按行拼接std::cout << a1 << std::endl;std::cout << a2 << std::endl;std::cout << cat_1 << std::endl;

运行结果：

04

张量的切片与索引

所谓切片，我们可以把张量理解成一个蛋糕，把蛋糕切成一块块的操作就相当于切片。索引也好理解，索引就是一个地址，通过该地址我们可以定位到张量内部的某一个数值或某一部分数值。

下面我们以三维张量[channels, Height, Width]为例说明张量的常见切片、索引操作。注意所有维度的序号均从0开始。

1. 索引操作

对第1维度、第2维度的所有索引，取第3维度索引号范围i~j的数据

//linspace(1, 75, 75)为取范围再1~75之间、长度为75的数组，也即1、2、3、...、75auto a = torch::linspace(1, 75, 75).reshape({ 3, 5, 5 });  //start -- end -- lengthcout << a << endl;//对于所有第1维度、第2维度，取第3维度索引号为2的数据auto bx = a.index({ "...", 2 });  cout << bx << endl;

运行结果：

对第1维度的所有索引，取第2维度索引号为i、第3维度索引号为j的数据

auto a = torch::linspace(1, 75, 75).reshape({ 3, 5, 5 });  cout << a << endl;auto bx = a.index({ "...", 2, 3 });  //对所有第1维度，取第2维度索引号为2、第3维度索引号为3的数据cout << bx << endl;

运行结果：

对第1维度的索引号i，取第2维度、第3维度的所有索引号的数据

该操作相当于取channels个Height*Width矩阵中的第i个Height*Width矩阵。

auto a = torch::linspace(1, 75, 75).reshape({ 3, 5, 5 });  cout << a << endl;//对索引号为2的第1维度，取所有第2维度、第3维度数据auto bx = a.index({ 2, "..."});  cout << bx << endl;

运行结果：

对第1维度的索引号i、第3维度的索引号j，取第2维度所有索引的数据

该操作相当于取channels个Height*Width矩阵中的第i个Height*Width矩阵的第j列。

auto a = torch::linspace(1, 75, 75).reshape({ 3, 5, 5 });  cout << a << endl;//对索引号为2的第1维度、索引号为3的第3维度，取所有第2维度数据auto bx = a.index({ 2, "...", 3 });  cout << bx << endl;

运行结果：

直接指定张量各维度的索引

cout << "**************************" << endl;Tensor a = torch::linspace(1, 25, 25).reshape({ 5, 5 });cout << a << endl;//取第1维度索引号为1、第2维度索引号为2的所有数据auto b = a.index({ 1, 2 });  cout << b << endl;cout << "**************************" << endl;a = torch::linspace(1, 27, 27).reshape({ 3, 3, 3 });cout << a << endl;//取第1维度索引号为1、第2维度索引号为2的所有数据b = a.index({ 1, 2 });  cout << b << endl;cout << "**************************" << endl;  a = torch::linspace(1, 75, 75).reshape({ 3, 5, 5 });cout << a << endl;//取第1维度索引号为1、第2维度索引号为2、第3维度索引号为3的所有数据b = a.index({ 1, 2, 3 });  cout << b << endl;

运行结果：

通过索引赋值

auto a = torch::linspace(1, 4, 4).reshape({ 2, 2 });cout << a << endl;//将第1维度的索引号1、第2维度的索引号1处赋值为100a.index_put_({ 1, 1 }, 100);cout << a << endl;//将第1维度的索引号0、第2维度的索引号0处赋值为101a.index_put_({ 0, 0 }, 101);cout << a << endl;//将第1维度的索引号1、第2维度的索引号0处赋值为102a.index_put_({ 1, 0 }, 102);cout << a << endl;a = torch::linspace(1, 9, 9).reshape({ 3, 3 });cout << a << endl;//将第1维度的所有索引号、第2维度的索引号1处赋值为100a.index_put_({ "...", 1 }, 100);cout << a << endl;

运行结果：

2. 切片操作

切片操作主要通过调用Slice函数实现。首先我们介绍一下该函数。

Slice函数主要用于对张量的某一维进行切片时，指定切片的开始索引、结束索引，以及切片步长（切片步长默认为1）：

Slice(    //开始索引，若设置为None，则从索引0开始    c10::optional<int64_t> start_index = c10::nullopt,       //结束索引。若设置为None，则到最大索引号结束    c10::optional<int64_t> stop_index = c10::nullopt,       //切片步长，默认为1    c10::optional<int64_t> step_index = c10::nullopt        )

对第1维度，第2维度的所有索引号，从[第3维度的索引号i~第3维度的最大索引号]开始切片，默认切片步长为1

auto a = torch::linspace(1, 75, 75).reshape({ 3, 5, 5 });cout << a << endl;//从第3维度的索引号1开始切片，一直切到第3维度的最大索引号，也即取第1~第4列//这里只Slice只设置开始索引，结束索引和切片步长都默认auto b = a.index({ "...", Slice(1) });   cout << b << endl;

运行结果：

对第1维度，第2维度的所有索引号，从[第3维度的索引号i~第3维度的最大索引号]开始切片，并设定切片步长为2

auto a = torch::linspace(1, 75, 75).reshape({ 3, 5, 5 });cout << a << endl;//设定切片步长为2，从第3维度的索引号1开始切片，一直切到第3维度的最大索引号，也即取第1~第4列auto b = a.index({ "...", Slice(1, None, 2) });  cout << b << endl;

运行结果：

对第1维度，第2维度的所有索引号，从[第3维度的索引号0~第3维度的索引号i]开始切片，默认切片步长为1

注意：切片不包括第3维度的索引号i，比如i为3，则切片索引号0、1、2。

auto a = torch::linspace(1, 75, 75).reshape({ 3, 5, 5 });cout << a << endl;//对第1维度，第2维度的所有索引号，从[第3维度的索引号0~第3维度的索引号2]开始切片，默认切片步长为1auto b = a.index({ "...", Slice({None, 2}) });   cout << b << endl;

运行结果：

好了，本文就总结到这里，下文我们继续哈~

欢迎关注“萌萌哒程序猴”微信公众号，您的支持是我坚持下去的最大动力~