如何使用也以神经网络的前一层为食的输入层？

Question

Let's say I want to predict the winner of a tag-team race, where some drivers are more usually place higher in certain weather conditions:

Race   |Driver | Weather | Time
Dummy1 |D1     | Rain    | 2:00
Dummy1 |D2     | Rain    | 5:00
Dummy1 |D3     | Rain    | 4:50
Dummy2 |D1     | Sunny   | 3:00
Dummy2 |D2     | Sunny   | 2:50
Dummy2 |D2     | Sunny   | 2:30
...

The logic is that a team composed of D1 and D3 would outperform any other combination on Rain, but wouldn't have the same luck on other weather. With that said, I thought about the following model:

Layer 1          |   Layer 2             | Layer 3 (output)
Driver encoding  | weather encoding      | expected race time
----------------------------------------------------------------
Input of 0 or 1  | sum(Layer 1 * weights | sum(Layer 2 * weights)
                 |  * Input of 0 or 1)   | 

This means that layer 2 uses layer 1 as well as input values to compute a value. The reason I want this architecture instead of having every feature on layer 1 is that I want different features to multiply each other instead of their sum.

I could not find anything like this, but it is probably just me not knowing the name of this approach. Can someone point me to sources or explain know how to replicate this on tensorflow/pytorch/any other lib?

Answer 1

Turns out it was actually pretty simple, for anyone that might stumble upon this post and would like to test this approach, here's rough code:

Racing dataset

#         TEAM 1                TEAM 2                 "Weather"    "WON"
#         "A","B","C","D","E",  "A","B","C","D","E",   W1   W2  W3  (combined times of team 1< combined times of team 2) 
dataset=[[ 1,  1,  0,  0,  0,    0,  0,  1,  1,  0,    1,   0,  0,          1],
         [ 1,  1,  0,  0,  0,    0,  0,  1,  0,  1,    1,   0,  0,          1],
         [ 1,  1,  0,  0,  0,    0,  0,  0,  1,  1,    1,   0,  0,          1],
         [ 1,  0,  1,  0,  0,    0,  1,  0,  1,  0,    1,   0,  0,          1],
         [ 1,  0,  1,  0,  0,    0,  0,  0,  1,  1,    1,   0,  0,          0],
         [ 1,  1,  0,  0,  0,    0,  0,  0,  1,  1,    0,   1,  0,          0],
         [ 1,  1,  0,  0,  0,    0,  0,  1,  1,  0,    0,   1,  0,          0],
         [ 1,  1,  0,  0,  0,    0,  0,  1,  0,  1,    0,   1,  0,          0],
         [ 1,  0,  0,  0,  1,    0,  0,  1,  1,  0,    0,   1,  0,          0],
         [ 0,  1,  1,  0,  0,    0,  0,  0,  1,  1,    0,   1,  0,          1],
        ]

inputs=[[x[0:-4],x[-4:-1]] for x in dataset]
results=[[x[-1]] for x in dataset]

Typings to make code more readable

from typing import Iterator

class InputLayer():
    def __init__(self, inputs,useBias=False):
        self.inputs=inputs
        self.useBias=useBias

    def __str__(self):
        return "Layer of size "+ str(self.inputs)
    def __repr__(self) -> str:
        return self.__str__()

class InputLayerValue():
    def __init__(self, values):
        self.values=np.array(values)

Actual model

import torch
from torch import nn
class MutipleInputModel(nn.Module):
    def __init__(self,input_layers:Iterator[InputLayer],output_size):
        super(MutipleInputModel, self).__init__()
        print(input_layers)
        self.nns=[]
        
        for i in range(len(input_layers)-1):
            current:InputLayer=input_layers[i]
            next:InputLayer=input_layers[i+1]
            il=nn.Linear(current.inputs,next.inputs,current.useBias)
            #To have hidden layers, you need to either use another model or create and attach multiple Linear models - nn.Linear(next.inputs,next.inputs)
            name="nn"+str(i)
            #models must be directly under self to be found by model.parameters()
            self.__setattr__(name,il)
            self.nns.append(name)
            
        il=nn.Linear(input_layers[-1].inputs,output_size,current.useBias)
        name="nnOutput"
        self.__setattr__(name,il)
        self.nns.append(name)

    def forward(self, inputs:Iterator[InputLayerValue]):
        inputsLen=len(inputs[0])
        if inputsLen != len(self.nns):
            raise Exception("Number of input values provided and input layers must be equal. Provided "+str(inputsLen)+" sets of inputs for a "+str(len(self.nns))+"-input-layer network")

        #Initialize first layer of inputs with ones which will then be multiplied by the actual input values
        lastOutput=torch.ones(len(inputs),len(inputs[0][0].values))                             # Layer 1 Outputs | Layer 2 provided Inputs | Layer 2 actual Inputs
        for i in range(inputsLen):                                                              #    lastOutput   |      multiplier         |     input
            multiplier=torch.from_numpy(np.array([x[i].values for x in inputs])).float()        #       0.2       |         0               |       0
            input=lastOutput*multiplier                                                         #       1.5       |         1               |      1.5
            lastOutput=self.__getattr__(self.nns[i])(input)                                     #       1.0       |         5               |       5 

        return lastOutput

Training

# Define hyperparameters
model = MutipleInputModel(input_layers=[InputLayer(len(x)) for x in inputs[0]],output_size=1)
n_epochs = 1000
lr=0.001
criterion = nn.BCEWithLogitsLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=lr)

for epoch in range(1, n_epochs + 1):
    optimizer.zero_grad() # Clears existing gradients from previous epoch
    output = model([[InputLayerValue(y) for y in x] for x in inputs])
    loss = criterion(output, torch.from_numpy(np.array(results)).float())
    loss.backward()
    optimizer.step() 
    
    print('Epoch: {}/{}.............'.format(epoch, n_epochs), end=' ')
    print("Loss: {:.4f}".format(loss.item()))

Testing:

def predict(model, input):
    input = [[InputLayerValue(y) for y in input]]
    out = model(input)
    return nn.Sigmoid()(out[0][0]).item()

print(predict(model,[[1, 1, 0, 0, 0, 0, 0, 1, 1, 0], [1, 0, 0]]))
print(predict(model,[[1, 1, 0, 0, 0, 0, 0, 1, 1, 0], [0, 1, 0]]))
print(predict(model,[[1, 1, 0, 0, 0, 0, 0, 1, 1, 0], [0, 0, 1]]))

This is a really basic implementation, but could easily be modified to have hidden layers.

Clearly needs further testing to see if it is actually better than a traditional NN, but I would say it is great for NN explainability.