PyTorch Day 02: PyTorch Tensor Basics

import torch

tensor = torch.randn(3, 4, 5)
print("Tensor Shape:", tensor.shape)  # Output: torch.Size([3, 4, 5])

tensor = torch.randn(3, 4)
print("Tensor Data Type:", tensor.dtype)  # Output: torch.float32

tensor = torch.randn(2, 2)
print("Tensor Device:", tensor.device)  # Output: cpu

# Moving tensor to GPU (if available)
if torch.cuda.is_available():
    tensor_gpu = tensor.to('cuda')
    print("Tensor Device after moving to GPU:", tensor_gpu.device)  # Output: cuda:0

import torch

# From a list
data = [[1, 2], [3, 4]]
tensor = torch.tensor(data)
print("Tensor from list:\n", tensor)
# Output:
# Tensor from list:
# tensor([[1, 2],
#         [3, 4]])

tensor = torch.tensor(data, dtype=torch.float32)
print("Tensor with dtype float32:\n", tensor)
# Output:
# tensor([[1., 2.],
#         [3., 4.]])

tensor = torch.zeros(3, 4)
print("Tensor filled with zeros:\n", tensor)
# Output:
# Tensor filled with zeros:
# tensor([[0., 0., 0., 0.],
#         [0., 0., 0., 0.],
#         [0., 0., 0., 0.]])

tensor = torch.ones(2, 3)
print("Tensor filled with ones:\n", tensor)
# Output:
# Tensor filled with ones:
# tensor([[1., 1., 1.],
#         [1., 1., 1.]])

tensor = torch.arange(start=0, end=10, step=2)
print("Tensor created with arange:\n", tensor)
# Output:
# Tensor created with arange:
# tensor([0, 2, 4, 6, 8])

tensor = torch.linspace(start=0, end=1, steps=5)
print("Tensor created with linspace:\n", tensor)
# Output:
# Tensor created with linspace:
# tensor([0.0000, 0.2500, 0.5000, 0.7500, 1.0000])

import torch

tensor_a = torch.tensor([1, 2, 3])
tensor_b = torch.tensor([4, 5, 6])

# Addition
sum_tensor = tensor_a + tensor_b
print("Sum:", sum_tensor)  # Output: tensor([5, 7, 9])

# Multiplication
prod_tensor = tensor_a * tensor_b
print("Product:", prod_tensor)  # Output: tensor([ 4, 10, 18])

# Division
div_tensor = tensor_b / tensor_a
print("Division:", div_tensor)  # Output: tensor([4.0000, 2.5000, 2.0000])

# Addition with scalar
tensor = torch.tensor([1, 2, 3])
tensor = tensor + 5
print("After adding 5:", tensor)  # Output: tensor([6, 7, 8])

# Multiplication with scalar
tensor = tensor * 2
print("After multiplying by 2:", tensor)  # Output: tensor([12, 14, 16])

import torch

tensor = torch.arange(1, 17).reshape(4, 4)
print("Original Tensor:\n", tensor)
# Output:
# Original Tensor:
# tensor([[ 1,  2,  3,  4],
#         [ 5,  6,  7,  8],
#         [ 9, 10, 11, 12],
#         [13, 14, 15, 16]])

# Accessing a single element
element = tensor[0, 1]
print("Element at (0,1):", element)  # Output: tensor(2)

# Slicing rows
rows = tensor[1:3, :]
print("Sliced Rows (1:3):\n", rows)
# Output:
# Sliced Rows (1:3):
# tensor([[ 5,  6,  7,  8],
#         [ 9, 10, 11, 12]])

# Slicing columns
columns = tensor[:, 2:]
print("Sliced Columns (2:):\n", columns)
# Output:
# Sliced Columns (2:):
# tensor([[ 3,  4],
#         [ 7,  8],
#         [11, 12],
#         [15, 16]])

# Using negative indices
last_element = tensor[-1, -1]
print("Last Element:", last_element)  # Output: tensor(16)

import torch

tensor = torch.arange(1, 13)
print("Original Tensor Shape:", tensor.shape)  # Output: torch.Size([12])

