# 从均值为 0，标准差为 1 的正态分布中采样随机值
torch.randn(3, 4)

x = torch.tensor([1.0, 2, 4, 8])
y = torch.tensor([2, 2, 2, 2])
x + y, x - y, x * y, x / y, x ** y  # **运算符是求幂运算

torch.exp(x)

X = torch.arange(12, dtype=torch.float32).reshape((3,4))
Y = torch.tensor([[2.0, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
torch.cat((X, Y), dim=0), torch.cat((X, Y), dim=1)

X == Y

X.sum() # 所有元素求和

a = torch.arange(3).reshape((3, 1))
b = torch.arange(2).reshape((1, 2))
a, b

a + b

X[-1], X[1:3]

X[1, 2] = 9
X

X[0:2, :] = 12
X

y = torch.zeros(2, 3)
y[:] = y + 1
# 或者也可以直接使用 += 这种类型的就地更新运算符，它实际上是执行 y.add_(1)
y += 1

A = X.numpy()
B = torch.tensor(A)
type(A), type(B)

a = torch.tensor([3])
a, a.item(), float(a), int(a)

import os

os.makedirs(os.path.join('..', 'data'), exist_ok=True)
data_file = os.path.join('..', 'data', 'house_tiny.csv')
with open(data_file, 'w') as f:
    f.write('NumRooms,Alley,Price\n')  # 列名
    f.write('NA,Pave,127500\n')  # 每行表示一个数据样本
    f.write('2,NA,106000\n')
    f.write('4,NA,178100\n')
    f.write('NA,NA,140000\n')

import pandas as pd

data = pd.read_csv(data_file)
print(data)

inputs, outputs = data.iloc[:, 0:2], data.iloc[:, 2]
inputs = inputs.fillna(inputs.mean())
print(inputs)

inputs = pd.get_dummies(inputs, dummy_na=True)
print(inputs)

import torch

X, y = torch.tensor(inputs.values), torch.tensor(outputs.values)
X, y

import torch

x = torch.tensor(3.0)
y = torch.tensor(2.0)

x + y, x * y, x / y, x**y
# (tensor(5.), tensor(6.), tensor(1.5000), tensor(9.))

x = torch.arange(4)
# tensor([0, 1, 2, 3])

A = torch.arange(20).reshape(5, 4)

X = torch.arange(24).reshape(2, 3, 4)

a = torch.arange(9).reshape(3, 3)
b = a.clone()
print(a * b)

x = torch.arange(4, dtype=torch.float32)
x, x.sum()
# tensor([0., 1., 2., 3.])
# tensor(6.)  求和的结果仍然是一个张量，仅包含一个数值，只有一行一列

A_sum_axis0 = A.sum(axis=0)
A_sum_axis0, A_sum_axis0.shape
# (tensor([40., 45., 50., 55.]), torch.Size([4]))

A.mean(), A.sum() / A.numel()
# tensor(9.5000), tensor(9.5000)

A.mean(axis=0), A.sum(axis=0) / A.shape[0]
(tensor([ 8.,  9., 10., 11.]), tensor([ 8.,  9., 10., 11.]))

sum_A = A.sum(axis=1, keepdims=True)

x = torch.tensor([1, 2, 3, 4])
print(torch.cumsum(x, dim=0))
# tensor([1, 3, 6, 10])

y = torch.ones(4, dtype = torch.float32)
x, y, torch.dot(x, y)
# torch.dot(x, y) 等同于 torch.sum(x * y)

A.shape, x.shape, torch.mv(A, x)
# (torch.Size([5, 4]), torch.Size([4]), tensor([ 14.,  38.,  62.,  86., 110.]))

A = torch.arange(20).reshape(5, 4)
B = torch.ones(4, 3, dtype=torch.long)
torch.mm(A, B)

u = torch.tensor([3.0, -4.0])
torch.norm(u)
# tensor(5.)

torch.abs(u).sum()
# tensor(7.)

torch.norm(torch.ones((4, 9)))
# tensor(6.)

"""生成y=Xw+b+噪声"""
def synthetic_data(w, b, num_examples):
    # torch.normal 可用来生成随机值
    # 第1个参数表示均值为 0，第2个参数表示标准差为 1,用来控制随机值的离散程度
    # 第3个参数用来控制结果的形状
    X = torch.normal(0, 1, (num_examples, len(w)))
    y = torch.matmul(X, w) + b # 做仿射变换
    y += torch.normal(0, 0.01, y.shape) # 添加随机噪声
    return X, y.reshape((-1, 1))

true_w = torch.tensor([2, -3.4])
true_b = 4.2
features, labels = synthetic_data(true_w, true_b, 1000)

# 按 batch_size 从数据集中随机采样数据
def data_iter(batch_size, features, labels):
    num_examples = len(features)
    indices = list(range(num_examples))
    # 这些样本是随机读取的，没有特定的顺序
    random.shuffle(indices)
    for i in range(0, num_examples, batch_size):
        batch_indices = torch.tensor(
            indices[i: min(i + batch_size, num_examples)])
        yield features[batch_indices], labels[batch_indices]

w = torch.normal(0, 0.01, size=(2,1), requires_grad=True)
b = torch.zeros(1, requires_grad=True)

"""线性回归模型"""
def linreg(X, w, b):  
    return torch.matmul(X, w) + b

"""均方损失"""
def squared_loss(y_hat, y):
    return (y_hat - y.reshape(y_hat.shape)) ** 2 / 2

"""
小批量随机梯度下降 Small-Batch SGD, Stochastic Gradient Descent
三个参数分别如下：
params：参数的集合
lr：学习率
batch_size：批量大小
"""
def sgd(params, lr, batch_size):
    with torch.no_grad():
        for param in params:
            param -= lr * param.grad / batch_size
            param.grad.zero_()
            
# 此处参数的梯度之所以除以 batch_size，貌似因为 param.grad 的损失是一个总和值，而不是平均值，因此需要除以 batch_size，以便得到损失的平均值。但这通常不是一个默认的行为，默认情况下 reduction='mean'，仅在 reduction = "sum" 时，才是上面这种情况，因此后续有待观察 params 是如何计算出来的

lr = 0.03
num_epochs = 3
net = linreg # 线性网络
loss = squared_loss # 均方差损失

for epoch in range(num_epochs):
    for X, y in data_iter(batch_size, features, labels):
        l = loss(net(X, w, b), y)  # 计算 X 和 y 的批量损失
        # 因为 l 形状是(batch_size,1)，而不是一个标量。
        # l 中的所有元素加到一起，以便计算 [w,b] 的总损失
        # 此处通过 sum 将损失累加了，故后面需要除以 batch_size 以得到平均损失
        # 调用 backward 方法反向传播计算梯度
        l.sum().backward()  # 它会沿着计算图回溯，并将梯度值记录在张量的 grad 属性中
        sgd([w, b], lr, batch_size)  # 使用优化算法（小批量梯度下降）更新参数
    with torch.no_grad():
        train_l = loss(net(features, w, b), labels)
        print(f'epoch {epoch + 1}, loss {float(train_l.mean()):f}')

import torch

# x 是标量的场景
x = torch.tensor(2.0, requires_grad=True)
y = x ** 2
# backward 方法会自动计算 x -> y 的梯度，也即 dy/dx，并将结果存放在 x.grad 属性中
# 因为 y 是标量，所以可以直接调用 backward，无需提供参数
# 如果 y 是向量，则需要提供初始梯度权重做为参数
y.backward() 
print(x.grad) # 输出：tensor(4.0)，因 dy / dx = 2x = 4

# x 是向量的场景
x = torch.tensor([1.0, 2.0], requires_grad=True) 
y = x * 2 # y = [2, 4]
"""
此处 x 和 y 都是一个向量，因此需要提供梯度参数（权重），例如 torch.tensor([0.1, 0.2])，
此处的梯度参数 torch.tensor([0.1, 0.2] 代表的是上游梯度，形状必须跟 y 相同，以便从中取出对应索引位置的标量
"""
y.backward(torch.tensor([0.1, 0.2]))
print(x.grad) # 输出：tensor([0.2, 0.4])
"""
之所以调用 y.backward 方法，会导致 x.grad 出现变化，是因为在使用 torch.tensor 初始化 x 时，设置了参数 requires_grad=True，因此 PyTorch 会自动创建计算图，记录 x 的计算过程,从而在计算中，能够找到 x 和 y 的关联；
另外，貌似 requires_grad=True 会传导，即计算出来的张量结果，也会自动默认为 requires_grad=True，这个传导性是 PyTorch 实现自动微分的关键；
"""

import numpy as np
import torch
from torch.utils import data
from d2l import torch as d2l

true_w = torch.tensor([2, -3.4])
true_b = 4.2
features, labels = d2l.synthetic_data(true_w, true_b, 1000)

# is_train 用于控制每次数据迭代时，是否打乱数据
def load_array(data_arrays, batch_size, is_train=True): 
    """构造一个PyTorch数据迭代器"""
    dataset = data.TensorDataset(*data_arrays)
    return data.DataLoader(dataset, batch_size, shuffle=is_train)

batch_size = 10
data_iter = load_array((features, labels), batch_size)

# nn是神经网络的缩写
from torch import nn

# 创建一个全连接层 
net = nn.Sequential(nn.Linear(2, 1)) # 输入的特征形状为 2，输出的特征形状为 1

# 初始化参数，权重均值为 0, 标准差为 0.01
net[0].weight.data.normal_(0, 0.01)
# 偏置 bias 为 1
net[0].bias.data.fill_(0)

# 定义损失函数，使用均方差，它返回的是平均损失值
loss = nn.MSELoss()

# 定义优化算法
trainer = torch.optim.SGD(net.parameters(), lr=0.03)

num_epochs = 3
for epoch in range(num_epochs):
    for X, y in data_iter:
        l = loss(net(X), y)
        trainer.zero_grad() # 清空模型参数的梯度
        l.backward()
        trainer.step()
    l = loss(net(features), labels)
    print(f'epoch {epoch + 1}, loss {1:f}')

import torch
from IPython import display
from d2l import torch as d2l

batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)

num_inputs = 784
num_outputs = 10

# 此处设置参数 requires_grad=True，它会让 PyTorch 自动创建计算图
W = torch.normal(0, 0.01, size=(num_inputs, num_outputs), requires_grad=True)
b = torch.zeros(num_outputs, requires_grad=True)

# 定义概率转化
def softmax(X):
    X_exp = torch.exp(X)
    partition = X_exp.sum(1, keepdim=True)
    return X_exp / partition

# 定义模型（有点特别，相当于先用参数进行仿射，然后做一个 softmax 换算成概率）
def net(X):
    X_reshape = X.reshape((-1, W.shape[0]))
    return softmax(torch.matmul(X_reshape, W) + b)

# 定义损失函数
def cross_entropy(y_hat, y):
    return - torch.log(y_hat[range(len(y_hat)), y])


"""
y_hat[range(len(y_hat)), y] 是一个非常有意思的 Numpy 操作
它表示将 y 的值作为列，从 y_hat 每一行中，取出相应列的值
假设 y_hat 的 值为：
y_hat = [[0.1, 0.3, 0.6],   # 样本0：预测类别2的概率是 0.6
         [0.8, 0.1, 0.1],   # 样本1：预测类别0的概率是 0.8
         [0.2, 0.7, 0.1]]   # 样本2：预测类别1的概率是 0.7
y = [2, 0, 1]

目标：从 y_hat 每一行中分别取第2列、第0列、第1列的值，range(3) 用来表示要取值的行

# y_hat[range(3), y] → [y_hat[0,2], y_hat[1,0], y_hat[2,1]] → [0.6, 0.8, 0.7]
"""

# 定义精度计算函数
def accuracy(y_hat, y):
    if len(y_hat.shape) > 1 and y_hat.shape[1] > 1:
        y_hat = y_hat.argmax(axis=1)
    cmp = y_hat.type(y.dtype) == y
    return float(cmp.type(y.dtype).sum())

# 评估精度
def evaluate_accuracy(net, data_iter):
    if isinstance(net, torch.nn.Module):
        net.eval() # 切换为评估模式
    metric = Accumulator(2)
    with torch.no_grad():
        for X, y in data_iter:
            metric.add(accuracy(net(X), y), y.numel())
    return metric[0] / metric[1]

# 定义累计器，用来存储每次正确预测的数量和总数量，以便后续进行统计
class Accumulator:
    def __init__(self, n):
        self.data = [0.0] * n
        
    def add(self, *args):
        self.data = [a + float(b) for a, b in zip(self.data, args)]
        
    def reset(self):
        self.data = [0.0] * len(self.data)
        
    def __getitem__(self, idx):
        return self.data[idx]

# 定义训练函数（单个 epoch）
def train_epoch_ch3(net, train_iter, loss, updater):
    if isinstance(net, torch.nn.Module):
        net.train() # 切换为训练模式
    metric = Accumulator(3)
    for X, y in train_iter:
        y_hat = net(X) # 前向传播
        l = loss(y_hat, y) # 计算损失，loss 损失函数由于外部传入
        if isinstance(updater, torch.optim.Optimizer):
            updater.zero_grad() # 清零历史梯度
            l.mean().backward() # 反向传播，计算梯度（取平均值）
            updater.step() # 更新参数
        else:
            l.sum().backward() # 反向传播，计算梯度（取和）
            updater(X.shape[0])
        # 累加损失、精度、样本数
        metric.add(float(l.sum()), accuracy(y_hat, y), y.numel())
    # 返回平均损失和准确率
    return metric[0] / metric[2], metric[1] / metric[2]

"""
PyTorch 会自动创建一个计算图，以张量为节点，以操作为边。在模型进行前向传播计算时，框架会自动记录所有涉及张量以及相关操作到计算图中；当调用损失 loss.backward 方法时，会自动触发计算图的反向遍历，根据链式法则，计算参与前向传播计算的张量的梯度；

损失 loss 必须是标量，如果不是，则需要调用 sum 或者 mean 方法进行聚合，以便转成标量；

当使用 PyTorch 的 torch.tensor 方法初始化张量时，如果参数 requires_grad=True，那么它就会自动构建计算图。通过调用  torch.no_grad 方法，可以临时关闭计算图构建功能。

不可微分的操作，例如 argmax 离散操作，会中断梯度链。
"""
"""
updater.zero_grad() # 清零历史梯度
l.mean().backward() # 反向传播，计算梯度（取平均值）
updater.step() # 更新参数
以上这三个操作很有意思，咋一看，backword 和 updater.step 之间并没有参数传递，好像没有什么关系
为什么能够实现参数的更新呢？
原因在于 loss 是计算结果，PyTorch 在背后悄悄维护着计算图，PyTorch 知道这个 loss 是如何一步一步计算出来的。
因此，当调用 backward 时，PyTorch 沿着计算图，计算出每一步的梯度变化，并将变化值存放在每一步涉及的张量的 
grad 属性中。因为权重参数是参与计算的，所以权重参数在 backword 之后，其 grad 属性就被悄悄的赋值了；
而之前 updater 在初始化时，就已经将权重做为参数传进去了，所以 updater 里面关联着待更新的权重参数
当调用 step 方法时，updater 只需执行一下 param = param - lr * param.grad 即可；
"""

# 训练模型
def train_ch3(net, train_iter, test_iter, loss, num_epochs, updater):
    animator = Animator(xlabel='epoch', xlim=[1, num_epochs], ylim=[0.3, 0.9]
                       legend=['train_loss', 'train_acc', 'test_acc'])
    for epoch in range(num_epochs):
        train_metrics = train_epoch_ch3(net, train_iter, loss, updater)
        test_acc = evaluate_accuracy(net, test_iter)
        animator.add(epoch + 1, train_metrics + (test_acc,))
    train_loss, train_acc = train_metrics
    assert train_loss < 0.5, train_loss
    assert train_acc <= 1 and train_acc > 0.7, train_acc
    assert test_acc <= 1 and test_acc > 0.7, test_acc
    
lr = 0.1

# 定义优化器
def updater(batch_size):
    return d2l.sgd([W, b], lr, batch_size)

num_epochs = 10
# 开始训练
loss = cross_entropy # 使用交叉熵做为损失函数
train_ch3(net, train_iter, test_iter, loss, num_epochs, updater)

# 预测
def predict_ch3(net, test_iter, n=6):
    for X, y in test_iter:
        break
    trues = d2l.get_fashion_mnist_labels(y)
    preds = d2l.get_fashion_mnist_labels(net(X).argmax(axis=1))
    titles = [true + '\n' + pred for true, pred in zip(trues, preds)]
    d2l.show_images(X[0:n].reshape((n, 28, 28)), 1, n, titles=titles[0:n])
    
predict_ch3(net, test_iter)

import torch
from torch import nn
from d2l import torch as d2l

batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)

net = nn.Sequential(nn.Flatten(), nn.Linear(784, 10))

def init_weights(m):
    if type(m) == nn.Linear:
        nn.init.normal_(m.weight, std=0.01)
        
net.apply(init_weights)

# reduction='none' 表示不对计算出的损失结果进行聚合，而是直接返回原始值
# 返回原始值有助于对结果进行自定义处理
# 它还有另外两个选项是 mean 和 sum，即求平均和求和
# mean 最常用，因为它使用平均损失，所以梯度的调整会更稳定
# sum 因为加总所有损失，当 batch_size 比较大时，有可能损失特别大，导致梯度爆炸，参数更新步长过大，训练不稳定
# sum 适用于一些特定的任务，例如序列生成、变长的输入序列、比较小的 batch_size 等场景；
loss = nn.CrossEntropyLoss(reduction='none')

# 定义优化算法（参数优化器）
trainer = torch.optim.SGD(net.parameters(), lr=0.1)

num_epochs = 10
# 开始训练
d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, trainer)

