使用 C# 入門深度學習：Pytorch 基礎

痴者工良發表於2024-11-12

C#深度學習PyTorch

教程名稱：使用 C# 入門深度學習

作者：痴者工良

地址：

https://torch.whuanle.cn

1.2 Pytorch 基礎

本文內容介紹 Pytorcn 的基礎 API，主要是陣列的建立方式和運算方式，由於相關內容跟 Numpy 比較相似，並且 Numpy 型別可以轉 torch.Tensor，因此對 Numpy 感興趣的讀者可以參考筆者的其它文章：

Python 之 Numpy 框架入門

https://www.whuanle.cn/archives/21461

https://www.cnblogs.com/whuanle/p/17855578.html

提示：學習本文時，如果對線性代數有足夠的瞭解，則學習效果更佳，沒有線性代數基礎也沒關係，後面會學習到。本文會同時使用 Python 和 C# 編寫示例，方便各位讀者對照差異，在後續的章節學習中，基本只會使用 C# 編寫示例。

基礎使用

由於神經網路中的數值很多以向量或陣列等形式存在，不像日常程式設計中的數值型別那麼簡單，因此列印數值資訊是我們學習瞭解或除錯程式的一種手段，下面我們來觀察程式是怎麼列印 Pytorch 中複雜資料型別的。

列印

下面使用 Pytorch 建立一個從 0..9 的陣列，接著列印陣列。

Python：

import torch
x = torch.arange(10)
print(x)

tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

C# 版本不使用 Console.WriteLine()，而是使用官方提供的庫。

using TorchSharp;

var x = torch.arange(10);
x.print(style:TensorStringStyle.Default);
x.print(style:TensorStringStyle.Numpy);
x.print(style:TensorStringStyle.Metadata);
x.print(style:TensorStringStyle.Julia);
x.print(style:TensorStringStyle.CSharp);

[10], type = Int64, device = cpu 0 1 2 3 4 5 6 7 8 9
[0, 1, 2, ... 7, 8, 9]
[10], type = Int64, device = cpu
[10], type = Int64, device = cpu 0 1 2 3 4 5 6 7 8 9
[10], type = Int64, device = cpu, value = long [] {0L, 1L, 2L, ... 7L, 8L, 9L}

Python 列印的結果比較容易理解，C# 預設列印的方式比較難看，所以一般來說，視覺化都使用 TensorStringStyle.Numpy 列舉。

C# 列印數值時，引數有個 string? fltFormat = "g5"，表示精確度的意思，即列印的小數位數。

在 Maomi.Torch 包中提供了一些擴充套件方法，讀者可以使用 x.print_numpy() 擴充套件直接列印對應風格的資訊。

對於後面的章節來說，預設都引入 Python 的 torch 包名稱、C# 的 TorchSharp 名稱空間，後續程式碼示例可能會省略引入程式碼，讀者自行引入。

基本資料型別

Pytorch 的資料型別跟我們程式語言中的基本型別不太一樣，讀者要注意區別。

具體詳細的官方文件參考連結：

https://pytorch.org/docs/stable/tensor_attributes.html

https://pytorch.ac.cn/docs/stable/tensor_attributes.html

Pytorch 建立的資料型別以 torch.Tensor 表示，torch.Tensor 是用來處理機器學習模型中的各種資料的基礎結構，包括標量、向量、矩陣以及更高維度的張量。如果筆者沒理解錯的話，在 Pytorch 中建立的 Tensor 物件就叫張量。開發者可以透過各種形式的資料在 Pytorch 建立 Tensor。

Pytorch 建立的資料型別，都使用 Tensor 物件表示。

對於這句話的理解，建議看完本文再回頭看看。

PyTorch 有十二種不同的資料型別，列表如下：