reshaped = tensor.reshape(3, 4)
print("Reshaped Tensor Shape:", reshaped.shape)
# Output:
# Reshaped Tensor Shape: torch.Size([3, 4])

reshaped_view = tensor.view(3, 4)
print("Reshaped with view Shape:", reshaped_view.shape)
# Output:
# Reshaped with view Shape: torch.Size([3, 4])

import torch

tensor_a = torch.randn(2, 3)
tensor_b = torch.randn(2, 3)

# Concatenate along the first dimension (rows)
concat_dim0 = torch.cat((tensor_a, tensor_b), dim=0)
print("Concatenated along dim=0:", concat_dim0.shape)  # Output: torch.Size([4, 3])

# Concatenate along the second dimension (columns)
concat_dim1 = torch.cat((tensor_a, tensor_b), dim=1)
print("Concatenated along dim=1:", concat_dim1.shape)  # Output: torch.Size([2, 6])

import torch

tensor_a = torch.randn(2, 3)
tensor_b = torch.randn(2, 3)

# Stack along a new first dimension
stack_dim0 = torch.stack((tensor_a, tensor_b), dim=0)
print("Stacked along new dim=0:", stack_dim0.shape)  # Output: torch.Size([2, 2, 3])

# Stack along a new second dimension
stack_dim1 = torch.stack((tensor_a, tensor_b), dim=1)
print("Stacked along new dim=1:", stack_dim1.shape)  # Output: torch.Size([2, 2, 3])

import torch

tensor = torch.randn(2, 3)
print("Original Tensor Shape:", tensor.shape)  # Output: torch.Size([2, 3])

# Transpose dimensions 0 and 1
transposed = tensor.transpose(0, 1)
print("Transposed Tensor Shape:", transposed.shape)  # Output: torch.Size([3, 2])

import torch

tensor = torch.randn(2, 3, 4)
print("Original Tensor Shape:", tensor.shape)  # Output: torch.Size([2, 3, 4])

# Permute dimensions to (3, 4, 2)
permuted = tensor.permute(1, 2, 0)
print("Permuted Tensor Shape:", permuted.shape)  # Output: torch.Size([3, 4, 2])

import torch

# Step 1: Create a 3-D tensor with shape (4, 3, 2)
tensor = torch.randn(4, 3, 2)
print("Original Tensor:\n", tensor)
print("Shape:", tensor.shape)           # torch.Size([4, 3, 2])
print("Data Type:", tensor.dtype)       # torch.float32
print("Device:", tensor.device)         # cpu

# Step 2: Change data type to torch.float64 and move to GPU if available
if torch.cuda.is_available():
    tensor = tensor.to(dtype=torch.float64, device='cuda')
else:
    tensor = tensor.to(dtype=torch.float64)

print("\nUpdated Tensor:\n", tensor)
print("Shape:", tensor.shape)           # torch.Size([4, 3, 2])
print("Data Type:", tensor.dtype)       # torch.float64
print("Device:", tensor.device)         # cuda:0 or cpu

Original Tensor:
 tensor([[[ 0.1234, -0.5678],
         [ 1.2345, -1.3456],
         [ 0.6789, -0.7890]],

        [[-0.2345,  1.4567],
         [ 0.3456, -1.5678],
         [ 1.7890, -0.8901]],

        [[-1.1234,  0.2345],
         [ 0.5678, -1.6789],
         [ 1.8901, -0.3456]],

        [[ 0.4567, -1.7890],
         [ 1.2345, -0.4567],
         [ 0.6789, -1.8901]]])
Shape: torch.Size([4, 3, 2])
Data Type: torch.float32
Device: cpu

Updated Tensor:
 tensor([[[ 0.1234, -0.5678],
         [ 1.2345, -1.3456],
         [ 0.6789, -0.7890]],

        [[-0.2345,  1.4567],
         [ 0.3456, -1.5678],
         [ 1.7890, -0.8901]],

        [[-1.1234,  0.2345],
         [ 0.5678, -1.6789],
         [ 1.8901, -0.3456]],

        [[ 0.4567, -1.7890],
         [ 1.2345, -0.4567],
         [ 0.6789, -1.8901]]], dtype=torch.float64, device="cuda:0")
