import torch

torch.__version__

scalar = torch.tensor(9)
scalar

scalar.ndim, scalar.ndimension()

scalar.item()

vector = torch.tensor([9, 9, 9])
vector

vector.ndim

vector.shape

matrix = torch.tensor([[9, 9, 9],
                       [9, 9, 9]])
matrix

matrix.ndim

matrix.shape

matrix.size()

tensor = torch.tensor(
    [  #dim0, 这对括号里面有两个matrix
        [  #dim1, 这对括号里面有三个vector
            [  #dim2, 这对括号里面有三个scalar
                1,
                2,
                3,
            ],
            [1, 2, 3],
            [1, 2, 3]
        ],
        [  #dim1
            [1, 2, 3],
            [1, 2, 3],
            [1, 2, 3]
        ]
    ]
)
tensor

tensor.ndim

tensor.shape

ramdom_tensor = torch.rand(size=(3, 4))
ramdom_tensor, ramdom_tensor.dtype

random_image_size_tensor = torch.rand(size=(224, 224, 3))
random_image_size_tensor.shape, random_image_size_tensor.ndim

zeros = torch.zeros(size=(3, 4))
zeros, zeros.dtype

ones = torch.ones(size=(3, 4))
ones, ones.dtype

# Use torch.arange(), torch.range() is deprecated 
zero_to_ten_deprecated = torch.range(0, 10)

zero_to_ten = torch.arange(start=0, end=10, step=1)
zero_to_ten

ten_zeros = torch.zeros_like(input=zero_to_ten)
ten_zeros

float_32_tensor = torch.tensor([1, 2, 3],
                               dtype=None,  # default is float32
                               device=None,  # default is cpu
                               requires_grad=False,
                               # if True, the tensor will keep track of the operations that created it
                               )
float_32_tensor.shape, float_32_tensor.dtype, float_32_tensor.device, float_32_tensor.requires_grad

float_16_tensor = torch.tensor([3.0, 6.0, 9.0],
                               dtype=torch.float16)  # torch.half would also work

float_16_tensor.dtype

tensor = torch.tensor([1, 2, 3])
# Tensors don't change unless reassigned, when you do an operation, you need to assign it to a new tensor

tensor + 10, torch.add(tensor, 10)

tensor - 10, torch.sub(tensor, 10)

tensor * 10, torch.multiply(tensor, 10), torch.mul(tensor, 10)

tensor / 10, torch.divide(tensor, 10), torch.div(tensor, 10)

# Element-wise multiplication (each element multiplies its equivalent, index 0->0, 1->1, 2->2)
tensor * tensor, torch.mul(tensor, tensor)

import torch

tensor = torch.tensor([1, 2, 3])
tensor.shape

tensor * tensor, torch.mul(tensor, tensor)

tensor @ tensor, torch.matmul(tensor, tensor)
# torch.mm(tensor, tensor) this will error, as the tensors are not matrices

# Shapes need to be in the right way  
tensor_A = torch.tensor([[1, 2],
                         [3, 4],
                         [5, 6]], dtype=torch.float32)

tensor_B = torch.tensor([[7, 10],
                         [8, 11],  #
                         [9, 12]], dtype=torch.float32)

torch.matmul(tensor_A, tensor_B)  # (this will error)

print(tensor_A)
print(tensor_B)

print(tensor_A)
print(tensor_B.T)

# The operation works when tensor_B is transposed
print(f"Original shapes: tensor_A = {tensor_A.shape}, tensor_B = {tensor_B.shape}\n")
print(f"New shapes: tensor_A = {tensor_A.shape} (same as above), tensor_B.T = {tensor_B.T.shape}\n")
print(f"Multiplying: {tensor_A.shape} * {tensor_B.T.shape} <- inner dimensions match\n")
print("Output:\n")
output = torch.matmul(tensor_A, tensor_B.T)
print(output)
print(f"\nOutput shape: {output.shape}")

tensor_A @ tensor_B.T, torch.matmul(tensor_A, tensor_B.T), torch.mm(tensor_A, tensor_B.T)

torch.manual_seed(42)
linear = torch.nn.Linear(in_features=2, out_features=6)
x = tensor_A
output = linear(x)
print(f"Input shape: {x.shape}\n")
print(f"Output:\n{output}\n\nOutput shape: {output.shape}")

x = torch.arange(0, 100, 10)
x, x.dtype

print(f"Minimum: {x.min()}")
print(f"Maximum: {x.max()}")
# print(f"Mean: {x.mean()}") # this will error
print(f"Mean: {x.type(torch.float32).mean()}")  # won't work without float datatype
print(f"Sum: {x.sum()}")

torch.max(x), torch.min(x), torch.mean(x.type(torch.float32)), torch.sum(x)

# Create a tensor
tensor = torch.arange(10, 100, 10)
print(f"Tensor: {tensor}")

# Returns index of max and min values
print(f"Index where max value occurs: {tensor.argmax()}")
print(f"Index where min value occurs: {tensor.argmin()}")

torch.argmax(tensor), torch.argmin(tensor)

tensor.type(torch.float16)

tensor.type(torch.int8)

# Create a tensor
import torch

x = torch.arange(1., 8.)
x, x.shape

x_reshaped = torch.reshape(x, (1, 7))
x_reshaped, x_reshaped.shape

