import torch

# 創(chuàng)建一維張量（向量）
tensor1d = torch.tensor([1.0, 2.0, 3.0])  # 浮點(diǎn)型向量
tensor1d_int = torch.tensor([1, 2, 3])     # 整型向量

# 創(chuàng)建二維張量（矩陣）
tensor2d = torch.tensor([[1, 2, 3], [4, 5, 6]])  # 2x3矩陣
tensor2d_float = torch.tensor([[1., 2.], [3., 4.]])  # 2x2浮點(diǎn)矩陣

# 創(chuàng)建三維張量
tensor3d = torch.tensor([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])  # 2x2x2張量

# 創(chuàng)建全零張量（常用于初始化）
zeros = torch.zeros(3, 4)  # 3行4列的全零矩陣
zeros_3d = torch.zeros(2, 3, 4)  # 2x3x4的三維零張量

# 創(chuàng)建全一張量
ones = torch.ones(2, 3)    # 2行3列的全一矩陣
ones_like = torch.ones_like(zeros)  # 創(chuàng)建與zeros形狀相同的全一張量

# 創(chuàng)建隨機(jī)張量（常用于權(quán)重初始化）
rand_tensor = torch.rand(5, 5)  # 5x5的隨機(jī)矩陣，值在[0,1)之間均勻分布
randn_tensor = torch.randn(3, 3)  # 3x3的正態(tài)分布隨機(jī)矩陣，均值0，方差1

# 創(chuàng)建單位矩陣（常用于線性變換初始化）
eye_matrix = torch.eye(4)  # 4x4的單位矩陣
eye_with_offset = torch.eye(3, 4, k=1)  # 3x4的矩陣，對(duì)角線偏移1位

# 創(chuàng)建等差數(shù)列張量
arange_tensor = torch.arange(0, 10, 2)  # [0, 2, 4, 6, 8]
linspace_tensor = torch.linspace(0, 1, 5)  # [0.0, 0.25, 0.5, 0.75, 1.0]

tensor = torch.rand(3, 4)

# 數(shù)據(jù)類型 - 決定張量存儲(chǔ)的數(shù)值類型
print(tensor.dtype)    # 如torch.float32、torch.int64等
# 常用類型：torch.float32, torch.float64, torch.int32, torch.int64

# 存儲(chǔ)設(shè)備 - 決定張量存儲(chǔ)在CPU還是GPU上
print(tensor.device)   # 如'cpu'或'cuda:0'
# 可以通過.to(device)方法在設(shè)備間移動(dòng)張量

# 形狀 - 描述張量的維度信息
print(tensor.shape)    # 如torch.Size([3, 4])
print(tensor.size())   # 同shape的另一種訪問方式
print(tensor.ndim)     # 張量的維度數(shù)，這里是2

# 梯度計(jì)算標(biāo)志 - 決定張量是否需要計(jì)算梯度
print(tensor.requires_grad)  # 默認(rèn)為False
# 當(dāng)設(shè)置為True時(shí)，PyTorch會(huì)跟蹤對(duì)此張量的所有操作以計(jì)算梯度

# 其他屬性
print(tensor.is_leaf)  # 是否為葉節(jié)點(diǎn)（用戶直接創(chuàng)建的張量）
print(tensor.is_cuda)  # 是否存儲(chǔ)在GPU上
print(tensor.grad)     # 存儲(chǔ)的梯度值（如果有）

a = torch.tensor([1, 2, 3], dtype=torch.float32)
b = torch.tensor([4, 5, 6], dtype=torch.float32)

# 加法（逐元素相加）
c = a + b          # 直接運(yùn)算符
c = torch.add(a, b)  # 函數(shù)形式
c = a.add(b)       # 方法形式

# 原地加法（不創(chuàng)建新張量）
a.add_(b)  # 等價(jià)于 a += b

# 乘法（逐元素相乘）
d = a * b          # [1*4, 2*5, 3*6] = [4, 10, 18]
d = torch.mul(a, b)
d = a.mul(b)

# 除法（逐元素相除）
e = a / b          # [1/4, 2/5, 3/6]
e = torch.div(a, b)

# 矩陣乘法
mat_a = torch.rand(3, 4)  # 3x4矩陣
mat_b = torch.rand(4, 5)  # 4x5矩陣
mat_prod = torch.matmul(mat_a, mat_b)  # 3x5結(jié)果矩陣
mat_prod = mat_a @ mat_b  # Python 3.5+支持的運(yùn)算符

# 廣播機(jī)制示例
a = torch.rand(5, 1, 4)
b = torch.rand(  1, 3)
c = a + b  # 廣播后形狀為(5,3,4)

tensor = torch.arange(12).reshape(3, 4)
"""
tensor([[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]])
"""

# 基本索引
print(tensor[0])       # 第一行: tensor([0, 1, 2, 3])
print(tensor[-1])      # 最后一行: tensor([ 8,  9, 10, 11])
print(tensor[:, 1])    # 第二列: tensor([1, 5, 9])
print(tensor[1:3, 2])  # 第二三行的第三列元素: tensor([6, 10])

# 高級(jí)索引
print(tensor[[0, 2], [1, 3]])  # 第0行第1列和第2行第3列: tensor([1, 11])
print(tensor[tensor > 5])      # 所有大于5的元素: tensor([6, 7, 8, 9, 10, 11])

# 修改子張量
tensor[1:, 2:] = 0  # 將第二行開始的右下2x2子矩陣置零