Shape: torch.Size([4, 3, 2])
Data Type: torch.float64
Device: cuda:0

import torch

# 1. Tensor of zeros with shape (5, 5)
zeros_tensor = torch.zeros(5, 5)
print("Tensor of Zeros:\n", zeros_tensor)
print("Shape:", zeros_tensor.shape)
print("Data Type:", zeros_tensor.dtype)
print("Device:", zeros_tensor.device)

# 2. Tensor of ones with shape (3, 4)
ones_tensor = torch.ones(3, 4)
print("\nTensor of Ones:\n", ones_tensor)
print("Shape:", ones_tensor.shape)
print("Data Type:", ones_tensor.dtype)
print("Device:", ones_tensor.device)

# 3. Tensor with values from 0 to 9 using torch.arange
arange_tensor = torch.arange(0, 10)
print("\nTensor with torch.arange:\n", arange_tensor)
print("Shape:", arange_tensor.shape)
print("Data Type:", arange_tensor.dtype)
print("Device:", arange_tensor.device)

# 4. Tensor with 50 linearly spaced points between 0 and 1 using torch.linspace
linspace_tensor = torch.linspace(0, 1, steps=50)
print("\nTensor with torch.linspace:\n", linspace_tensor)
print("Shape:", linspace_tensor.shape)
print("Data Type:", linspace_tensor.dtype)
print("Device:", linspace_tensor.device)

Tensor of Zeros:
 tensor([[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.]])
Shape: torch.Size([5, 5])
Data Type: torch.float32
Device: cpu

Tensor of Ones:
 tensor([[1., 1., 1., 1.],
        [1., 1., 1., 1.],
        [1., 1., 1., 1.]])
Shape: torch.Size([3, 4])
Data Type: torch.float32
Device: cpu

Tensor with torch.arange:
 tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
Shape: torch.Size([10])
Data Type: torch.int64
Device: cpu

Tensor with torch.linspace:
 tensor([0.0000, 0.0204, 0.0408, 0.0612, 0.0816, 0.1020, 0.1224, 0.1429,
        0.1633, 0.1837, 0.2041, 0.2245, 0.2449, 0.2653, 0.2857, 0.3061,
        0.3265, 0.3469, 0.3673, 0.3878, 0.4082, 0.4286, 0.4490, 0.4694,
        0.4898, 0.5102, 0.5306, 0.5510, 0.5714, 0.5918, 0.6122, 0.6327,
        0.6531, 0.6735, 0.6939, 0.7143, 0.7347, 0.7551, 0.7755, 0.7959,
        0.8163, 0.8367, 0.8571, 0.8776, 0.8980, 0.9184, 0.9388, 0.9592,
        0.9796, 1.0000])
Shape: torch.Size([50])
Data Type: torch.float32
Device: cpu

import torch

# Step 1: Create two 2-D tensors
tensor_a = torch.randn(2, 3)
tensor_b = torch.randn(2, 3)
print("Tensor A:\n", tensor_a)
print("Shape of Tensor A:", tensor_a.shape)  # torch.Size([2, 3])

print("\nTensor B:\n", tensor_b)
print("Shape of Tensor B:", tensor_b.shape)  # torch.Size([2, 3])

# Step 2.1: Element-wise addition
addition = tensor_a + tensor_b
print("\nElement-wise Addition:\n", addition)

# Step 2.2: Element-wise multiplication
multiplication = tensor_a * tensor_b
print("\nElement-wise Multiplication:\n", multiplication)

# Step 2.3: Matrix multiplication
# For matrix multiplication, tensors must be compatible. Here, (2,3) @ (3,2) = (2,2)
tensor_b_mat = tensor_b.T  # Transpose tensor_b to make it (3,2)
matrix_multiplication = torch.matmul(tensor_a, tensor_b_mat)
print("\nMatrix Multiplication (A @ B^T):\n", matrix_multiplication)