import torch
from torch import nn
from d2l import torch as d2l

batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)

"""
此处输入为 784, 输出为 10, 隐藏单元的数量为 256（一般选择 2 的幂次，以便能够更高效的使用内存）
"""
num_inputs, num_outputs, num_hiddens = 784, 10, 256

# 由于多了一个隐藏层，因此现在有两套参数了，一套用于线性变换，一套用于激活

# 参数一
W1 = nn.Parameter(torch.randn(num_inputs, num_hiddens, requires_grad=True) * 0.01)
b1 = nn.Parameter(torch.zeros(num_hiddens, requires_grad=True))

# 参数二
W2 = nn.Parameter(torch.randn(num_hiddens, num_outputs, requires_grad=True) * 0.01)
b2 = nn.Parameter(torch.zeros(num_outputs, requires_grad=True))

params = [W1, b1, W2, b2]

# 手工实现激活函数
def relu(X):
    a = torch.zeros_like(X)
    return torch.max(X, a)

# 此处将 28×28 的二维图片，展成了一维的向量，尺寸为
def net(X):
    X = X.reshape((-1 ,num_inputs))
    H = relu(X@W1 + b1) # @ 代表矩阵乘法
    return (H@W2 + b2)

# 使用交叉熵做为损失函数
loss = nn.CrossEntropyLoss(reduction='none')

