libtorch入门-1

libtorch入门-1

torch::slice

对tensor进行切片。

Tensor::slice(int64_t dim, c10::optional<int64_t> start, c10::optional<int64_t> end, int64_t step) 
第一个参数：在哪一个维度进行切片
第二个参数：开始位置索引
第三个参数：结束位置索引
第四个参数：步长，默认为1
返回值：tensor
float a[3][3] = {{1.f,2.f,3.f},            //创建3x3数组
                              {4.f,5.f,6.f},
                              {7.f,8.f,9.f}};
torch::Tensor a_tensor = torch::from_blob(a,{3,3});            //利用数组创建tensor
torch::Tensor b_tensor = a_tensor.slice(0,0,1);                    //在维度0上索引，从0开始到1结束，即索引一行
torch::Tensor c_tensor = a_tensor.slice(1, 0, 2);                 //在维度1上索引，从0开始到2结束，即索引第一列与第二列
cout<<a_tensor<<endl;
cout<<b_tensor<<endl;
cout<<c_tensor<<endl;

//输出结果
a_tensor:
 1  2  3
 4  5  6
 7  8  9
[ CPUFloatType{3,3} ]
b_tensor:
 1  2  3
[ CPUFloatType{1,3} ]
c_tensor:
 1  2
 4  5
 7  8
[ CPUFloatType{3,2} ]

torch::max

找出tensor中指定维度的最大值及其索引

::std::tuple<at::Tensor,at::Tensor> max(const at::Tensor & self, int64_t dim, bool keepdim=false)
第一个参数：目标tensor
第二个参数：在哪一个维度
第三个参数：获得的最大值与索引是否要保持维度，默认为false
返回值：tuple(tensor)
float a[3][4] = {{1.f,2.f,3.f, 4.f},
                     {4.f,5.f,6.f, 7.f},
                     {7.f,8.f,9.f,10.f}};
torch::Tensor a_tensor = torch::from_blob(a,{3,4});
::tuple<torch::Tensor, torch::Tensor> b_tensor = torch::max(a_tensor, 0, false);
torch::Tensor max_vaule = std::get<0>(b_tensor);
torch::Tensor max_index = std::get<1>(b_tensor);
cout<<max_vaule<<endl;
cout<<max_index<<endl;

//输出结果
max_value
  7
  8
  9
 10
[ CPUFloatType{4} ]
max_index
 2
 2
 2
 2
[ CPULongType{4} ]
//当keepdim设置为tures时
  7   8   9  10
[ CPUFloatType{1,4} ]
 2  2  2  2
[ CPULongType{1,4} ]

torch::nonzero

找出tensor中非零索引，或者说找出tensor中为true的索引

at::Tensor nonzero(const at::Tensor & self)
第一个参数：目标tensor
返回值：tensor类型，对应的非0索引
float a[3][4] = {{1.f,2.f,3.f, 4.f},
                     {4.f,5.f,6.f, 7.f},
                     {7.f,8.f,9.f,10.f}};
torch::Tensor a_tensor = torch::from_blob(a,{3,4});
torch::Tensor b_tensor = torch::nonzero(a_tensor > 2.0);
cout<<b_tensor<<endl;

//输出结果
 0  2
 0  3
 1  0
 1  1
 1  2
 1  3
 2  0
 2  1
 2  2
 2  3
[ CPULongType{10,2} ]

torch::sort

libtorch中的排序算法

::std::tuple<at::Tensor,at::Tensor> sort(const at::Tensor & self, int64_t dim=-1, bool descending=false)
第一个参数：目标tensor
第二个参数：在哪一个维度
第三个参数：false从小到大，true从大到小，默认为false
返回：tuple(tensor)
 vector<float> a;
a.push_back(2.0); a.push_back(1.0); a.push_back(5.0); a.push_back(8.0);     
torch::Tensor a_tensor = torch::from_blob(a.data(), {4});     //利用vector创建tensor
cout<<a_tensor<<endl;
std::tuple<torch::Tensor, torch::Tensor> b = torch::sort(a_tensor, 0, true);
torch::Tensor value = std::get<0>(b);
torch::Tensor index = std::get<1>(b);
cout<<value<<endl;
cout<<index<<endl;

//输出结果
a_tensor:
 2
 1
 5
 8
[ CPUFloatType{4} ]
value:
 8
 5
 2
 1
[ CPUFloatType{4} ]
index:
 3
 2
 0
 1
[ CPULongType{4} ]

本文以二维tensor作为例子，方便理解，实际应用时可能是三维、四维tensor，即需深刻理解才能在高维时应用的得心应手。虽然只有四个api，但是一般将其组合起来进行使用，即需知道每一步维度的变化。