資料型別	dtype
32 位浮點數	`torch.float32` 或 `torch.float`
64 位浮點數	`torch.float64` 或 `torch.double`
64 位複數	`torch.complex64` 或 `torch.cfloat`
128 位複數	`torch.complex128` 或 `torch.cdouble`
16 位浮點數	`torch.float16` 或 `torch.half`
16 位浮點數	`torch.bfloat16`
8 位整數（無符號）	`torch.uint8`
8 位整數（有符號）	`torch.int8`
16 位整數（有符號）	`torch.int16` 或 `torch.short`
32 位整數（有符號）	`torch.int32` 或 `torch.int`
64 位整數（有符號）	`torch.int64` 或 `torch.long`
布林值	`torch.bool`

下面示範在建立一個數值全為 1 的陣列時，設定陣列的型別。

Python：

float_tensor = torch.ones(1, dtype=torch.float)
double_tensor = torch.ones(1, dtype=torch.double)
complex_float_tensor = torch.ones(1, dtype=torch.complex64)
complex_double_tensor = torch.ones(1, dtype=torch.complex128)
int_tensor = torch.ones(1, dtype=torch.int)
long_tensor = torch.ones(1, dtype=torch.long)
uint_tensor = torch.ones(1, dtype=torch.uint8)

C#：

var float_tensor = torch.ones(1, dtype: torch.float32);
var double_tensor = torch.ones(1, dtype: torch.float64);
var complex_float_tensor = torch.ones(1, dtype: torch.complex64);
var complex_double_tensor = torch.ones(1, dtype: torch.complex128);
var int_tensor = torch.ones(1, dtype: torch.int32); ;
var long_tensor = torch.ones(1, dtype: torch.int64);
var uint_tensor = torch.ones(1, dtype: torch.uint8);

在 C# 中， torch.ScalarType 列舉表示 Pytorch 的資料型別，所以可以有以下兩種方式指定資料型別。

例如：

var arr = torch.zeros(3,3,3, torch.ScalarType.Float32);
arr.print_numpy();

或：

var arr = torch.zeros(3,3,3, torch.float32);
arr.print_numpy();

CPU 或 GPU 運算

我們知道，AI 模型可以在 CPU 下執行，也可以在 GPU 下執行，Pytorch 的資料也可以這樣做，在建立資料型別時就設定繫結的裝置，在運算使用會使用對應的裝置進行運算。

一般使用 cpu 表示 CPU，使用 cuda 或 cuda:{顯示卡序號} 表示 GPU。

下面編寫程式碼判斷 Pytorch 正在使用 GPU 還是 CPU 執行。

Python：

print(torch.get_default_device())

C#：

 Console.WriteLine(torch.get_default_device())

如果當前裝置支援 GPU，則使用 GPU 啟動 Pytorch，否則使用 CPU 啟動 Pytorch。可以透過 torch.device('cuda')、torch.device('cuda:0') 指定使用 GPU 、指定使用哪個 GPU。

Python：

if torch.cuda.is_available():
    print("當前裝置支援 GPU")
    device = torch.device('cuda')
    # 使用 GPU 啟動
    torch.set_default_device(device)
    current_device = torch.cuda.current_device()
    print(f"繫結的 GPU 為：{current_device}")
else:
    # 不支援 GPU，使用 CPU 啟動
    device = torch.device('cpu')
    torch.set_default_device(device)

default_device = torch.get_default_device()
print(f"當前正在使用 {default_device}")

C#：

if (torch.cuda.is_available())
{
    Console.WriteLine("當前裝置支援 GPU");
    var device = torch.device("cuda",index:0);
    // 使用 GPU 啟動
    torch.set_default_device(device);
}
else
{
    var device = torch.device("cpu");
    // 使用 CPU 啟動
    torch.set_default_device(device);
    Console.WriteLine("當前正在使用 CPU");
}

var default_device = torch.get_default_device();
Console.WriteLine($"當前正在使用 {default_device}");

C# 沒有 torch.cuda.current_device() 這個方法，建議預設設定使用哪塊 GPU，即設定 index 引數。