x_view = x.view(1, 7)
x_view, x_view.shape

# change x_view, x_reshaped will also change
x_view[:, 0] = 7
x_view, x

x_stacked = torch.stack([x, x, x, x, x], dim=0)
x_stacked, x_stacked.shape

x_stacked = torch.stack([x, x, x, x, x], dim=1)
x_stacked, x_stacked.shape

print(f"Previous tensor: {x_reshaped}")
print(f"Previous shape: {x_reshaped.shape}")

# Remove extra dimension from x_reshaped
x_squeezed = x_reshaped.squeeze()
print(f"\nNew tensor: {x_squeezed}")
print(f"New shape: {x_squeezed.shape}")

print(f"Previous tensor: {x_squeezed}")
print(f"Previous shape: {x_squeezed.shape}")

## Add an extra dimension with unsqueeze
x_unsqueezed = x_squeezed.unsqueeze(dim=0)
print(f"\nNew tensor: {x_unsqueezed}")
print(f"New shape: {x_unsqueezed.shape}")

# Create tensor with specific shape
x_original = torch.rand(size=(224, 224, 3))

# Permute the original tensor to rearrange the axis order
x_permuted = x_original.permute(2, 0, 1)  # shifts axis 0->1, 1->2, 2->0

print(f"Previous shape: {x_original.shape}")
print(f"New shape: {x_permuted.shape}")

# Create a tensor 
import torch

x = torch.arange(1, 10).reshape(1, 3, 3)
x, x.shape

# Let's index bracket by bracket
print(f"First square bracket:\n{x[0]}")
print(f"Second square bracket: {x[0][0]}")
print(f"Third square bracket: {x[0][0][0]}")

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

# Get all values of 0th dimension and the 0 index of 1st dimension
x[:, 0]

# Get all values of 0th & 1st dimensions but only index 1 of 2nd dimension
x[:, :, 1]

# Get all values of the 0 dimension but only the 1 index value of the 1st and 2nd dimension
x[:, 1, 1]

# Get index 0 of 0th and 1st dimension and all values of 2nd dimension 
x[0, 0, :]  # same as x[0][0]

# NumPy array to tensor
import torch
import numpy as np
array = np.arange(1.0, 8.0)
tensor = torch.from_numpy(array)
array, tensor

tensor= torch.from_numpy(array).type(torch.float32)

# Tensor to NumPy array
tensor = torch.ones(7) # create a tensor of ones with dtype=float32
numpy_tensor = tensor.numpy() # will be dtype=float32 unless changed
tensor, numpy_tensor

import torch

# Create two random tensors
random_tensor_A = torch.rand(3, 4)
random_tensor_B = torch.rand(3, 4)

print(f"Tensor A:\n{random_tensor_A}\n")
print(f"Tensor B:\n{random_tensor_B}\n")
print(f"Does Tensor A equal Tensor B? (anywhere)")
random_tensor_A == random_tensor_B

import torch
import random

# # Set the random seed
RANDOM_SEED=42 # try changing this to different values and see what happens to the numbers below
torch.manual_seed(seed=RANDOM_SEED) 
random_tensor_C = torch.rand(3, 4)

# Have to reset the seed every time a new rand() is called 
# Without this, tensor_D would be different to tensor_C 
torch.random.manual_seed(seed=RANDOM_SEED) # try commenting this line out and seeing what happens
random_tensor_D = torch.rand(3, 4)

print(f"Tensor C:\n{random_tensor_C}\n")
print(f"Tensor D:\n{random_tensor_D}\n")
print(f"Does Tensor C equal Tensor D? (anywhere)")
random_tensor_C == random_tensor_D

import torch
import random

# # Set the random seed
RANDOM_SEED=42 # try changing this to different values and see what happens to the numbers below
torch.manual_seed(seed=RANDOM_SEED) 
random_tensor_C = torch.rand(3, 4)

# Have to reset the seed every time a new rand() is called 
# Without this, tensor_D would be different to tensor_C 
# torch.random.manual_seed(seed=RANDOM_SEED) # try commenting this line out and seeing what happens
random_tensor_D = torch.rand(3, 4)

print(f"Tensor C:\n{random_tensor_C}\n")
print(f"Tensor D:\n{random_tensor_D}\n")
print(f"Does Tensor C equal Tensor D? (anywhere)")
random_tensor_C == random_tensor_D

if torch.cuda.is_available():
    device = "cuda" # Use NVIDIA GPU (if available)
    print(torch.cuda.device_count())
elif torch.backends.mps.is_available():
    device = "mps" # Use Apple Silicon GPU (if available)
    print(torch.mps.device_count())
else:
    device = "cpu" # Default to CPU if no GPU is available
    print(torch.cpu.device_count())
device

# Create tensor (default on CPU)
tensor = torch.tensor([1, 2, 3])

# Tensor not on GPU
print(tensor, tensor.device)

# Move tensor to GPU (if available)
tensor_on_gpu = tensor.to(device)
tensor_on_gpu

# If tensor is on GPU, can't transform it to NumPy (this will error)
tensor_on_gpu.numpy()

# Instead, copy the tensor back to cpu
tensor_back_on_cpu = tensor_on_gpu.cpu().numpy()
tensor_back_on_cpu

tensor_on_gpu