torch.empty(5, 3)
torch.ones(3, 3)
torch.ones_like(...)
torch.zeros(5, 3, dtype=torch.long)
torch.eye(5)

torch.arange(start=0, end=8, step=2) # 含头不含尾
torch.linspace(start=0, end=9, steps=5) # 均匀的取5个值，含头含尾


# 随机生成
torch.manual_seed(2) # 设置种子
print(torch.initial_seed()) 查看种子
torch.rand(5, 3)
torch.randn(5, 3)
torch.randn_like(x, dtype=torch.float)


# 从其它数据新建
torch.tensor([5.5, 3], dtype=torch.float32)
# torch.from_numpy(np.ones()) # 用上面的也可以

x.int()
x.long()
x.float()
x.bool()
x.char() # int8 类型
x.double()

# 有这些类型
torch.bool
torch.int
torch.short
torch.uint8 # 这个是 ByteTensor
torch.int
torch.int8
torch.int16
torch.int32
torch.long
torch.float
torch.float16
torch.float32
torch.float64
torch.double
torch.complex32
torch.complex64
# 还有很多其它



# 四舍五入
x.round()
x.fix()
x.floor()

torch.add(x, y)
# 或者
x + y

# 或者
result = torch.empty(5, 3)
torch.add(x, y, out=result)




# 大多数运算符后面可以加个下划线，表示替换运算
# 替换加
y.add_(x) # 这个会把加法的结果赋值给y
# 如 x.copy_(y), x.t_()

x.size() # torch.Size([5, 3])
x.numel() # 共多少个元素

# index 和 Numpy 一样
x[:, 1]

# 获取某一行
x.select(dim=1,index=2) # 获取按照 dim 计算的 第 index 组。
# 例子的 dim=1 表示获取的是列，index=2 表示获取第 2 列


# tensor 转其它格式
x.numpy() # 转 np.array
x.tolist() # 转 list

# 转 Python 数字，只有单个元素的时候可以用
x[0][0].item()

# 注意一个特性: 共享内存
x = torch.ones(2)
y = x.numpy()
x += 1
print(x, y)
# 打印：tensor([2., 2.]) [2. 2.]

# 值得一提，反过来也是这个特性
a = np.ones(5)
b = torch.from_numpy(a)
a += 1
print(a, b)
# [2. 2.] tensor([2., 2.])

# 修正：新版本已可用
# reshape 也可以做下面这些事，但不能reshape到1维（？不知道为什么要这么设计）

x = torch.randn(4, 4)
x.reshape(2, -1)
x.reshape(-1)

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

# 先生成，再放入 GPU
x = torch.randn(4, 4).to(device)
# 或者直接在 GPU 生成
x = torch.randn(4, 4, device=device)
# 也可以是字符串
# device = 'cpu' # device = 'cuda'
# ...to(device)

x.sqrt()
x.square()
x.exp()

x.cos()
x.cosh()
x.acos()
x.acosh()
x.arccos()
x.arccosh()

# dtype 必须是 int 类型，最好是 uint8
x1 = torch.tensor([1, 2, 3], dtype=torch.uint8)
x2 = torch.tensor([1, 1, 1], dtype=torch.uint8)


x1 & x2  # 按位与
x1 | x2  # 按位或
~x1  # 按位非
x1 ^ x2  # 按位异或
# 以上对应的运算符为：x1.bitwise_or(x2) 等类似的东西

x1 << 1  # 移位运算
# x1.bitwise_left_shift(1)

# 0 转为 False，别的数字都转为 True
x1 = torch.tensor([-0.9, 0, True, False], dtype=torch.bool)

# >、<、==、 >=、 <= 都可以
x2 = torch.rand(size=(4,)) < 0.5

# logic and:
x1 * x2
x1 *= x2

# logic or:
x1 + x2
x1 += x2

x1.logical_and(x2)
x1.logical_or(x2)
x1.logical_xor(x2)
x1.logical_xor_(x2)
x1.logical_not()
x1.logical_not_()

import torch
import torch.nn as nn
import torch.nn.functional as F
from collections import OrderedDict


class MyNet(nn.Module):
    def __init__(self):
        super(MyNet, self).__init__()
        # 方法1
        self.fc1 = nn.Linear(10, 10)
        # 方法2
        self.add_module("layer2", nn.Linear(10, 10))
        # 方法3
        self.layer3 = nn.Sequential(OrderedDict([
            ("conv1", torch.nn.Conv2d(in_channels=1, out_channels=16, kernel_size=(5, 5))),
            ("relu1", nn.ReLU())
        ]))
        # 方法4
        self.add_module("layer4", nn.Sequential(OrderedDict([
            ("conv1", torch.nn.Conv2d(in_channels=1, out_channels=16, kernel_size=(5, 5))),
            ("relu1", nn.ReLU())
        ])))

    def forward(self, x):
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        return x


