数据操作

<!-- #include-env-start: D:/code/klc/test/share4ai/docs/book/dive_into_on_dl/dl_basic -->
```python
import torch
scalar=torch.tensor(7)
scalar.ndim

scalar.item()

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

# 维度 dimension
print(vector.ndim)
print(vector.dim())

vector.shape

# Matrix
MATRIX = torch.tensor([[7, 8], 
                       [9, 10]])

MATRIX.ndim,MATRIX.shape

# Tensor
TENSOR = torch.tensor([[[1, 2, 3],
                        [3, 6, 9],
                        [2, 4, 5]]])
TENSOR

TENSOR.ndim
TENSOR.shape

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

# Create a tensor of all zeros
zeros = torch.zeros(size=(3, 4))
zeros, zeros.dtype

# Create a tensor of all ones
ones = torch.ones(size=(3, 4))
ones, ones.dtype

# Create a range of values 0 to 10
zero_to_ten = torch.arange(start=0, end=10, step=1)
zero_to_ten

# Can also create a tensor of zeros similar to another tensor
ten_zeros = torch.zeros_like(input=zero_to_ten) # will have same shape
print(ten_zeros)
ten_ones = torch.ones_like(input=zero_to_ten) # will have same shape
print(ten_ones)

float_32_tensor = torch.tensor(data=[5,6,7],dtype=torch.float32)
float_32_tensor,float_32_tensor.dtype

# Create a tensor
some_tensor = torch.rand(3, 4)

# Find out details about it
print(some_tensor)
print(f"Shape of tensor: {some_tensor.shape}")
print(f"Datatype of tensor: {some_tensor.dtype}")
print(f"Device tensor is stored on: {some_tensor.device}") # will default to CPU

# Manipulating tensors
# Create a tensor of values and add a number to it
tensor = torch.tensor([1, 2, 3])
print(tensor + 10)

# Subtract and reassign
print(tensor-10)

# Multiply it by 10
print(tensor * 10)
print(torch.multiply(tensor, 10))

# Division it by 10
print(tensor / 10)

# Element-wise multiplication (each element multiplies its equivalent, index 0->0, 1->1, 2->2)
print(tensor, "*", tensor)
print("Equals:", tensor * tensor)

# Matrix multiplication
torch.matmul(tensor, tensor)

# 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)

# 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}")

# Since the linear layer starts with a random weights matrix, let's make it reproducible (more on this later)
torch.manual_seed(42)

# Since the linear layer starts with a random weights matrix, let's make it reproducible (more on this later)
torch.manual_seed(42)
# This uses matrix mutliplcation
# 输入样本的维度2，输出样本维度6
linear = torch.nn.Linear(in_features=2, # in_features = matches inner dimension of input 
                         out_features=6) # out_features = describes outer value 
x = tensor_A
print(f"Input tensor_A: {tensor_A}\n")
output = linear(x)
print(f"Input shape: {x.shape}\n")
print(f"Output:\n{output}\n\nOutput shape: {output.shape}")

# min, max, mean, sum
x = torch.arange(0, 100, 10)
x

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()}")

# Positional min/max
# 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()}")

# Create a tensor and check its datatype
tensor = torch.arange(10., 100., 10.)
print(f"tensor.dtype: {tensor.dtype}")
# Create a float16 tensor
tensor_float16 = tensor.type(torch.float16)
print(f"tensor_float16: {tensor_float16}")
# Create a int8 tensor
tensor_int8 = tensor.type(torch.int8)
print(f"tensor_int8: {tensor_int8}")

# Reshaping, stacking, squeezing and unsqueezing
x = torch.arange(1., 8.)
print(x, x.shape)

# Add an extra dimension
x_reshaped = x.reshape(1, 7)
print(x_reshaped, x_reshaped.shape, x_reshaped.dim())

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}")

x_unsqueezed_1 = x_unsqueezed.unsqueeze(dim=0)
print(f"\nNew tensor: {x_unsqueezed_1}")
print(f"New shape: {x_unsqueezed_1.shape}")

# Create tensor with specific shape
x_original = torch.rand(size=(2, 1, 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 x_original: {x_original}, shape: {x_original.shape}")
print(f"New x_permuted: {x_permuted}, shape: {x_permuted.shape}")

# Create a tensor 
import torch
x = torch.arange(1, 10).reshape(1, 3, 3)
print(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]}")

# Get all values of 0th dimension and the 0 index of 1st dimension
print(x[:, 0])
# Get all values of 0th & 1st dimensions but only index 1 of 2nd dimension
print(x[:, :, 1])
# Get all values of the 0 dimension but only the 1 index value of the 1st and 2nd dimension
print(x[:, 1, 1])

# 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 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

# 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

torch.cuda.is_available()