# 训练过程跟 softmax 回归没有区别
num_epochs, lr = 10, 0.1
updater = torch.optim.SGD(params, lr=lr)
d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, updater)

import torch
from torch import nn
from d2l import torch as d2l

"""
之前的 softmax 模型是这样子的：
net = nn.Sequential(nn.Flatten(), nn.Linear(784, 10))
现在相当于在中间加了两层，一层是 nn.Linear(784, 256), 一层是 nn.ReLU()
"""
net = nn.Sequential(nn.Flatten(),
                    nn.Linear(784, 256),
                    nn.ReLU(),
                    nn.Linear(256, 10))

def init_weights(m):
    if type(m) == nn.Linear:
        nn.init.normal_(m.weight, std=0.01)

net.apply(init_weights);

# 训练过程和 softmax 没有区别
batch_size, lr, num_epochs = 256, 0.1, 10
loss = nn.CrossEntropyLoss(reduction='none')
trainer = torch.optim.SGD(net.parameters(), lr=lr)

train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)
d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, trainer)

import math
import numpy as np
import torch
from torch import nn
from d2l import torch as d2l

max_degree = 20  # 多项式的最大阶数
n_train, n_test = 100, 100  # 训练和测试数据集大小
true_w = np.zeros(max_degree)  # 20个系数初始化为零
true_w[0:4] = np.array([5, 1.2, -3.4, 5.6]) # 前4个系数，其他系数为 0
# 因此看似有20阶，但实际上3阶多项式，阶数搞这么多，主要是为了用高阶来拟合，演示过拟合问题