另外可以透過使用 torch.cuda.device_count() 獲取裝置有多少個顯示卡，這裡不再贅述。

Pytorch 還支援針對單獨的資料型別設定使用 CPU 還是 GPU，還可以讓兩者混合運算，這裡不再贅述。

Tensor 型別

在 Pytorch 中，可以將標量、陣列等型別轉換為 Tensor 型別，Tensor 表示的資料結構就叫張量。

x = torch.tensor(3.0);

基本陣列

Pytorch 使用 asarray() 函式將 obj 值轉換為陣列，其定義如下：

torch.asarray(obj, *, dtype=None, device=None, copy=None, requires_grad=False) → Tensor

官方 API 文件：https://pytorch.org/docs/stable/generated/torch.asarray.html#torch-asarray

obj 可以是以下之一：

a tensor（張量）
a NumPy array or a NumPy scalar（NumPy 陣列或 NumPy 標量）
a DLPack capsule
an object that implements Python’s buffer protocol
a scalar（標量）
a sequence of scalars（標量序列）

筆者不會的或者本文用不到的，就不翻譯了。

比如說，傳入一個平常的陣列型別，轉換成 Pytorch 中的陣列型別。

Python：

arr = torch.asarray([1,2,3,4,5,6], dtype=torch.float)
print(arr)

C#：

var arr = torch.from_array(new float[] { 1, 2, 3, 4, 5 });
arr.print(style: TensorStringStyle.Numpy);

請注意，兩種語言的版本差異有些大。

前面提到過，可以給單獨的資料型別設定使用 CPU 還是 GPU。

device = torch.device("cuda",index=0)
arr = torch.asarray(obj=[1,2,3,4,5,6], dtype=torch.float, device=device)
print(arr)

將資料型別轉換為使用 CPU 裝置：

device = torch.device("cuda",index=0)
arr = torch.asarray(obj=[1,2,3,4,5,6], dtype=torch.float, device=device)
arr = arr.cpu()
print(arr)

但是將資料在 GPU、CPU 之間轉換，會消耗一定的效能。

生成陣列

torch.zeros

用於建立一個元素全為 0 的陣列，可以指定陣列大小，其定義如下：

