Beispiel #1
0
def gen_model(input_dim=10, output_dim=8, batch_size=100):
    model_LSTM = Sequential()
    model_LSTM.name = "LSTM"
    model_LSTM.batch_size = batch_size
    model_LSTM.input_dim = input_dim
    model_LSTM.output_dim = output_dim

    model_LSTM.add(LSTM(input_shape=(None, input_dim), units=units, return_sequences=True))
    model_LSTM.add(LSTM(units=units, return_sequences=True))
    model_LSTM.add(LSTM(units=output_dim, return_sequences=True))
    model_LSTM.add(Activation('sigmoid'))

    sgd = Adam(lr=lr, clipnorm=clipnorm)
    model_LSTM.compile(loss='binary_crossentropy', optimizer=sgd, metrics=[
                       'binary_accuracy'], sample_weight_mode="temporal")

    return model_LSTM
Beispiel #2
0
def gen_model(input_dim=10, output_dim=8, batch_size=100):
    model_dense = Sequential()
    model_dense.name = "FFW"
    model_dense.batch_size = batch_size
    model_dense.input_dim = input_dim
    model_dense.output_dim = output_dim

    model_dense.add(Dense(input_shape=(None, input_dim), units=output_dim))
    model_dense.add(Activation('sigmoid'))

    sgd = Adam(lr=lr, clipnorm=clipnorm)
    model_dense.compile(loss='binary_crossentropy',
                        optimizer=sgd,
                        metrics=['binary_accuracy'],
                        sample_weight_mode="temporal")

    return model_dense
Beispiel #3
0
def gen_model(input_dim,
              batch_size,
              output_dim,
              n_slots=n_slots,
              m_depth=m_depth,
              controller_model=None,
              activation="sigmoid",
              read_heads=1,
              write_heads=1):

    model = Sequential()
    model.name = "NTM_-_" + controller_model.name
    model.batch_size = batch_size
    model.input_dim = input_dim
    model.output_dim = output_dim

    ntm = NTM(output_dim,
              n_slots=n_slots,
              m_depth=m_depth,
              shift_range=3,
              controller_model=controller_model,
              activation=activation,
              read_heads=read_heads,
              write_heads=write_heads,
              return_sequences=True,
              input_shape=(None, input_dim),
              batch_size=batch_size)
    model.add(ntm)

    sgd = Adam(lr=learning_rate, clipnorm=clipnorm)
    model.compile(loss='binary_crossentropy',
                  optimizer=sgd,
                  metrics=['binary_accuracy'],
                  sample_weight_mode="temporal")

    return model
n_slots = 128 
m_depth = 20 
learning_rate = 5e-4
clipnorm = 10

def gen_model(input_dim.batch_size,output_dim,
              n_slots = n_slots,
              m_depth = m_depth,
              controller_model = None,
              activation = "sigmoid",
              read_head = 1,
              write_head = 1):

    model = Sequential()
    model.name = "NTM_-_"+ controller_model.name 
    model.batch_size = batch_size
    model.input_dim = input_dim
    model.ouput_dim =output_dim

    ntm = NTM(output_dim, n_slots = n_slots, m_depth = m_depth,
              shift_range = 3,
              controller_model = controller_model,
              activation = activation,
              read_heads = read_heads,
              write_heads = write_heads,
             # return_sequences = True,
             input_shape = (None,input_dim),
             batch_size = batch_size)

    model.add(NTM)