Question

这可能不是问这个问题的最佳地点，但我真的很努力。我想创建一个具有2个输入，3个隐藏的神经元和1个输出的“平凡”神经网络。这个想法是我们给它提供两个布尔值，然后输出AND结果。

我想以某种“常规”方式进行操作（我对pytorch还是很陌生）。我使用的学习率是0.001的亚当优化器和nll_loss函数（尽管我需要更改它，因为我只需要1个输出，并且这需要输出的数量与类的数量相匹配-在这种情况下为1和0）

我知道这应该是一个微不足道的问题，但我确实很挣扎，在Google上找不到任何有用的东西。

Answer 1

使用您的训练数据制作一个.csv文件。

x1  x2  label
TRUE    FALSE   FALSE
TRUE    TRUE    TRUE
FALSE   FALSE   FALSE
FALSE   TRUE    FALSE

创建数据集类。

class boolData(Dataset):
    def __init__(self, csv_path):
        self.label = pd.read_csv(csv_path)

    def __len__(self):
        return len(self.label)

    def __getitem__(self, idx):
        sample = torch.tensor(self.label.iloc[idx,0:2]).int()
        label = torch.tensor(self.label.iloc[idx,2]).int()
        return sample, label

tensor_dataset = boolData(csv_path='sample_bool_stack.csv')

boolDL = DataLoader(tensor_dataset, batch_size=4, shuffle=True)

batch, labels = next(iter(boolDL))

batch, labels

(tensor([[1, 0],
         [1, 1],
         [0, 1],
         [0, 0]], dtype=torch.int32), tensor([0, 1, 0, 0], dtype=torch.int32))

初始化嵌入。

def _emb_init(x):
    x = x.weight.data
    sc = 2/(x.size(1)+1)
    x.uniform_(-sc,sc)

模型将True，False转换为整数，并将总和作为输入。编辑：仅输出单个神经元。

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.emb = nn.Embedding(3, 2)
        _emb_init(self.emb)
        self.fc1 = nn.Linear(2, 10)
        self.fc2 = nn.Linear(10, 1)

    def forward(self, x):
        x = torch.sum(x, dim=1)
        x = self.emb(x)
        x = self.fc1(x)
        x = F.relu(x)
        x = self.fc2(x)
        return x

初始化模型，优化器和损失函数。编辑：更改损耗以匹配单个神经元输出。

model = Net()
opt = optim.SGD(model.parameters(), lr=1e-3)
loss_func = nn.BCEWithLogitsLoss()
num_epochs = 10000

device = "cpu"

火车模型。

for epoch in range(num_epochs):
    for i,(inputs, labels) in enumerate(boolDL):
        inputs = inputs.to(device).long()
        labels = labels.to(device).float()

        opt.zero_grad()

        output = model(inputs)
        loss = loss_func(output.view(-1), labels)
        loss.backward()
        opt.step()
        with torch.no_grad():
            if epoch % 2000 == 0: print(loss.item())

0.004416308831423521
0.002891995944082737
0.004371378570795059
0.0017852336168289185

测试模型。

inputs = torch.tensor([[0,0],[0,1],[0,0]])

def check_model(inputs):
    out = model(inputs)
    preds = torch.sigmoid(out).round()
    return preds.detach().numpy()

check_model(inputs)

array([[0.],
       [0.],
       [0.]], dtype=float32)

神经网络的位运算和

1 个答案: