paddle百度飞桨，一个简单神经网络，完成模型搭建的全流程

# -*- coding: UTF-8 -*-
"""
@项目名称：Delete.py
@作   者：陆地起飞全靠浪
@创建日期：2022-07-20-09:04
"""
from paddle import nn

class NN(nn.Layer):
    def __init__(self, nc=4):
        super(NN, self).__init__()
        self.fceq = nn.Linear(1000, 1000)
        self.fc = nn.Linear(1000, nc)
        self.act = nn.LeakyReLU()
        self.soft = nn.Softmax()

    def forward(self, x):
        x = self.fceq(x)
        x = self.act(x)
        x = self.fceq(x)
        x = self.act(x)

        x = self.fc(x)
        x = self.soft(x)
        return x


import os
import numpy as np
from glob import glob
from paddle.io import Dataset

class GetData(Dataset):
    def __init__(self, data_dir):
        super(GetData, self).__init__()
        self.data_list = glob(os.path.join(data_dir, '/*'))

    def __getitem__(self, item):
        data_path = self.data_list[item]
        x = np.load(data_path)
        label = int(os.path.basename().split("_")[0])  # label_time.time()
        return x, np.array([label])


import paddle
from paddle.io import DataLoader

def train(isNew=True):
    loss = paddle.nn.loss.CrossEntropyLoss(soft_label=True)
    if isNew:
        model = NN(10)
        opt = paddle.optimizer.Adam(learning_rate=0.01, parameters=model.parameters())
    else:
        # 继续训练
        model = paddle.load("model.pdmodel")

        layer_state_dict = paddle.load("model.pdparams")
        model.set_state_dict(layer_state_dict)

        opt = paddle.optimizer.Adam(learning_rate=0.01, parameters=model.parameters())
        opt_state_dict = paddle.load("model.pdopt")
        opt.set_state_dict(opt_state_dict)
    model.train()
    get_data = GetData("./")
    data_loader = DataLoader(get_data, batch_size=3, shuffle=True)
    for _ in range(300):
        for x, y in data_loader:
            out = model(x)
            t_loss = loss(out, y)
            t_loss.backward()
            opt.step()
            opt.clear_grad()
            if t_loss < 10:
                paddle.save(model, "model.pdmodel")
                paddle.save(model.state_dict, "model.pdparams")
                paddle.save(opt.state_dict(), 'model.pdopt')

def predict(x):
    model = NN(10)
    model.eval()
    layer_state_dict = paddle.load("model.pdparams")
    model.set_state_dict(layer_state_dict)
    y = model(x)