# 生成 200 个服从标准正态分布的随机输入值
features = np.random.normal(size=(n_train + n_test, 1))
np.random.shuffle(features)
# 构造多项式特征矩阵
poly_features = np.power(features, np.arange(max_degree).reshape(1, -1))
# 特征归一化：除以阶乘(不然有些高阶项会超级大，导致数值爆炸)
for i in range(max_degree):
    poly_features[:, i] /= math.gamma(i + 1)  # gamma(n)=(n-1)!
# labels的维度:(n_train+n_test,)
labels = np.dot(poly_features, true_w) # 生成多项式
labels += np.random.normal(scale=0.1, size=labels.shape) # 添加高斯噪声

# NumPy ndarray转换为tensor
true_w, features, poly_features, labels = [torch.tensor(x, dtype=
torch.float32) for x in [true_w, features, poly_features, labels]]

def evaluate_loss(net, data_iter, loss):  #@save
    """评估给定数据集上模型的损失"""
    metric = d2l.Accumulator(2)  # 损失的总和,样本数量
    for X, y in data_iter:
        out = net(X)
        y = y.reshape(out.shape)
        l = loss(out, y)
        metric.add(l.sum(), l.numel())
    return metric[0] / metric[1]

# 训练
def train(train_features, test_features, train_labels, test_labels,
          num_epochs=400):
    loss = nn.MSELoss(reduction='none')
    input_shape = train_features.shape[-1]
    # 不设置偏置，因为我们已经在多项式中实现了它
    net = nn.Sequential(nn.Linear(input_shape, 1, bias=False))
    batch_size = min(10, train_labels.shape[0])
    train_iter = d2l.load_array((train_features, train_labels.reshape(-1,1)),
                                batch_size)
    test_iter = d2l.load_array((test_features, test_labels.reshape(-1,1)),
                               batch_size, is_train=False)
    trainer = torch.optim.SGD(net.parameters(), lr=0.01)
    animator = d2l.Animator(xlabel='epoch', ylabel='loss', yscale='log',
                            xlim=[1, num_epochs], ylim=[1e-3, 1e2],
                            legend=['train', 'test'])
    for epoch in range(num_epochs):
        d2l.train_epoch_ch3(net, train_iter, loss, trainer)
        if epoch == 0 or (epoch + 1) % 20 == 0:
            animator.add(epoch + 1, (evaluate_loss(net, train_iter, loss),
                                     evaluate_loss(net, test_iter, loss)))
    print('weight:', net[0].weight.data.numpy())