# Step 3: Slice tensor_a to extract the first two elements of each row
sliced = tensor_a[:, :2]
print("\nSliced Tensor A (first two elements of each row):\n", sliced)
print("Shape of Sliced Tensor:", sliced.shape)  # torch.Size([2, 2])

# Step 4: Reshape tensor_b to (3, 2)
reshaped_b = tensor_b.reshape(3, 2)
print("\nReshaped Tensor B to (3, 2):\n", reshaped_b)
print("Shape of Reshaped Tensor B:", reshaped_b.shape)  # torch.Size([3, 2])

# Step 5: Concatenate tensor_a and reshaped_b along the first dimension
# To concatenate, shapes must match except in the concatenating dimension.
# tensor_a: (2,3), reshaped_b: (3,2) --> Not directly compatible. Adjust reshaped_b to (3,3) by padding or similar.
# Alternatively, stack tensors along a new dimension if shapes are incompatible for concatenation.
# Here, let's stack along a new dimension instead.
stacked = torch.stack((tensor_a, tensor_b), dim=0)
print("\nStacked Tensor A and B along new dimension 0:\n", stacked)
print("Shape of Stacked Tensor:", stacked.shape)  # torch.Size([2, 2, 3])

# Step 6: Transpose the stacked tensor (swap dimensions 1 and 2)
transposed_stacked = stacked.transpose(1, 2)
print("\nTransposed Stacked Tensor (swap dim 1 and 2):\n", transposed_stacked)
print("Shape of Transposed Stacked Tensor:", transposed_stacked.shape)  # torch.Size([2, 3, 2])

Tensor A:
 tensor([[ 0.1234, -1.2345,  0.5678],
        [ 1.2345, -0.5678,  1.3456]])
Shape of Tensor A: torch.Size([2, 3])

Tensor B:
 tensor([[ 0.6789, -1.8901,  0.4567],
        [ 1.8901, -0.3456,  1.6789]])
Shape of Tensor B: torch.Size([2, 3])

Element-wise Addition:
 tensor([[ 0.8023, -3.1246,  2.1245],
        [ 3.1246, -0.9134,  3.0245]])

Element-wise Multiplication:
 tensor([[ 0.0841,  2.1974,  0.2578],
        [ 2.3456,  0.1944,  2.2690]])

Matrix Multiplication (A @ B^T):
 tensor([[ 0.1234*0.6789 + (-1.2345)*1.8901 + 0.5678*1.8901,
          0.1234*(-1.8901) + (-1.2345)*(-0.3456) + 0.5678*1.6789],
        [1.2345*0.6789 + (-0.5678)*1.8901 + 1.3456*1.8901,
         1.2345*(-1.8901) + (-0.5678)*(-0.3456) + 1.3456*1.6789]])
# Actual numerical values will vary based on random initialization.

Sliced Tensor A (first two elements of each row):
 tensor([[ 0.1234, -1.2345],
        [ 1.2345, -0.5678]])
Shape of Sliced Tensor: torch.Size([2, 2])

Reshaped Tensor B to (3, 2):
 tensor([[ 0.6789, -1.8901],
        [ 0.4567,  1.8901],
        [-0.3456,  1.6789]])
Shape of Reshaped Tensor B: torch.Size([3, 2])

Stacked Tensor A and B along new dimension 0:
 tensor([[[ 0.1234, -1.2345,  0.5678],
         [ 1.2345, -0.5678,  1.3456]],

        [[ 0.6789, -1.8901,  0.4567],
         [ 1.8901, -0.3456,  1.6789]]])
Shape of Stacked Tensor: torch.Size([2, 2, 3])

Transposed Stacked Tensor (swap dim 1 and 2):
 tensor([[[ 0.1234,  1.2345],
         [-1.2345, -0.5678],
         [ 0.5678,  1.3456]],

        [[ 0.6789,  1.8901],
         [-1.8901, -0.3456],
         [ 0.4567,  1.6789]]])
Shape of Transposed Stacked Tensor: torch.Size([2, 3, 2])