Libtorch 与 Pytorch常用写法对比

#include<iostream>
#include<torch/torch.h>
#include<torch/script.h>

int main()
{
    torch::Tensor t1 = torch::rand({4, 5});

    // print shape
    t1.print();
    std::cout << "t1.sizes = " << t1.sizes() << std::endl;
    // print the tensor
    std::cout << "t1 = " << t1 << std::endl;             std::cout << std::endl;
    float a1 = t1[1][2].item().toFloat();
    std::cout << "t1[1][2] = " << a1 << std::endl; std::cout << std::endl;

    // 访问某一列
    torch::Tensor t2 = t1.select(0, 3); // 0 = dimY, 1 = dimX
    // print the tensor
    std::cout << "t2 = " << t2 << std::endl; std::cout << std::endl;

    // 批量处理
    torch::Tensor t3 = torch::rand({ 3, 5 });
    std::cout << "t3 = " << t3 << std::endl;             std::cout << std::endl;
    torch::Tensor t4 = t3.ge(0.5);
    std::cout << "t4 = " << t4 << std::endl;             std::cout << std::endl;
    torch::Tensor t5 = (t3 > 0.5); // 0 or 1, as bool vec
    std::cout << "t5 = " << t5 << std::endl;             std::cout << std::endl;
    
    torch::Tensor t6 = torch::masked_select(t3, t5);
    std::cout << "t6 = " << t6 << std::endl;             std::cout << std::endl;

    torch::Tensor t7 = t3.masked_select(t5);
    std::cout << "t7 = " << t7 << std::endl;             std::cout << std::endl;

    // 创建一个mask，筛选行
    // torch::from_blob 针对torch::kBool居然有bug
    /*std::vector<int> v4{1, 0, 1};
    torch::Tensor mask4 = torch::from_blob(v4.data(), { 3, 1 }, torch::kBool);
    std::cout << "mask4 = " << mask4 << std::endl;*/
    torch::Tensor mask5 = torch::tensor({ {1}, {0}, {1} }, torch::kBool);
    std::cout << "mask5 = " << mask5 << std::endl;             std::cout << std::endl;
    std::cout << "mask5.size() = " << mask5.sizes() << std::endl;             std::cout << std::endl;

    torch::Tensor t5_ = torch::rand({3, 6});
    std::cout << "t5_ = " << t5_ << std::endl;             std::cout << std::endl;
    auto t6_ = torch::masked_select(t5_, mask5).view({-1, 6}); // view展平是必须的
    std::cout << "t6_ = " << t6_ << std::endl;             std::cout << std::endl;

    // 构建一个张量
    torch::Tensor t8 = torch::rand({6, 6});
    std::cout << "t8 = " << t8 << std::endl;             std::cout << std::endl;
    std::cout << "t8.slice(0, 2, 4) = " << t8.slice(0, 2, 4) << std::endl;             std::cout << std::endl;
    
    // 行/列最大值
    torch::Tensor t9 = torch::rand({ 3, 4 });
    std::cout << "t9 = " << t9 << std::endl;             std::cout << std::endl;
    std::tuple<torch::Tensor, torch::Tensor> max_info = torch::max(t9, 0); // 0:代表列， slice那里0代表行
    // 访问元组
    torch::Tensor max_vals = std::get<0>(max_info);
    torch::Tensor idxs = std::get<1>(max_info);
    std::cout << "max_vals = " << max_vals << std::endl;             std::cout << std::endl;
    std::cout << "idxs = " << idxs << std::endl;             std::cout << std::endl;

    // 拼接
    torch::Tensor t10 = torch::cat({ t3, t9 }, 1);
    std::cout << "t10 = " << t10 << std::endl;             std::cout << std::endl;
    system("pause");
    return 1;
}

LearningPytorch.py

import numpy as np
import torch