# 从多项式特征中选择前4个维度,即1,x,x^2/2!,x^3/3!
train(poly_features[:n_train, :4], poly_features[n_train:, :4],
labels[:n_train], labels[n_train:])

# 从多项式特征中选择前2个维度,即1和x
train(poly_features[:n_train, :2], poly_features[n_train:, :2],
labels[:n_train], labels[n_train:])

# 从多项式特征中选取所有维度
train(poly_features[:n_train, :], poly_features[n_train:, :],
labels[:n_train], labels[n_train:], num_epochs=1500)

import torch
from torch import nn
from d2l import torch as d2l

"""
样本数非常小，只有 20 个样本
输入的维数（特征数）非常多，有 200 个
"""
n_train, n_test, num_inputs, batch_size = 20, 100, 200, 5
"""
合成数据的权重为 0.01，偏置为 0.05, 通常合成的时候还会添加噪声
公式示例：y = X @ true_w + true_b + noise
"""
true_w, true_b = torch.ones((num_inputs, 1)) * 0.01, 0.05 
train_data = d2l.synthetic_data(true_w, true_b, n_train)
train_iter = d2l.load_array(train_data, batch_size)
test_data = d2l.synthetic_data(true_w, true_b, n_test)
test_iter = d2l.load_array(test_data, batch_size, is_train=False)

def init_params():
    w = torch.normal(0, 1, size=(num_inputs, 1), requires_grad=True)
    b = torch.zeros(1, requires_grad=True)