# 改變形狀（不改變數(shù)據(jù)）
tensor = torch.rand(4, 6)
reshaped = tensor.reshape(3, 8)  # 總元素?cái)?shù)必須保持不變
viewed = tensor.view(2, 12)      # 與reshape類似，但對(duì)內(nèi)存連續(xù)性有要求

# 轉(zhuǎn)置
transposed = tensor.t()  # 僅適用于2D張量
permuted = tensor.permute(1, 0)  # 通用轉(zhuǎn)置方法

# 增加/減少維度
tensor = torch.rand(3, 4)
unsqueezed = tensor.unsqueeze(0)  # 在0維增加1維，變?yōu)?x3x4
squeezed = unsqueezed.squeeze()   # 去除所有長度為1的維度

# 連接張量
a = torch.rand(2, 3)
b = torch.rand(2, 3)
cat_0 = torch.cat([a, b], dim=0)  # 沿0維連接，結(jié)果為4x3
cat_1 = torch.cat([a, b], dim=1)  # 沿1維連接，結(jié)果為2x6

# 分割張量
chunks = torch.chunk(tensor, 3, dim=0)  # 沿0維分成3塊
splits = torch.split(tensor, 2, dim=1)  # 沿1維每2列分一塊

import numpy as np

# 張量轉(zhuǎn) NumPy
tensor = torch.ones(5)
numpy_array = tensor.numpy()  # 共享內(nèi)存，修改一個(gè)會(huì)影響另一個(gè)

# 注意：GPU上的張量需要先移動(dòng)到CPU
gpu_tensor = torch.rand(5, device='cuda')
cpu_tensor = gpu_tensor.cpu()
numpy_array = cpu_tensor.numpy()

# NumPy 轉(zhuǎn)張量
np_array = np.array([1, 2, 3])
torch_tensor = torch.from_numpy(np_array)  # 同樣共享內(nèi)存

# 不共享內(nèi)存的創(chuàng)建方式
torch_tensor_copy = torch.tensor(np_array)  # 創(chuàng)建新副本

# 檢查GPU是否可用
device = 'cuda' if torch.cuda.is_available() else 'cpu'
print(f"Using device: {device}")

# 創(chuàng)建張量并移動(dòng)到GPU
tensor = torch.rand(10, 10).to(device)

# 直接在目標(biāo)設(shè)備上創(chuàng)建張量
gpu_tensor = torch.rand(5, 5, device='cuda')

# 在GPU上執(zhí)行運(yùn)算
result = tensor * 2  # 如果tensor在GPU上，result也會(huì)在GPU上

# 將結(jié)果移回CPU
cpu_result = result.cpu()

# 多GPU示例（需要多GPU環(huán)境）
if torch.cuda.device_count() > 1:
    tensor = tensor.to('cuda:1')  # 顯式指定第二個(gè)GPU

# 創(chuàng)建需要計(jì)算梯度的張量
x = torch.tensor(2.0, requires_grad=True)
w = torch.tensor(1.0, requires_grad=True)
b = torch.tensor(0.5, requires_grad=True)

# 構(gòu)建計(jì)算圖
y = w * x + b  # 線性函數(shù)
z = y**2       # 非線性變換

# 反向傳播計(jì)算梯度
z.backward()  # 計(jì)算dz/dx, dz/dw, dz/db

# 查看梯度
print(x.grad)  # dz/dx = 2*(w*x+b)*w = 2*(1*2+0.5)*1 = 5.0
print(w.grad)  # dz/dw = 2*(w*x+b)*x = 2*(1*2+0.5)*2 = 10.0
print(b.grad)  # dz/db = 2*(w*x+b)*1 = 2*(1*2+0.5)*1 = 5.0

# 梯度清零（重要！在訓(xùn)練循環(huán)中需要）
x.grad.zero_()
w.grad.zero_()
b.grad.zero_()

# 禁用梯度跟蹤（用于推理階段）
with torch.no_grad():
    y = w * x + b  # 不會(huì)在計(jì)算圖中記錄

# 視圖操作共享內(nèi)存
a = torch.rand(4, 5)
b = a.view(20)  # b與a共享內(nèi)存
c = a[1:3, 2:4]  # c與a共享內(nèi)存

# clone()創(chuàng)建獨(dú)立副本
d = a.clone()  # d與a不共享內(nèi)存

# 創(chuàng)建稀疏張量
indices = torch.tensor([[0, 1, 2], [2, 0, 1]])  # 非零元素的坐標(biāo)
values = torch.tensor([3, 4, 5], dtype=torch.float32)  # 非零元素的值
shape = torch.Size([3, 3])  # 稀疏張量的形狀

sparse_tensor = torch.sparse_coo_tensor(indices, values, shape)
print(sparse_tensor.to_dense())  # 轉(zhuǎn)換為稠密張量

# 分布式訓(xùn)練中的張量分片
import torch.distributed as dist

if dist.is_initialized():
    # 將張量分片到不同進(jìn)程
    tensor = torch.rand(10, 10)
    shard = tensor.chunk(dist.get_world_size(), dim=0)[dist.get_rank()]

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
x = x.to(device)  # 將張量移動(dòng)到指定設(shè)備

x = torch.tensor(2.0, requires_grad=True)
y = x**2
y.backward()  # 自動(dòng)計(jì)算梯度
print(x.grad)  # 輸出梯度值 4.0