my_net = MyNet()
print(my_net)
# 结果：
# MyNet(
#   (fc1): Linear(in_features=10, out_features=10, bias=True)
#   (layer2): Linear(in_features=10, out_features=10, bias=True)
#   (layer3): Sequential(
#     (conv1): Conv2d(1, 16, kernel_size=(5, 5), stride=(1, 1))
#     (relu1): ReLU()
#   )
#   (layer4): Sequential(
#     (conv1): Conv2d(1, 16, kernel_size=(5, 5), stride=(1, 1))
#     (relu1): ReLU()
#   )
# )

# 存
torch.save(model.state_dict(),'./model.pkh')

# 读
model.load_state_dict(torch.load('./model.pkh'))

# GPU：模型保存时，会记录设备序号，如果系统不一致会报错
# 把 GPU1 的权重加载到 GPU0 上
troch.load('model.pkh', map_location={"cuda:1":"cuda:0"})
torch.load('model.pkh',map_location=lambda storage,loc: storage)

# optimizer = torch.optim.SGD(my_net.parameters(), lr=0.001, momentum=0.9)
# 原来的上面一行代码，替换成下面的多行代码，其它部分不变

weight_p, bias_p = [], []
for name, p in my_net.named_parameters():
    if 'bias' in name:
        bias_p += [p]
    else:
        weight_p += [p]

optimizer = torch.optim.SGD([{'params': weight_p, 'weight_decay': 1e-5},
                             {'params': bias_p, 'weight_decay': 0}],
                            lr=1e-2,
                            momentum=0.9)

# 方法1
x = torch.ones(2, 2, requires_grad=True)
# requires_grad 默认为 False

# 方法2
x = torch.ones(2, 2)
x.requires_grad = True

y = x + 2
# y.requires_grad 为 True
# y.grad_fn 非空

# 求导数
k.backward() # 开始计算梯度
print(x.grad) # 返回梯度值
# 1. 返回 dk/dx_ij，形式是矩阵
# 2. 只会给出叶子的导数。所以 z.grad 没有值。因为计算这个值往往意义不大
# 3. 如果确实需要 z.grad，提前声明 z.retain_grad()

x.is_leaf, y.is_leaf # (True, False)

x = torch.ones(2, 2, requires_grad=True)

# 方法1. 使用 with
with torch.no_grad():
    y = x + 2

print(y.requires_grad)  # False

# 方法2. 使用装饰器
@torch.no_grad()
def func(x):
    return x + 2


y = func(x)
print(y.requires_grad)  # False

# 相反的运算是 torch.enable_grad()，可以嵌入到 no_grad() 代码块里面
# 如果 x 本身没有设置 requires_grad=True，那么即使 enable_grad()，它也不生效

# 方法3. 全局打开/关闭
torch.set_grad_enabled(True)
torch.set_grad_enabled(False)

# ???
# 如果 out 是一个 tensor 数据类型的矢量，那么这样
v = torch.tensor([1.0, 2, 3])
y.backward(v)
# ？？？但我没搞清楚这个对应哪个数学公式

optimizer = torch.optim.SGD(my_model.parameters(), lr=learning_rate)
optimizer = torch.optim.Adam(my_model.parameters(),weight_decay =0.0001) # weight_decay 是 L2 penalty

# 等间隔调整
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=7, gamma=0.1)
# 按步调整
torch.optim.lr_scheduler.MultiStepLR

# 指数衰减 lr * (gamma ** step)
torch.optim.lr_scheduler.ExponentialLR

# 余弦退火，学习率按余弦衰减
torch.optim.lr_scheduler.CosineAnnealingLR

# 指标在近几次没有变化时，调整学习率，最常用
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau \
    (optimizer=optimizer
     , mode='min'
     , factor=0.5  # gamma
     , patience=5  # 监控不再减少/增加的次数
     , verbose=True  # 触发规则后打印
     , threshold=1e-4  # 触发规则的阈值
     , threshold_mode='abs'  # 触发规则的计算方法
     , cooldown=0  # 触发规则后停止监控这么多次
     , min_lr=0  # lr最小是这么多
     , eps=1e-8
     )

# 自定义 学习率衰减
torch.optim.lr_scheduler.LambdaLR

# 训练阶段，前面一堆代码
optimizer.step()
scheduler.step()
# 后面一堆代码

optimizer = torch.optim.Adam(my_net.parameters(), lr=0.1)
# scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=20, gamma=0.5)
scheduler = torch.optim.lr_scheduler.ExponentialLR(optimizer, gamma=0.96)

lr_history = []
for i in range(100):
    scheduler.step()
    lr_history.append(optimizer.state_dict()['param_groups'][0]['lr'])

# 正向时会触发的hook
def func1(model,input,output):pass
my_net.register_forward_hook(func1)
# 反向时会触发的hook
def func2(model,grad_input,grad_output):pass
my_net.register_backward_hook(func2)

accumulation_steps = 5  # 累积5次，然后更新一次权重

for i in range(1000):
    loss = loss_func(pred, y)
    loss = loss / accumulation_steps
    loss.backward() # 计算 loss
    if (i + 1) % accumulation_steps == 0:
        optimizer.step()  # 参数更新
        optimizer.zero_grad()  # 清空梯度