帮我伪生成斜率为正的训练集和验证集的精确度曲线。要求epoch=100，精确度由0.75缓慢上升到0.86结束，加入很小的白噪声，训练集的白噪声较小；训练集的精确度要稍微高于验证集

好的，我可以为您提供一个基本的代码框架，您可以在此基础上进行修改和调整以满足您的具体需求。

首先，我们需要生成训练集和验证集数据。根据您的要求，我们可以使用斜率为正的线性函数 y = kx + b，并加入一些白噪声来模拟真实场景。为了使训练集的白噪声较小，我们可以将噪声的标准差设为一个较小的值，例如0.1。

接下来，我们可以使用PyTorch框架来构建神经网络模型，并定义损失函数和优化器。为了使训练集的精确度稍微高于验证集，我们可以使用Dropout随机丢弃部分神经元来降低过拟合的风险。

最后，我们可以在训练过程中记录训练集和验证集的精确度，并绘制精确度曲线图。

下面是一个示例代码框架：

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt

# 生成数据
def generate_data(num_samples, noise_std):
    np.random.seed(42)
    x = np.random.uniform(-10, 10, size=(num_samples, 1))
    y = 2 * x + 3 + np.random.normal(0, noise_std, size=(num_samples, 1))
    return x, y

# 构建模型
class Net(nn.Module):
    def __init__(self, dropout_prob):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(1, 64)
        self.dropout1 = nn.Dropout(p=dropout_prob)
        self.fc2 = nn.Linear(64, 64)
        self.dropout2 = nn.Dropout(p=dropout_prob)
        self.fc3 = nn.Linear(64, 1)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.dropout1(x)
        x = torch.relu(self.fc2(x))
        x = self.dropout2(x)
        x = self.fc3(x)
        return x

# 定义训练函数
def train(model, optimizer, criterion, x_train, y_train):
    model.train()
    running_loss = 0.0
    correct = 0
    total = 0
    for i in range(len(x_train)):
        inputs = torch.tensor(x_train[i], dtype=torch.float32).unsqueeze(0)
        labels = torch.tensor(y_train[i], dtype=torch.float32).unsqueeze(0)
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
        total += labels.size(0)
        correct += (torch.abs(outputs - labels) < 0.1).sum().item()
    epoch_loss = running_loss / len(x_train)
    epoch_acc = correct / total
    return epoch_loss, epoch_acc

# 定义验证函数
def validate(model, criterion, x_val, y_val):
    model.eval()
    running_loss = 0.0
    correct = 0
    total = 0
    with torch.no_grad():
        for i in range(len(x_val)):
            inputs = torch.tensor(x_val[i], dtype=torch.float32).unsqueeze(0)
            labels = torch.tensor(y_val[i], dtype=torch.float32).unsqueeze(0)
            outputs = model(inputs)
            loss = criterion(outputs, labels)
            running_loss += loss.item()
            total += labels.size(0)
            correct += (torch.abs(outputs - labels) < 0.1).sum().item()
    epoch_loss = running_loss / len(x_val)
    epoch_acc = correct / total
    return epoch_loss, epoch_acc

# 主函数
def main():
    # 设置随机种子
    np.random.seed(42)
    torch.manual_seed(42)

    # 生成数据
    x_train, y_train = generate_data(1000, 0.1)
    x_val, y_val = generate_data(100, 0.1)

    # 构建模型
    model = Net(dropout_prob=0.2)

    # 定义损失函数和优化器
    criterion = nn.MSELoss()
    optimizer = optim.Adam(model.parameters(), lr=0.001)

    # 训练模型
    num_epochs = 100
    train_losses, train_accs = [], []
    val_losses, val_accs = [], []
    for epoch in range(num_epochs):
        train_loss, train_acc = train(model, optimizer, criterion, x_train, y_train)
        val_loss, val_acc = validate(model, criterion, x_val, y_val)
        train_losses.append(train_loss)
        train_accs.append(train_acc)
        val_losses.append(val_loss)
        val_accs.append(val_acc)
        print('Epoch [{}/{}], Train Loss: {:.4f}, Train Acc: {:.4f}, Val Loss: {:.4f}, Val Acc: {:.4f}'
              .format(epoch+1, num_epochs, train_loss, train_acc, val_loss, val_acc))

    # 绘制精确度曲线图
    plt.plot(train_accs, label='Train Acc')
    plt.plot(val_accs, label='Val Acc')
    plt.xlabel('Epoch')
    plt.ylabel('Accuracy')
    plt.ylim(0.7, 0.9)
    plt.legend()
    plt.show()

if __name__ == '__main__':
    main()

您可以根据需要调整超参数，例如噪声标准差、Dropout概率、学习率等，以达到最佳效果。