Tensors

import torch

t = torch.tensor([1, 2, 3])                    # from Python list (int64)
t = torch.tensor([[1.0, 2.0], [3.0, 4.0]])     # 2-D float32
t = torch.tensor(data, dtype=torch.float32)    # explicit dtype
t = torch.as_tensor(numpy_arr)                 # zero-copy if possible
t = torch.from_numpy(numpy_arr)                # shares memory with ndarray

torch.zeros(3, 4)                   # shape (3,4) filled with 0.0
torch.ones(2, 3, dtype=torch.int8)  # shape (2,3) filled with 1
torch.full((2, 3), 7.0)             # filled with 7.0
torch.empty(4, 4)                   # uninitialized (garbage values)
torch.eye(3)                        # 3×3 identity matrix
torch.arange(0, 10, 2)              # [0, 2, 4, 6, 8]
torch.linspace(0, 1, 5)             # [0.00, 0.25, 0.50, 0.75, 1.00]
torch.logspace(0, 2, 3)             # [1, 10, 100]
torch.randint(low=0, high=10, size=(3, 3))
torch.rand(3, 3)                    # uniform [0, 1)
torch.randn(3, 3)                   # standard normal
torch.normal(mean=0.0, std=1.0, size=(3,))

torch.zeros_like(t)    # same shape/dtype/device as t, filled 0
torch.ones_like(t)
torch.rand_like(t)     # requires float dtype
torch.empty_like(t)
torch.full_like(t, 3.14)

t = t.float()    # cast to float32
t = t.long()     # cast to int64
t = t.to(torch.float16)
t = t.type(torch.DoubleTensor)
print(t.dtype)

t.shape          # torch.Size([2, 3])  — same as t.size()
t.size(0)        # size of dim 0
t.ndim           # number of dimensions
t.numel()        # total number of elements
t.element_size() # bytes per element
t.is_contiguous()
t.contiguous()   # returns a contiguous copy if not already

t.reshape(6)             # returns view or copy as needed
t.view(2, 3)             # view (tensor must be contiguous)
t.view(-1)               # flatten
t.view(-1, 3)            # infer one dimension
t.flatten()              # always returns 1-D
t.flatten(start_dim=1)   # flatten from dim 1 onward
t.squeeze()              # remove all size-1 dims
t.squeeze(0)             # remove size-1 at dim 0
t.unsqueeze(0)           # insert size-1 at dim 0
t.expand(2, 3)           # broadcast without copying data
t.repeat(2, 1)           # tile data

t.T                          # transpose 2-D tensor
t.transpose(0, 1)            # swap dim 0 and 1
t.permute(2, 0, 1)           # reorder all dims
t.movedim(0, -1)             # move specific dim
t.swapaxes(0, 1)             # alias of transpose

t[0]          # first row
t[-1]         # last row
t[1, 2]       # element at row 1, col 2
t[:, 1]       # all rows, col 1
t[0:2, :]     # rows 0-1, all cols
t[..., -1]    # last element along last dim (ellipsis)

# Boolean indexing
mask = t > 0
t[mask]                     # 1-D tensor of matching values
t[t > 0] = 0               # in-place masked fill

# Fancy (advanced) indexing
idx = torch.tensor([0, 2])
t[idx]                      # rows 0 and 2

# torch.where
torch.where(t > 0, t, torch.zeros_like(t))  # element-wise conditional

t.device                   # device('cpu') or device('cuda:0')
t.is_cuda                  # bool
t.cpu()                    # move to CPU
t.cuda()                   # move to default GPU
t.to('cuda:0')             # explicit GPU
t.to(device)               # move to variable device
t.pin_memory()             # pin for faster host→device transfer

t.data_ptr()               # raw memory address (int)
t.untyped_storage()        # underlying storage (t.storage() is deprecated)
t.is_shared()              # in shared memory (for multiprocessing)

t.clone()                   # deep copy, keeps grad_fn
t.detach()                  # no-copy view, severs grad graph
t.detach().clone()          # safe copy outside autograd
t.copy_(other)              # in-place copy from other tensor

t.item()                    # Python scalar (single-element tensors only)
t.tolist()                  # nested Python list
t.numpy()                   # NumPy array (CPU, no grad, shares memory)
t.detach().cpu().numpy()    # safe pattern for GPU / grad tensors