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;
}