torch.tensor([1,2,3])		# tensor([1, 2, 3])

torch.zeros(2,3)  # tensor([[0., 0., 0.],
                  #         [0., 0., 0.]])

torch.ones(2,2)   # tensor([[1., 1.],
                  #         [1., 1.]])

torch.arange(0,10,2)  # tensor([0, 2, 4, 6, 8])

torch.linspace(0,1,5)   # tensor([0.0000, 0.2500, 0.5000, 0.7500, 1.0000])

torch.eye(3)  # tensor([[1., 0., 0.],
              #         [0., 1., 0.],
              #         [0., 0., 1.]])

torch.rand(2,3)  # tensor([[0.1234, 0.6789, 0.2345],
                 #         [0.3456, 0.9876, 0.1111]])

torch.randn(2,3) # 标准正态分布，均值0方差1

torch.empty(2,2) # 未初始化内存的张量（内容随机）

x = torch.randn(2,3)
x.shape                                   # torch.Size([2, 3])
x.dtype                                   # torch.float32
x.device                                  # device(type='cpu')
x.ndim                                    # 2
x.numel()                                 # 6  （总元素数）

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

# 基础运算
a ** 2                                    # tensor([1, 4, 9])
torch.add(a,b)                            # tensor([4, 4, 4])
torch.mul(a,b)                            # tensor([3, 4, 3])

A = torch.tensor([[1.,2.],[3.,4.]])
B = torch.tensor([[2.,0.],[1.,2.]])
# 矩阵乘法
torch.matmul(A,B)                         # tensor([[4., 4.],
                                          #         [10., 8.]])
# 逆矩阵，与原矩阵相乘得到单位矩阵
torch.inverse(A)                          # tensor([[-2.0000,  1.0000],
                                          #         [ 1.5000, -0.5000]])
# 交互矩阵的行和列
torch.transpose(A, 0, 1)                  # tensor([[1., 3.],
                                          #         [2., 4.]])

x = torch.arange(6).view(2,3)             # tensor([[0, 1, 2],
                                          #         [3, 4, 5]])
# 改变张量形状
x.view(3,2)                               # tensor([[0, 1],
                                          #         [2, 3],
                                          #         [4, 5]])
# 改变张量形状，同 x.view(3,2)        
x.reshape(3,2)   
# 在原张量的第0维上增加一维，常用来将单条数据转为batch_size为1的批数据
x.unsqueeze(0).shape                      # torch.Size([1, 2, 3])
# 展平张量，常用于将图像数据展平送至全连接层中
x.flatten()                               # tensor([0, 1, 2, 3, 4, 5])
# 沿着指定维度将两个张量拼接
torch.cat([x,x], dim=0)                   # 按行拼接 → (4,3)
# 沿着指定维度将两个张量堆叠
torch.stack([x,x], dim=0)           			# torch.Size([2, 2, 3])

x = torch.arange(9).reshape(3,3)          # tensor([[0,1,2],
                                          #         [3,4,5],
                                          #         [6,7,8]])
x[:,1]                                    # tensor([1,4,7])
x[1:,:2]                                  # tensor([[3,4],
                                          #         [6,7]])
x[x>4]                                    # tensor([5,6,7,8])

torch.manual_seed(0)
torch.randint(0,10,(2,3))                 # tensor([[4, 8, 4],
                                          #         [6, 3, 4]])
torch.randn(2,2)                          # 标准正态分布
torch.rand(2,2)                           # 均匀分布 [0,1)
torch.bernoulli(torch.tensor([0.2,0.8]))  # tensor([0., 1.])

class Attention(nn.Module):
    def __init__(self, embed_dim):
        super().__init__()
        self.embed_dim = embed_dim
        self.query = nn.Linear(embed_dim, embed_dim)
        self.key = nn.Linear(embed_dim, embed_dim)
        self.value = nn.Linear(embed_dim, embed_dim)
        
    def forward(self, query, key, value):
        # Implement attention mechanism

# 全连接层
nn.Linear(in_features, out_features)
# 卷积层
nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0)
# 逆卷积层，将数据尺寸放大
nn.ConvTranspose2d(in_channels, out_channels, kernel_size, stride=2, padding=1)
# 一维归一化
nn.BatchNorm1d(num_features)
# 二维归一化
nn.BatchNorm2d(num_features)
# 层归一化（均值为0，方差为1）
nn.LayerNorm(normalized_shape)
# 嵌入层，是一种查找表，将离散数据映射为连续数据
nn.Embedding(num_embeddings, embedding_dim)
# Dropout，按比例丢弃数据
nn.Dropout(p=0.5)
# 恒等映射，常与Dropout一起用
nn.Identity()
# 激活函数
nn.ReLU(), nn.LeakyReLU(), nn.Sigmoid(), nn.Tanh()

# 将多层网络按顺序级联
model = nn.Sequential(
    nn.Conv2d(1, 20, 5),
    nn.ReLU(),
    nn.Conv2d(20, 64, 5),
    nn.ReLU()
)
# 等同于
model2 = nn.Sequential()
model2.add_module("conv1", nn.Conv2d(1, 20, 5))
model2.add_module('relu1', nn.ReLU())
model2.add_module('conv2', nn.Conv2d(20, 64, 5))
model2.add_module('relu2', nn.ReLU())

# 保存
torch.save(model.state_dict(), 'checkpoints/save.pt')
# 加载
state_dict = torch.load('checkpoints/save.pt', map_location=torch.device('cpu'))
model = Flow()
model.load_state_dict(state_dict)

transforms.Resize((256,256))
transforms.CenterCrop(224)
transforms.RandomCrop(224)
transforms.RandomHorizontalFlip()
transforms.RandomVerticalFlip()
transforms.RandomRotation(30)
transforms.ColorJitter(brightness=0.2, contrast=0.2)
transforms.RandomGrayscale(p=0.1)

transforms.ToTensor()         # PIL->Tensor, 0-1
transforms.Normalize(mean, std) # 标准化

transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean,std)
])