Keras Sequential model with multiple inputs

I am making a MLP model which takes two inputs and produces a single output.

I have two input arrays (one for each input) and 1 output array. The neural network has 1 hidden layer with 2 neurons. Each array has 336 elements.

model0 = keras.Sequential([
keras.layers.Dense(2, input_dim=2, activation=keras.activations.sigmoid, use_bias=True),
keras.layers.Dense(1, activation=keras.activations.relu, use_bias=True),

# Compile the neural network #
    optimizer = keras.optimizers.RMSprop(lr=0.02,rho=0.9,epsilon=None,decay=0),
    loss = 'mean_squared_error',

I tried two ways, both of them are giving errors.[array_1, array_2]),output, batch_size=16, epochs=100)

ValueError: Error when checking input: expected dense_input to have shape (2,) but got array with shape (336,)

The second way:[array_1, array_2],output, batch_size=16, epochs=100)

ValueError: Error when checking model input: the list of Numpy arrays that you are passing to your model is not the size the model expected. Expected to see 1 array(s), but instead got the following list of 2 arrays:

Similar question. But not using sequential model.

Here is Solutions:

We have many solutions to this problem, But we recommend you to use the first solution because it is tested & true solution that will 100% work for you.

Solution 1

To solve this problem you have two options.

1. Using a sequential model

You can concatenate both arrays into one before feeding to the network. Let’s assume the two arrays have a shape of (Number_data_points, ), now the arrays can be merged using numpy.stack method.

merged_array = np.stack([array_1, array_2], axis=1)

model0 = keras.Sequential([
keras.layers.Dense(2, input_dim=2, activation=keras.activations.sigmoid, use_bias=True),
keras.layers.Dense(1, activation=keras.activations.relu, use_bias=True),
]),output, batch_size=16, epochs=100)

2. Using Functional API.

This is the most recommened way to use when there are multiple inputs to the model.

input1 = keras.layers.Input(shape=(1, ))
input2 = keras.layers.Input(shape=(1,))
merged = keras.layers.Concatenate(axis=1)([input1, input2])
dense1 = keras.layers.Dense(2, input_dim=2, activation=keras.activations.sigmoid, use_bias=True)(merged)
output = keras.layers.Dense(1, activation=keras.activations.relu, use_bias=True)(dense1)
model10 = keras.models.Model(inputs=[input1, input2], output=output)

Now you can use the second method you have trying to fit to the model[array_1, array_2],output, batch_size=16, epochs=100)

Solution 2

As in the answer you’ve linked, you cant be using the Sequential API for the stated reason. You should use Model API which is also called the functional API. Architecturally, you need to define to the model how you’ll combine the inputs with the Dense layer ie how you want to create the intermediate layer viz. merge/add or subtract etc/construct a embedding layer etc), or maybe you want to have 2 neural networks, 1 for each input and only want to combine the output in the last layer. The code for each of the above will vary.

Here’s a working solution assuming you want to merge the inputs into a vector of shape 672 and then construct a neural network on that input:

import tensorflow as tf
from tensorflow.keras.layers import *
from tensorflow.keras.models import Sequential, Model
from tensorflow.keras.optimizers import Adam, RMSprop
import numpy as np

input1 = Input(shape=(336,))
input2 = Input(shape=(336,))
input = Concatenate()([input1, input2])
x = Dense(2)(input)
x = Dense(1)(x)
model = Model(inputs=[input1, input2], outputs=x)

You’ll notice that this model merges or concatenates the two inputs and then constructs a neural network on top of that:

Layer (type)                    Output Shape         Param #     Connected to                     
input_1 (InputLayer)            (None, 336)          0                                            
input_2 (InputLayer)            (None, 336)          0                                            
concatenate (Concatenate)       (None, 672)          0           input_1[0][0]                    
dense (Dense)                   (None, 2)            1346        concatenate[0][0]                
dense_1 (Dense)                 (None, 1)            3           dense[0][0]                      
Total params: 1,349
Trainable params: 1,349
Non-trainable params: 0

If you have some other preferred way to create the intermediate layer, you should replace the Concatenate line with that in the code.

You can then compile and fit the model:

    optimizer = RMSprop(lr=0.02,rho=0.9,epsilon=None,decay=0),
    loss = 'mean_squared_error'

x1, x2 = np.random.randn(100, 336),np.random.randn(100, 336,)
y = np.random.randn(100, 1)[x1, x2], y)

Solution 3

The above solutions contain the recommended approach but I still got some errors.
So I tried the following.

for count in range (len(array_1)):
    input_array[count][0] = array_1[count]
    input_array[count][1] = array_2[count]

Both Array_1 and Array_2 were the same length.

And then created and compiled the model as before.

Finally for training, I used:, output_array, batch_size=16, epochs=100, verbose=0)

This approach worked for me.

Note: Use and implement solution 1 because this method fully tested our system.
Thank you 🙂

All methods was sourced from or, is licensed under cc by-sa 2.5, cc by-sa 3.0 and cc by-sa 4.0

Leave a Reply