y = torch.tensor([1,2,3])        # shape (3,)
y[None, :]      # shape (1,3)
y[:, None]      # shape (3,1)

a = torch.tensor([0,5,2,7,3])
mask = a > 3                 # tensor([False, True, False, True, False])
a[mask]                     # tensor([5,7])  -> 1D 输出，丢失原shape信息

M = torch.arange(12).reshape(3,4)  # shape (3,4)
rows = torch.tensor([2,0])
cols = torch.tensor([1,3])
M[rows]           # 按行选择 -> shape (2,4)
M[:, cols]        # 按列选择 -> shape (3,2)
# 对应元素选择（pairwise）
M[rows, cols]     # 取 (2,1) 和 (0,3) -> shape (2,)

T = torch.arange(2*3*4).reshape(2,3,4)
idx0 = torch.tensor([0,1])    # 用于第0维
idx1 = torch.tensor([2,0])    # 用于第1维
T[idx0, idx1]    # 逐对索引 -> shape (2,4)
# 等价于: torch.stack([T[0,2], T[1,0]], dim=0)

A = torch.arange(6).reshape(2,3)  # (2,3)
idx = torch.tensor([0,2])         # (2,)
A[torch.arange(2), idx]           # (2,) -> 每 batch 对应列取值
# torch.arange(2) 为 [0,1]，与 idx 配对 -> 取 (0,0) 和 (1,2)

# gather 示例：从 src 中按 index 收集（需要指定 dim）
src = torch.tensor([[10,11,12],[20,21,22]])   # shape (2,3)
index = torch.tensor([[2,1,0],[0,2,1]])       # shape (2,3)
torch.gather(src, dim=1, index=index)
# -> shape (2,3): [[12,11,10],[20,22,21]]

v = torch.tensor([10,20,30,40])
torch.index_select(v, dim=0, index=torch.tensor([3,1]))  # tensor([40,20])
# 对于矩阵按行选：
M = torch.arange(12).reshape(3,4)
torch.index_select(M, dim=0, index=torch.tensor([2,0]))  # shape (2,4)

x = torch.tensor([1., -2., 3.])
x.masked_fill(x < 0, 0.)    # 把负数置0
torch.where(x>0, x, torch.zeros_like(x))  # 条件选择，相当于 np.where

a = torch.tensor([1,2,3])      # (3,)
a.unsqueeze(0)                 # (1,3)
a.unsqueeze(1)                 # (3,1)
torch.squeeze(a.unsqueeze(0))  # 恢复

X = torch.randn(4,5,6,7)
X[..., 0]   # 等价 X[:, :, :, 0]
X[0, ...]   # 等价 X[0, :, :, :]

t = torch.randn(2,3,4)
t[0].shape        # (3,4)   -- 整数索引去掉第0维
t[0:1].shape      # (1,3,4) -- 切片保留第0维
t[[0]].shape      # (1,3,4) -- 用长度1的索引数组也保留

s = torch.arange(6).reshape(2,3)
t = s[:, ::-1]           # 可能是 copy（不连续）
t.is_contiguous()       # 可能 False
t.contiguous().view(-1) # 安全

x = torch.randn(3, requires_grad=True)
y = x[1] * 2
y.backward()           # 会为 x[1] 累积梯度，但 x[0], x[2] 为 0
x.grad                # tensor([0., 2., 0.])

probs = torch.randn(32, 10)  # logits or probs
pred = probs.argmax(dim=1)   # (32,)
# 如果想从 probs 中收集每个 batch 对应预测的概率：
selected = probs[torch.arange(32), pred]  # shape (32,)

seq = torch.randint(0, 100, (4,7))   # batch, seq_len
mask = (seq != PAD_TOKEN)            # True 表示有效
# 通过 mask 做池化：
masked_sum = (embeddings * mask.unsqueeze(-1)).sum(dim=1)

idx = torch.tensor([0,2,1])
onehot = torch.nn.functional.one_hot(idx, num_classes=4)  # shape (3,4)

embedding = torch.nn.Embedding(num_embeddings=1000, embedding_dim=64)
out = embedding(idx_tensor)   # embedding 内部就是高级索引/ gather 实现