if __name__ == "__main__":
    ## e.g. 2.4
    # 声明tensor
    t1 = torch.tensor([[1, 2, 3], [2, 3, 4]])
    print('t1.dtype = ', t1.dtype)
    print('t1.shape = ', t1.shape)
    t1 = torch.tensor(range(10))  # 转换迭代器为张量
    # numpy -> tensor
    t1 = torch.tensor(np.array([1, 2, 3]))
    t2 = torch.from_numpy(np.array([1, 2, 3]))
    # tensor -> numpy
    t3 = t2.numpy()

    # 随机tensor
    t1 = torch.randn(3, 3) * 10  # randn：正态分布， rand：均匀分布
    t2 = t1.to(torch.int8)

    ## e.g. 2.5 随机数
    t1 = torch.rand(3, 3)  # 3*3矩阵，元素服从[0, 1)均值分布
    t1 = torch.randn(2, 3, 4)  # 2*3*4, 高斯分布
    t1 = torch.zeros(2, 2, 2)
    t1 = torch.ones(3, 4, 5) * 4
    t1 = torch.eye(4)
    t1 = torch.randint(1, 5, (3, 3))  # # 生成[0, 10)之间均匀分布整数的3×3矩阵

    ## e.g. 2.6 随机数
    t1 = torch.randn(3, 3)

    # 复制t1的shape
    t2 = torch.zeros_like(t1)  # 生成一个元素全为0的张量，形状和给定张量t1相同
    t2 = torch.ones_like(t1)
    t2 = torch.randn_like(t1)  # 正太分布

    # 复制t1的类型
    t3 = t1.new_tensor([1, 2, 3])  # 根据Python列表生成张量，注意这里输出的是单精度浮点数
    t3 = t1.new_zeros(3, 3)  # 生成相同类型且元素全为0的张量
    t3 = t1.new_ones(3, 3)  # 生成相同类型且元素全为1的张量

    # e.g. 2.8 设备
    t1 = torch.randn(3, 3, device="cpu")  # 获取存储在CPU上的一个张量
    t1 = torch.randn(3, 3, device="cuda:0")  # 获取存储在0号GPU上的一个张量
    t1 = torch.randn(3, 3, device="cuda:0").device  # 获取当前张量的设备
    t1 = torch.randn(3, 3, device="cuda:0").cpu().device  # 张量从1号GPU转移到CPU
    t1 = torch.randn(3, 3, device="cuda:0").cuda(0).device  # 张量保持设备不变

    # e.g. 2.9 指针、维度
    t1 = torch.randn(3, 4, 5)
    nd = t1.ndimension()  # channels = 3;获取维度的数目
    ne = t1.nelement()  # c*w*h = 60;获取该张量的总元素数目
    sz = t1.size()  # torch.Size([3, 4, 5])
    c = t1.size(0)  # 获取该张量维度0的大小，调用方法
    t = torch.randn(12)  # 产生大小为12的向量
    t1 = t.view(3, 4)  # 向量改变形状为3×4的矩阵
    t1 = t1.view(-1, 4)  # 第一个维度为-1，PyTorch会自动计算该维度的具体值
    t1.view(4, 3)[0, 0] = 99.0  # 访问一个元素、遍历
    ptr = t1.data_ptr()  # 获取tensor数据指针
    t1.view(3, 4).data_ptr()  # 获取张量的数据指针
    t1.view(4, 3).contiguous().data_ptr()  # 同上，不改变
    t1.view(3, 4).transpose(0, 1).data_ptr()  # transpose方法交换两个维度
    t1.view(3, 4).transpose(0, 1).contiguous().data_ptr()  # 步长和维度不兼容，重新生成张量(即：会重新分配内存)

    # e.g. 2.10 mask
    t1 = torch.randn(2, 3, 4)
    t2 = t1[1, 2, 3]
    t2 = t1[:, 1:, 1:3]
    mask = t1 > 0  # t1中元素大于0 的mask，mask.shape 等于 t1.shape
    t2 = t1[mask]  # torch.Size([15])， t2是一个n*1的行向量

    # e.g. 2.11 sqrt && sum
    t1 = torch.randint(1, 9, (3, 3))
    t1 = t1.to(torch.float)
    t2 = t1.sqrt()  # 操作不改变t1的值
    t3 = torch.sqrt(t1)  # 操作不改变t1的值
    t1.sqrt_()  # 平方根原地操作,修改自己的值
    sum1 = torch.sum(t1)  # 默认对所有的元素求和
    sum2 = torch.sum(t1, 0)  # 对第0维的元素求和
    sum3 = torch.sum(t1, [0, 1])  # 对第0、1维的元素求和

    mean1 = t1.mean()  # 对所有元素求平均，也可以用torch.mean函数
    mean2 = t1.mean(0)  # 对第0维的元素求平均
    mean3 = torch.mean(t1, [0, 1])  # 对第0、1维元素求平均, mean.shape = 1*1

    # e.g. 2.12 加减乘除（其实都重载了运算符，自己取试一试）
    t1 = torch.rand(2, 3)
    t2 = torch.rand(2, 3)
    t3 = t1.add(t2)
    t4 = t1.sub(t2)
    t5 = t1.mul(t2) # 对应元素相乘，非矩阵乘法
    t6 = t1 * t2
    t1.add_(t2)  # 四则运算，改变参与运算张量(t2)的值


    var = torch.__version__

