速通深度学习（1）：构建数据训练任务（A）

（0）分类任务集：

     MNIST：50000 张 图片，每张图规格：28 x 28 x 1 ~ 其中 1 是颜色通道

   

    One-Hot_Encoding：返回一列标签分布的概率值 : 比方说5 ~ [0,0,0,0,1,0,0,0,0,0]

    

  784  x 128 ~ 128 x10 ~ 10 x 1  => 784：Dim_Input, 128：Dim_Hidden，10：Dim_Predicted

（1）利用Model建立模型：

     * 继承：

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

dim_input = 784
dim_hidden1 = 128
dim_hidden2 = 256
dim_output = 10

class NN (nn.Module):
    # 从 nn.Module 继承类函数
    def __init__(self):
        super().__init__()
       # 定义父类
        self.hidden1 = nn.Linear(dim_input,dim_hidden1)
        self.hidden2 = nn.Linear(dim_hidden1,dim_hidden2)
        self.out = nn.Linear(dim_hidden2,dim_output)
        

     * 向前传播（Forward）：

    def forward(self,x):
       # 调用 F 模块下的函数 relu
        x = F.relu(self.hidden1(x))
       # 直接作用在每个层的返回向量上面
        x = F.relu(self.hidden2(x)) 
        x = self.out(x)
        return x

net = nn()
# 建立 net 实例
print(net)
# 打印 net 参数

（2）使用 TensorDataset 和 DataLoader 来读取数据：

    * 产生 x_train,y_train：读取MNIST

    * 对 x_train,y_train读取数据

from torch.utils.data import TensorDataset
from torch.utils.data import DataLoader

batch_size = 64

train_dataset = TensorDataset(x_train, y_train)
valid_dataset = TensorDataset(x_train, y_train)

train_dataloader = DataLoader(train_dataset, batch_size = batchsize, shuffle = True)
valid_dataloader = DataLoader(valid_dataset, batch_size = batchsize*2 )

（3）加载-模型的 训练和优化：

from torch import optim

lr = 2e-3

loss_func = F.cross_entropy
    
def get_model():
    model = NN()
    # 实例化model,opt
    return model, optim.SGD(model.parameters(), lr = lr)

def loss_batch(model, loss_func, xb, yb, opt = None):
    loss = loss_func(model(xb),yb)
    # 调用opt并_更新_并_清除_梯度缓存
    if opt is not None:
        loss.backward()
        opt.step()
        opt.zero_grad()
    # len(xb) 被设计于 后文统计总规模，以求迄今为止的平均loss
    # 貌似都是 0 阶张量 (数)
    return loss.item(),len(xb)


def fit(steps, model, loss_func, opt, train_dataLoader, valid_dataLoader):
    
    for step in range(steps):
        # 不知道 model.train()有什么用
        model.train()
        for xb,yb in train_dataLoader:
            loss_batch(model, loss_func, xb, yb, opt)
        # 不知道 model.eval()有什么用
        modal.eval()
        with torch.no_grad():
            losses,nums = zip(
            *[loss_batch(model, loss_func, xb, yb, opt) for xb,yb in valid_dataLoader]
            # 解压缩
              )
    
        val_loss = np.sum(np.multiply(losses,nums)/np.sum(nums))
        print('\Current step:',step,'\with vaildation Loss:', val_loss)

    * 调用函数

if __name__ == '__main__':
    model, opt = get_model()
    fit(25, model, loss_func, opt, train_dataLoader, vaild_dataLoader)