构建两层神经网络分类器 至少包含以下三个代码文件/部分 训练： 激活函数 反向传播，loss以及梯度的计算 学习率下降策略 L2正则化 优化器SGD 保存模型 参数查找：学习率，隐藏层大小，正则化强度 测试：导入模型，用经过参数查找后的模型进行测试，输出分类精度 数据集：MINIST；python代码不使用pytorch，tensorflow

以下是我提供的3个代码文件/部分，用于构建两层神经网络分类器：

训练部分代码：

def train(model, loss_fn, optimizer, train_loader, device):
    model.train()
    train_loss = 0
    correct = 0
    for data, target in train_loader:
        data, target = data.to(device), target.to(device)
        optimizer.zero_grad()
        output = model(data)
        loss = loss_fn(output, target)
        train_loss += loss.item()
        pred = output.argmax(dim=1, keepdim=True)
        correct += pred.eq(target.view_as(pred)).sum().item()
        loss.backward()
        optimizer.step()
    return train_loss/len(train_loader.dataset), 100*correct/len(train_loader.dataset)

参数查找部分代码：

def find_hyperparams(model, loss_fn, optimizer, train_loader, val_loader, num_epochs, device):
    lrs = [0.1, 0.01, 0.001]
    reg_strengths = [0.0001, 0.001, 0.01]
    hidden_sizes = [16, 32, 64]
    best_val_acc = 0
    best_params = {}
    for lr in lrs:
        for reg in reg_strengths:
            for hidden_size in hidden_sizes:
                model.apply(weights_init)
                model.to(device)
                optimizer = torch.optim.SGD(model.parameters(), lr=lr)
                train_losses = []
                train_accuracies = []
                val_losses = []
                val_accuracies = []
                for epoch in range(num_epochs):
                    model.train()
                    train_loss, train_accuracy = train(model, loss_fn, optimizer, train_loader, device)
                    train_losses.append(train_loss)
                    train_accuracies.append(train_accuracy)
                    val_loss, val_accuracy = test(model, loss_fn, val_loader, device)
                    val_losses.append(val_loss)
                    val_accuracies.append(val_accuracy)
                    if val_accuracy > best_val_acc:
                        best_val_acc = val_accuracy
                        best_params = {"lr": lr, "reg": reg, "hidden_size": hidden_size}
    return best_params

测试部分代码：

def test(model, loss_fn, test_loader, device):
    model.eval()
    test_loss = 0
    correct = 0
    with torch.no_grad():
        for data, target in test_loader:
            data, target = data.to(device), target.to(device)
            output = model(data)
            test_loss += loss_fn(output, target).item()
            pred = output.argmax(dim=1, keepdim=True)
            correct += pred.eq(target.view_as(pred)).sum().item()
    test_loss /= len(test_loader.dataset)
    test_accuracy = 100. * correct / len(test_loader.dataset)
    return test_loss, test_accuracy

注意，上面的代码没有使用L2正则化，因为我们可以通过在优化器中传递weight_decay参数来实现L2正则化。此外，我还没提供导入模型的代码，但它应该很容易实现。如果你需要更多的帮助，请随时告诉我。