LearningPytorch.cpp

#include<torch/torch.h>
#include<torch/script.h>
#include<iostream>
using namespace std; // 项目中建议不要使用

void printTitle(const string& title)
{
    cout << endl;
    cout << "******【" << title << "】******" << endl;
}

int main()
{
    // e.g. 2.4
    {
        printTitle("e.g. 2.4");
        // 声明tensor
        torch::Tensor t1 = torch::tensor({ { 1, 2, 3 }, { 2, 3, 4 } }, torch::kByte);
        cout << "t1.dtype() = " << t1.dtype() << endl; // __int64
        t1.print();
        cout << "t1 = " << t1 << endl;
        t1 = torch::range(1, 10, torch::kByte);

        // 随机tensor
        t1 = torch::randn({ 3, 3 }, torch::kFloat) * 10;
        cout << "t1 = " << t1 << endl;
        torch::Tensor t2 = t1.to(torch::kInt8);
        cout << "t2 = " << t2 << endl;
    }
    // e.g. 2.5 随机
    {
        printTitle("e.g. 2.5 随机");
        torch::Tensor t1 = torch::rand({ 3, 3 }, torch::kFloat32);
        t1 = torch::randn({ 2, 3, 4 });
        t1 = torch::zeros({ 2, 2, 2 }, torch::kUInt8);
        t1 = torch::ones({ 3, 4 }) * 9;
        t1 = torch::eye(3, torch::kFloat);
        t1 = torch::randint(0, 4, { 3, 3 });
        cout << "t1 = " << t1 << endl;

    }
    // e.g. 2.6 随机
    {
        printTitle("e.g. 2.6 随机");
        torch::Tensor t1 = torch::rand({ 3, 3 }, torch::kFloat32);
        // copy the shape of t1
        torch::Tensor t2 = torch::zeros_like(t1);
        t2 = torch::ones_like(t1);
        t2 = torch::randn_like(t1);

        // copy the dtype of t1
        torch::Tensor t3 = t1.new_zeros({ 3, 3 }); // 生成相同类型且元素全为0的张量
        t3 = torch::ones(t1.sizes(), t1.dtype()); // 和opencv一样
        t3 = torch::zeros(t1.sizes(), t1.dtype());

        cout << "t2 = " << t2 << endl;
        cout << "t3 = " << t3 << endl;
    }
    // e.g. 2.8 设备
    {
        printTitle("e.g. 2.8 设备");
        torch::Tensor t1 = torch::randn({ 3, 3 }, torch::Device("cpu"));
        cout << "t1 = " << t1 << endl;
        auto device = torch::Device("cuda:0");
        torch::Tensor t2 = torch::randn({ 3, 3 }, torch::kF32).to(device);
        cout << "t2 = " << t2 << endl;
        cout << "t2.device = " << t2.device() << endl;
    }
    // e.g. 2.9 指针
    {
        printTitle("e.g. 2.9 指针");
        torch::Tensor t1 = torch::randn({ 3, 4, 5 });
        cout << t1 << endl;
        int nd = t1.ndimension(); // channels = 3;  获取维度的数目
        int nc = t1.size(0); // c
        int nw = t1.size(1); // w
        int nh = t1.size(2); // h
        cout << nd << " " << nc << endl;
        auto sz = t1.sizes(); // [c w h]
        cout << "sz = " << sz << endl;
        t1 = torch::randn({ 12 });
        torch::Tensor t2 = t1.view({ -1, 3 }); // 将其第二个维度变为3，第一个维度会自动计算，不过不能整除就会报错
        t2[0][0] = 99;    // 访问元素
        cout << "t2 = " << t2 << endl;
        float* t2_ptr = (float*)t2.data_ptr(); // 获取指针
        cout << "t2_ptr = " << t2_ptr << endl;
        void* t22_ptr = (void*)t2.data_ptr(); // 指针指针,地址不变
        cout << "t22_ptr = " << t22_ptr << endl;
        auto t222_ptr = t2.contiguous().data_ptr(); // 指针指针，地址不变
        cout << "t222_ptr = " << t222_ptr << endl;
        auto t2222_ptr = t2.transpose(0, 1).contiguous().data_ptr(); // 步长和维度不兼容，重新生成张量(即：会重新分配内存)
        cout << "t2222_ptr = " << t2222_ptr << endl;
    }
    // e.g. 2.10 mask
    {
        printTitle("e.g. 2.10 mask");
        torch::Tensor t1 = torch::randn({ 2, 3, 4 });
        cout << "t1 = " << t1 << endl;
        torch::Tensor ele = t1[1][2][3];
        cout << "ele = " << ele << endl;
        double ele_ = ele.item().toDouble(); // tensor 转 double
        cout << "ele_ = " << ele_ << endl;
        torch::Tensor mask = t1.ge(0);
        cout << "mask = " << mask << endl;
        torch::Tensor t2 = t1.masked_select(mask); // t2 是一个向量
        cout << "t2 =" << t2 << endl;
    }
    // e.g. 2.11 sqrt && sum
    {
        printTitle("e.g. 2.11 sqrt");
        torch::Tensor t1 = torch::randint(1, 9, { 3, 3 });
        cout << "t1 = " << t1 << endl;
        torch::Tensor t2 = t1.to(torch::kFloat32);
        torch::Tensor t3 = t2.sqrt(); // 操作不改变t2的值
        t3 = torch::sqrt(t2); // 操作不改变t2的值
        cout << "t3 = " << t3 << endl;
        t2.sqrt_();        // 平方根原地操作,修改自己的值
        cout << "t2 = " << t2 << endl;

        // 也可以调用默认的sum()成员函数
        cout << "t1 = " << t1 << endl;
        torch::Tensor sum1 = torch::sum(t1);    // 默认对所有的元素求和
        torch::Tensor sum2 = torch::sum(t1, 0); //  对第0维的元素求和，即：按列进行求和
        torch::Tensor sum3 = torch::sum(t1, { 1,0 }); // 写成{0, 1}会报编译错
        cout << "sum3 = " << sum3.item().toFloat() << endl;

        torch::Tensor mean1 = t1.mean();  // 对所有元素求平均，也可以用torch.mean函数
        torch::Tensor mean2 = t1.mean(0); // 对第0维的元素求平均
        // 写成{0, 1}会报编译错，同上
        torch::Tensor mean3 = torch::mean(t1, { 1, 0 }); // 对第0、1维元素求平均, mean.shape = 1*1
        cout << "mean1 = " << mean1.item().toFloat() << endl;
        cout << "mean2 = " << mean2 << endl;
        cout << "mean3 = " << mean3 << endl;
    }
    // e.g. 2.12 对应元素加、减、乘、除（其实都重载了运算符，自己取试一试）
    {
        printTitle("e.g. 2.12 ");
        torch::Tensor t1 = torch::rand({ 2, 3 });
        torch::Tensor t2 = torch::rand({ 2, 3 });
        torch::Tensor t3 = t1 + t2;
        torch::Tensor t4 = t1.sub(t2);
        torch::Tensor t5 = t1.mul(t2);
        torch::Tensor t6 = t1.div(2);
        cout << "t1 = " << t1 << endl;
        cout << "t2 = " << t2 << endl;
        cout << "t3 = " << t3 << endl;
        cout << "t4 = " << t4 << endl;
        cout << "t5 = " << t5 << endl;
        cout << "t6 = " << t6 << endl;
        t6.add_(1); // 会修改t6中的值
        cout << "t6 = " << t6 << endl;
    }
    // e.g. 2.13 min max argmax
    {
        printTitle("e.g. 2.13 min max argmax");
        torch::Tensor t1 = torch::randn({ 3, 4 }, torch::kFloat64);
        cout << "t1 = " << t1 << endl;
        torch::Tensor mask_argmax = torch::argmax(t1, 0); // 返回的是沿着第0个维度，极大值所在位置
        cout << "mask_argmax = " << mask_argmax << endl;
        // max
        std::tuple<torch::Tensor, torch::Tensor> maxVals = torch::max(t1, -1); //  函数调用，返回的是沿着最后一个维度，包含极大值和极大值所在位置的元组
        torch::Tensor mask_max = std::get<0>(maxVals); // max val
        torch::Tensor mask_max_idx = std::get<1>(maxVals); // index of maxVal
        cout << "mask_max = " << mask_max << endl;
        cout << "mask_max_idx = " << mask_max_idx << endl;
        // min
        std::tuple<torch::Tensor, torch::Tensor> minVals = t1.min(0); // 内置方法调用，返回的是沿着第0个维度，包含极小值和极小值所在位置的元组
        torch::Tensor mask_min = std::get<0>(minVals); // min val
        torch::Tensor mask_min_idx = std::get<1>(minVals);// index of minVal
        cout << "mask_min = " << mask_min << endl;
        cout << "mask_min_idx = " << mask_min_idx << endl;
        // sort
        std::tuple<torch::Tensor, torch::Tensor> sortVals = t1.sort(-1); // 沿着最后一个维度排序，返回排序后的张量和张量元素在该维度的原始位置
        torch::Tensor tensorVal = std::get<0>(sortVals);
        torch::Tensor tensorValIdx = std::get<1>(sortVals);
        cout << "tensorVal = " << tensorVal << endl;
        cout << "tensorValIdx = " << tensorValIdx << endl;
    }
    // e.g. 2.14 矩阵乘法
    {
        printTitle("e.g. 2.14 矩阵乘法");
        torch::Tensor t1 = torch::tensor({ {1, 2}, {3, 4} }, torch::kFloat64); // 2×2
        torch::Tensor t2 = torch::tensor({ {1, 1, 1}, {2, 3, 1} }, torch::kFloat64); // 2×3
        auto t3 = t1.mm(t2); // 矩阵乘法, torch::mm
        cout << "t1 = " << t1 << endl;
        cout << "t2 = " << t2 << endl;
        cout << "t3 = " << t3 << endl;
        //
        t1 = torch::randn({ 2, 3, 4 });
        t2 = torch::randn({ 2, 4, 3 });
        torch::Tensor t4 = t1.bmm(t2); // （迷你）批次矩阵乘法，返回结果为2×3×3，函数形式
        cout << "t1 = " << t1 << endl;
        cout << "t2 = " << t2 << endl;
        cout << "t4 = " << t4 << endl;
    }
    // e.g. 2.16 Tensor堆叠、拼接
    {
        printTitle("e.g. 2.16 Tensor堆叠、拼接");
        auto t1 = torch::randn({ 2, 3 });
        auto t2 = torch::randn({ 2, 3 });
        auto t3 = torch::stack({ t1, t2 }, -1); // 沿着最后一个维度做堆叠，返回大小为2×2×3的张量
        cout << "t1.sizes() = " << t1.sizes() << endl;
        cout << "t2.sizes() = " << t2.sizes() << endl;
        cout << "t3.sizes() = " << t3.sizes() << endl;
    }
    // e.g. 2.17 2.18  拓展、压缩维度
    {
        printTitle("e.g. 2.17 2.18 拓展维度");
        torch::Tensor t1 = torch::rand({ 3, 4 });
        cout << "t1.sizes() = " << t1.sizes() << endl;
        auto t11 =    t1.unsqueeze(-1); // 扩增最后一个维度
        cout << "t11.sizes() = " << t11.sizes() << endl;
        auto t12 = t1.unsqueeze(-1).unsqueeze(-1); // 继续扩增最后一个维度
        cout << "t12.sizes() = " << t12.sizes() << endl;
        auto t13 = t1.unsqueeze(1); // 在第1个维度插入新一个维度 -> 3*4*1
        cout << "t13.sizes() = " << t13.sizes() << endl;

        auto t2 = torch::rand({ 1, 3, 4, 1 });
        cout << "t2.sizes() = " << t2.sizes() << endl;
        auto t21 = t2.squeeze(); // 压缩所有大小为1的维度
        cout << "t21.sizes() = " << t21.sizes() << endl;
    }
    // e.g. 2.18 
    return 1;
}