I seem to have some problems starting my learning... I am not sure why.. 
the network is multi input (72 1d arrays) and output is a 1d array length 24. the 1d array output consist of numbers related to 145 different classes. 

So: 72 inputs => 24 outputs

Minimal working example - without the input/output being set. 

```
import keras
from keras.utils import np_utils
from keras import metrics
from keras.models import Sequential
from keras.layers.core import Dense, Activation, Lambda, Reshape,Flatten
from keras.layers import Conv1D,Conv2D, MaxPooling2D, MaxPooling1D, Reshape, ZeroPadding2D
from keras.utils import np_utils
from keras.layers.advanced_activations import LeakyReLU, PReLU
from keras.layers.advanced_activations import ELU
from keras.models import Model
from keras.layers import Input, Dense
from keras.layers import Dropout
from keras import backend as K
from keras.callbacks import ReduceLROnPlateau
from keras.callbacks import CSVLogger
from keras.callbacks import EarlyStopping
from keras.models import load_model
from keras.layers.merge import Concatenate
import numpy as np

def chunks(l, n):
    """Yield successive n-sized chunks from l."""
    for i in range(0, len(l), n):
        yield l[i:i + n]

nano_train_input = []
nano_train_output = []
nano_test_input = []
nano_test_output = []

##   Creating train input:
for i in range(974):
    nano_train_input.append(np.random.random((78,684,4)))
    nano_train_output.append(np.random.randint(145,size=(228)).tolist())

##   Creating test input:
for i in range(104):
    nano_test_input.append(np.random.random((78,684,4)))
    nano_test_output.append(np.random.randint(145,size=(228)).tolist())

def model(train_input, train_output, test_input, test_output, names=0):

    #   Paper uses dimension (40 x 45 =(15 * 3))
    #   Filter size 5
    #   Pooling size
    #   I use dimension (78  x 72 = (24 * 3)
    #   Filter size 9

    print "In model"
    i = 0
    print_once = True
    data_test_output = []
    data_test_input = []
    for matrix in test_input:
        row,col,channel = matrix.shape
        remove_output = (col/3)%24
        remove_input  = col%72
        if remove_output > 0 :
            test_output[i] = test_output[i][:-(remove_output)]
        for split in chunks(test_output[i],24):
            data_test_output.append(np.array(split))
        if remove_input > 0:
            out = np.split(matrix[:,:-(remove_input),:-1],matrix[:,:-(remove_input),:-1].shape[1]/72,axis=1)
        else:
            out = np.split(matrix[:,:,:-1],matrix[:,:,:-1].shape[1]/72,axis=1)
        data_test_input.extend(out)
        del out
        i=i+1 # Increment

    i=0
    data_train_output = []
    data_train_input = []
    for matrix in train_input:
        row,col,channel = matrix.shape
        remove_output = (col/3)%24
        remove_input  = col%72
        if remove_output > 0 :
            train_output[i] = train_output[i][:-(remove_output)]
        for split in chunks(train_output[i],24):
            data_train_output.append(np.array(split))
        if remove_input > 0:
            out = np.split(matrix[:,:-(remove_input),:-1],matrix[:,:-(remove_input),:-1].shape[1]/72,axis=1)
        else:
            out = np.split(matrix[:,:,:-1],matrix[:,:,:-1].shape[1]/72,axis=1)
        data_train_input.extend(out)
        del out
        i=i+1 # Increment

    print
    print "Len:"
    print len(data_train_input)
    print len(data_train_output)
    print len(data_test_input)
    print len(data_test_output)
    print
    print "Type[0]:"
    print type(data_train_input[0])
    print type(data_train_output[0])
    print type(data_test_input[0])
    print type(data_test_output[0])
    print
    print "Type:"
    print type(data_train_input)
    print type(data_train_output)
    print type(data_test_input)
    print type(data_test_output)
    print
    print "shape of [0]:"
    print data_train_input[0].shape
    print data_train_output[0].shape
    print data_test_input[0].shape
    print data_test_output[0].shape

    list_of_input = [Input(shape = (78,3)) for i in range(72)]
    list_of_conv_output = []
    list_of_max_out = []

    for i in range(72):
        list_of_conv_output.append(Conv1D(filters = 32 , kernel_size = 6 , padding = "same", activation = 'relu')(list_of_input[i]))
        list_of_max_out.append(MaxPooling1D(pool_size=3)(list_of_conv_output[i]))

    merge = keras.layers.concatenate(list_of_max_out)

    reshape = Flatten()(merge)

    dense1 = Dense(units = 500, activation = 'relu',    name = "dense_1")(reshape)
    dense2 = Dense(units = 250, activation = 'relu',    name = "dense_2")(dense1)
    dense3 = Dense(units = 24 , activation = 'softmax', name = "dense_3")(dense2)

    model = Model(inputs = list_of_input , outputs = dense3)
    model.compile(loss="categorical_crossentropy", optimizer="adam" , metrics = [metrics.sparse_categorical_accuracy])

    reduce_lr=ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=3, verbose=1, mode='auto', epsilon=0.01, cooldown=0, min_lr=0.000000000000000000001)
    stop  = EarlyStopping(monitor='val_loss', min_delta=0, patience=5, verbose=1, mode='auto')

    print "Train!"

    print model.summary()

    hist_current = model.fit(x = ,
                        y = ,
                        shuffle=False,
                        validation_data=(,),
                        validation_split=0.1,
                        epochs=150000,
                        verbose=1,
                        callbacks=[reduce_lr,stop])

model(nano_train_input,nano_train_output,nano_test_input, nano_test_output)

```

The input and output is stored as a list of numpy.ndarrays. 
This is a minimal working example.. how am I supposed to pass the input an output?