torch.zeros(*size, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

Python：

arr = torch.zeros(10, dtype=torch.float)
print(arr)

C#：

var arr = torch.zeros(10);
arr.print(style: TensorStringStyle.Numpy);

另外，可以指定生成的陣列維度，例如下面指定生成 2*3 的多維陣列。

var arr = torch.zeros(2,3, torch.float32);
arr.print(style: TensorStringStyle.Numpy);

程式碼為 C# 語言。

列印：

[[0, 0, 0] [0, 0, 0]]

我們還可以生成多種維度的陣列，例如下面生成一個 3*3*3 的陣列：

var arr = torch.zeros(3,3,3, torch.float32);
arr.print(style: TensorStringStyle.Numpy);

為了方便理解，下面將列印結果做了格式化處理。

[
[[0, 0, 0]  [0, 0, 0]  [0, 0, 0]]
[[0, 0, 0]  [0, 0, 0]  [0, 0, 0]]
[[0, 0, 0]  [0, 0, 0]  [0, 0, 0]]
]

torch.ones

建立一個全由 1 填充的陣列，使用方法跟 torch.zeros 完全一致，因此這裡不再贅述。

torch.empty

建立一個未初始化的陣列，使用方法跟 torch.zeros 完全一致，因此這裡不再贅述。

由於其沒有初始化記憶體，因此記憶體區域會殘留資料，元素的值不確定。

複製函式

此外，上面三個函式還有對應的原型複製函式：

torch.ones_like(input, *, dtype=None, layout=None, device=None, requires_grad=False, memory_format=torch.preserve_format) → Tensor

torch.zeros_like(input, *, dtype=None, layout=None, device=None, requires_grad=False, memory_format=torch.preserve_format) → Tensor

torch.empty_like(input, *, dtype=None, layout=None, device=None, requires_grad=False, memory_format=torch.preserve_format) → Tensor

它們的作用是根據陣列型別，複製一個相同的結構，然後填充對應值。

如下示例，複製陣列相同的結構，但是填充的值為 1。

var arr = torch.ones_like(torch.zeros(3, 3, 3));
arr.print(style: TensorStringStyle.Numpy);

該程式碼語言為 C#。

[
[[1, 1, 1]  [1, 1, 1]  [1, 1, 1]]
[[1, 1, 1]  [1, 1, 1]  [1, 1, 1]]
[[1, 1, 1]  [1, 1, 1]  [1, 1, 1]]
]

torch.rand

torch.rand 會生成一個張量，陣列會填充來自 [0,1) 區間上的均勻分佈的隨機數。

函式定義如下：

torch.rand(*size, *, generator=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False, pin_memory=False) → Tensor

例如生成 2*3 大小的，範圍在 [0,1) 區間的隨機數，使用 C# 編寫程式碼：

var arr = torch.rand(2,3);
arr.print(style: TensorStringStyle.Numpy);

[[0.60446, 0.058962, 0.65601] [0.58197, 0.76914, 0.16542]]

由於 C# 繪製圖形的庫不像 Python matplotlib 簡單易用，因此讀者可以引用 Maomi.Torch.ScottPlot、Maomi.ScottPlot.Winforms 兩個包，可以快速轉換 Pytorch 型別和生成繪製視窗。下面示範使用編寫程式碼繪製均勻分佈的隨機數，方便使用 Python matplotlib 和 Maomi.ScottPlot.Winforms 框架顯示圖形。

Python：

import torch
import matplotlib.pyplot as plt

arr = torch.rand(100, dtype=torch.float)

print(arr)

x = arr.numpy()
y = x
plt.scatter(x,y)
plt.show()

C#：

using Maomi.Torch;
using Maomi.Plot;
using TorchSharp;

var x = torch.rand(100);

x.print(style: TensorStringStyle.Numpy);

ScottPlot.Plot myPlot = new();
myPlot.Add.Scatter(x, x);
var form = myPlot.Show(400, 300);

由圖可知，生成的隨機數是均勻散佈在 [0,1) 區間內。

torch.randn

生成具有給定形狀的標準正態分佈（平均值為0，方差為1）的隨機樣本。隨機樣本取值範圍是[0,1)。

定義如下：

torch.randn(*size, *, generator=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False, pin_memory=False) → Tensor

官方文件：https://pytorch.ac.cn/docs/stable/generated/torch.randn.html#torch.rand

由於 C# 不好繪圖，這裡使用 Python 編寫示例：

import torch
import matplotlib.pyplot as plt

arr = torch.randn(100, dtype=torch.float)

print(arr)

x = arr.numpy()
y = x
plt.hist(x, bins=30, alpha=0.5, color='b', edgecolor='black')

plt.show()

x 座標軸是數值，y 座標軸是出現次數。

torch.randint

在某個區間內生成隨機數。

定義如下：

torch.randint(low=0, high, size, \*, generator=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

比如在 0-100 範圍內生成 10 個元素，安裝 5*2 結構組成，使用 C# 程式碼編寫。

var arr = torch.randint(low: 0, high: 100, size: new int[] { 5, 2 });
arr.print(style: TensorStringStyle.Numpy);

[[17, 46] [89, 52] [10, 89] [80, 91] [52, 91]]

如果要生成某個區間的浮點數，則可以使用 torch.rand ，但是因為 torch.rand 生成範圍是 [0,1)，因此需要自行乘以倍數。例如要生成 [0,100) 的隨機數。

var arr = torch.rand(size: 100, dtype: torch.ScalarType.Float32) * 100;
arr.print(style: TensorStringStyle.Numpy);

torch.arange

指定區間以及步長，均勻提取元素生成陣列。

定義如下：

torch.arange(start=0, end, step=1, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

比如說，需要生成 [0,1,2,3,4,5,6,7,8,9] 這樣的陣列，可以使用：

var arr = torch.arange(start: 0, stop: 10, step: 1);
arr.print(style: TensorStringStyle.Numpy);

如果將步長改成 0.5。

var arr = torch.arange(start: 0, stop: 10, step: 0.5);

[0.0000, 0.5000, 1.0000, 1.5000, 2.0000, 2.5000, 3.0000, 3.5000, 4.0000,
        4.5000, 5.0000, 5.5000, 6.0000, 6.5000, 7.0000, 7.5000, 8.0000, 8.5000,
        9.0000, 9.5000]

陣列操作和計算

軸

在 Pytorch 中，往往使用 dim(dimension) 參數列示軸，軸就是張量的層數。

有以下陣列：

[[ 1, 2, 3 ], { 4, 5, 6 ]]

如果把 a = [1,2,3]，b = [4,5,6]，則：

[a,b]

那麼當我們要獲取 a 時，dim(a) = 0，dim(b) = 1。

var arr = torch.from_array(new[,] { { 1, 2, 3 }, { 4, 5, 6 } });

arr.print(style: TensorStringStyle.Numpy);

// 列印維度
arr.shape.print();

var a = arr[0];
a.print();
var b = arr[1];
b.print();

[[1, 2, 3] [4, 5, 6]]
[2, 3]
[3], type = Int32, device = cpu 1 2 3
[3], type = Int32, device = cpu 4 5 6

這裡我們分兩步理解，由於該陣列是 2*3 陣列，可以使用 .shape.print() 列印出來。

由於第一層有兩個元素，因此可以使用 Tensor[i] 獲取第一層的第 i 個元素，其中 i<2。

同理，由於 a、b 的下一層都有 3 個元素，因此第二層 n<3。

例如要將陣列的 3、6 兩個元素取出來。

用 C# 可以這樣寫，但是列印的時候不能選 TensorStringStyle.Numpy ，否則列印不出來。

var arr = torch.from_array(new[,] { { 1, 2, 3 }, { 4, 5, 6 } });

var a = arr[0, 2];
a.print(style: TensorStringStyle.CSharp);
var b = arr[1, 2];
b.print(style: TensorStringStyle.CSharp);

同理，如果陣列有三層，可以這樣獲取 3、6 兩個元素

var arr = torch.from_array(new[, ,] { { { 1, 2, 3 } }, { { 4, 5, 6 } } });

var a = arr[0, 0, 2];
a.print(style: TensorStringStyle.CSharp);
var b = arr[1, 0, 2];
b.print(style: TensorStringStyle.CSharp);

如果要取出一部分元素，TorchCsharp 可以使用 a[i..j] 的語法擷取，示例如下。

var arr = torch.from_array(new int[] { 1, 2, 3 });
arr = arr[0..2];
arr.print(style: TensorStringStyle.Numpy);

[1, 2]

陣列排序

Pytorch 中有一些排序函式：

sort ：沿給定維度按值升序對 input 張量的元素進行排序。

argsort：它是沿指定軸的間接排序，本文不講解。

msort：按值對 input 張量沿其第一維以升序排序。torch.msort(t) 等效於 torch.sort(t, dim=0)。

sort 可以降序或升序，引數說明如下：

torch.sort(input, dim=-1, descending=False, stable=False, *, out=None)

input (張量) – 輸入張量。
dim (int,可選) – 要排序的維度
descending (bool,可選) – 控制排序順序（升序或降序）
stable (boo,可選) – 使排序例程穩定，從而保證等效元素的順序得以保留。

示例：

var arr = torch.arange(start: 0, stop: 10, step: 1);

// 或者使用 torch.sort(arr, descending: true)
(torch.Tensor Values, torch.Tensor Indices) a1 = arr.sort(descending: true);

a1.Values.print(style: TensorStringStyle.Numpy);

[9, 8, 7, ... 2, 1, 0]

Values 是排序後的結果，Indices 是排序的規則。

如果陣列結構比較複雜，預設不設定引數時，只有最內層陣列進行排序。如下程式碼所示，有兩層陣列。

var arr = torch.from_array(new[,] { { 4, 6, 5 }, { 8, 9, 7 }, { 3, 2, 1 } });

(torch.Tensor Values, torch.Tensor Indices) a1 = arr.sort();

a1.Values.print(style: TensorStringStyle.Numpy);
a1.Indices.print(style: TensorStringStyle.Numpy);

[[4, 5, 6] [7, 8, 9] [1, 2, 3]]
[[0, 2, 1] [2, 0, 1] [2, 1, 0]]

Indices 會記錄當前元素在以前的排序位置。

當設定 arr.sort(dim: 0); 時，按照第一層排序。

[[3, 2, 1] [4, 6, 5] [8, 9, 7]]
[[2, 2, 2] [0, 0, 0] [1, 1, 1]]

當設定 arr.sort(dim: 1); 時，只有裡面一層排序。

[[4, 5, 6] [7, 8, 9] [1, 2, 3]]
[[0, 2, 1] [2, 0, 1] [2, 1, 0]]

當一個張量的維度比較大時，我們可以這樣逐層排序。

var arr = torch.from_array(new[, ,] { { { 4, 6, 5 }, { 8, 9, 7 }, { 3, 2, 1 } } });

var dimCount = arr.shape.Length;
for (int i = dimCount - 1; i >= 0; i--)
{
    (torch.Tensor Values, torch.Tensor Indices) a1 = arr.sort(dim: i);
    arr = a1.Values;
    arr.print(style: TensorStringStyle.Numpy);
}

[[[1, 2, 3]  [4, 5, 6]  [7, 8, 9]]]

C# 多維陣列沒有 Python 那麼方便，會要求每一層的元素個數必須一致。

例如下面的陣列宣告是對的：

var array = new int[, , ]
{
    {
        { 10, 12, 11},{ 14, 15, 11 }
    },
    {
        { 4, 6, 5 }, { 8, 9, 7 }
    }
};

如果層數元素個數不一致會報錯：

另外要注意，C# 有多維陣列和交錯陣列，下面是交錯陣列的宣告方式，TorchSharp 並不支援。多維陣列是陣列，交錯陣列是陣列的陣列，或陣列的陣列的陣列，要注意區分。

var array = new int[][][]
{
    new int[][]
    {
        new int[] { 1, 2, 3 },
        new int[] { 4, 5, 6 },
        new int[] { 7, 8, 9 }
    },
    new int[][]
    {
        new int[] { 10, 12, 11 },
        new int[] { 14, 15, 13 }
    }
};

陣列運算子

在 PyTorch 中，張量支援許多運算子，下面列舉部分加以說明：

算術運算子

+：加法，如 a + b
-：減法，如 a - b
*：元素級乘法，如 a * b
/：元素級除法，如 a / b
//：元素級整除，如 a // b ，TorchCsharp 不支援。
%：取模運算，如 a % b
**：冪運算，如 a ** b，TorchCsharp 不支援，使用 .pow(x) 代替。

邏輯運算子

==：元素級相等比較，如 a == b
!=：元素級不等於比較，如 a != b
>：元素級大於比較，如 a > b
<：元素級小於比較，如 a < b
>=：元素級大於等於比較，如 a >= b
<=：元素級小於等於比較，如 a <= b

位運算子

&：按位與運算，如 a & b
|：按位或運算，如 a | b
^：按位異或運算，如 a ^ b
~：按位取反運算，如 ~a
<<：按位左移，如 a << b
>>：按位右移，如 a >> b

索引和切片

[i]：索引運算子，如 a[i]
[i:j]：切片運算子，如 a[i:j] ，TorchCsharp 使用 a[i..j] 語法。
[i, j]：多維索引運算子，如 a[i, j]

例如張量每個元素的值 *10。

var arr = torch.from_array(new int[] { 1, 2, 3 });
arr = arr * 10;
arr.print(style: TensorStringStyle.Numpy);

[10, 20, 30]

此外，還有 Pytorch 還很多函式，後面的章節中會逐漸學習。

深度學習及pytorch基礎
2020-07-25
深度學習PyTorch
【Pytorch教程】迅速入門Pytorch深度學習框架
2024-08-26
PyTorch深度學習框架
零基礎入門深度學習-dive in to pytorch 的程式碼報錯記錄
2020-10-02
深度學習PyTorch
Anaconda Pytorch 深度學習入門記錄
2024-10-27
PyTorch深度學習
深度學習基礎
2024-08-24
深度學習
JDK學習基礎入門(一)
2020-09-29
JDK
mysql 基礎命令入門學習
2013-08-02
MySql
PyTorch深度學習入門筆記（一）PyTorch環境配置及安裝
2022-02-12
PyTorch深度學習筆記
給深度學習入門者的Python快速教程 - 基礎篇
2017-03-13
深度學習Python
MongoDB for C#基礎入門
2017-06-20
MongoDBC#
基於pytorch的深度學習實戰
2018-10-12
PyTorch深度學習
java入門基礎學習----泛型
2018-10-06
Java泛型
node 學習筆記基礎入門
2020-10-13
筆記
Oracle學習快速入門基礎教程
2006-04-19
Oracle
深度學習--RNN基礎
2023-04-25
深度學習RNN
零基礎入門深度學習工作原理？看本文就對了！
2018-05-30
深度學習
pytorch入門- tensor基礎操作（1）
2020-10-03
PyTorch
零基礎輕鬆入門——JAVA基礎學習
2017-04-07
Java
深度學習入門筆記——Transform的使用
2024-10-28
深度學習筆記ORM
Pytest學習（一）- 入門及基礎
2020-10-19
深度學習基礎之 Dropout
2020-04-06
深度學習
DL-深度學習基礎
2019-02-22
深度學習
深度學習入門筆記——DataLoader的使用
2024-10-29
深度學習筆記
C#字串基礎學習
2009-02-12
C#字串
零基礎深度學習入門：由淺入深理解反向傳播演算法
2019-03-06
深度學習反向傳播演算法
基礎入門：深度學習矩陣運算的概念和程式碼實現
2017-08-07
深度學習矩陣
深度學習框架Pytorch學習筆記
2023-02-27
深度學習框架PyTorch筆記
Linux入門學習（1基礎操作命令）
2018-08-06
Linux
CTF入門學習5-> 前端JavaScript基礎
2022-02-08
前端JavaScript
零基礎學習Alfred(一)：入門操作
2020-10-13
Alfred
Vue2.x學習一：基礎入門
2018-05-31
Vue
前端學習小結（一）—基礎入門篇
2016-12-19
前端
新手入門之——Linux學習基礎(轉)
2007-08-12
Linux
【筆記】PyTorch快速入門：基礎部分合集
2022-04-30
筆記PyTorch
Pytorch_第七篇_深度學習 (DeepLearning) 基礎 [3]---梯度下降
2020-08-05
PyTorch深度學習梯度
機器學習和深度學習概念入門
2018-04-12
機器學習深度學習
【機器學習基礎】神經網路/深度學習基礎
2021-11-05
機器學習神經網路深度學習
C# 入門深度學習：萬字長文講解微積分和梯度下降
2024-11-18
C#深度學習梯度

使用 C# 入門深度學習：Pytorch 基礎

1.2 Pytorch 基礎

基礎使用

列印

基本資料型別

CPU 或 GPU 運算

Tensor 型別

基本陣列

生成陣列

torch.zeros

torch.ones

torch.empty

複製函式

torch.rand

torch.randn

torch.randint

torch.arange

陣列操作和計算

軸

陣列排序

陣列運算子

相關文章