def _training_model(vec, ac_weights, rl_weights, output_folder, args): """Example function with types documented in the docstring. Args: param1 (int): The first parameter. param2 (str): The second parameter. Returns: bool: The return value. True for success, False otherwise. """ print('Build model...') print(args) # ============================================================================= # Input layer # ============================================================================= ac_input = Input(shape=(vec['prefixes']['activities'].shape[1], ), name='ac_input') rl_input = Input(shape=(vec['prefixes']['roles'].shape[1], ), name='rl_input') t_input = Input(shape=(vec['prefixes']['times'].shape[1], 1), name='t_input') inter_input = Input(shape=(vec['prefixes']['inter_attr'].shape[1], vec['prefixes']['inter_attr'].shape[2]), name='inter_input') # ============================================================================= # Embedding layer for categorical attributes # ============================================================================= ac_embedding = Embedding(ac_weights.shape[0], ac_weights.shape[1], weights=[ac_weights], input_length=(vec['prefixes']['activities'] .shape[1]), trainable=False, name='ac_embedding')(ac_input) rl_embedding = Embedding(rl_weights.shape[0], rl_weights.shape[1], weights=[rl_weights], input_length=vec['prefixes']['roles'].shape[1], trainable=False, name='rl_embedding')(rl_input) # ============================================================================= # Concatenation layer # ============================================================================= merged1 = Concatenate(name='conc_categorical', axis=2)([ac_embedding, rl_embedding]) merged2 = Concatenate(name='conc_continuous', axis=2)([t_input, inter_input]) # ============================================================================= # Layer 1 # ============================================================================= l1_c1 = LSTM(args['l_size'], kernel_initializer='glorot_uniform', return_sequences=True, dropout=0.2, implementation=args['imp'])(merged1) l1_c1d_1 = Conv1D(filters=1, kernel_size=round(vec['prefixes']['times'].shape[1]/3), kernel_initializer='glorot_uniform', padding='same', activation=args['lstm_act'], strides=1)(inter_input) l1_c1d_2 = Conv1D(filters=1, kernel_size=round(vec['prefixes']['times'].shape[1]/3), kernel_initializer='glorot_uniform', padding='same', activation=args['lstm_act'], strides=1)(merged2) pooling1 = MaxPooling1D(pool_size=2)(l1_c1d_1) pooling2 = MaxPooling1D(pool_size=2)(l1_c1d_2) l1_c2 = LSTM(args['l_size'], activation=args['lstm_act'], kernel_initializer='glorot_uniform', return_sequences=True, dropout=0.2, implementation=args['imp'])(pooling1) l1_c3 = LSTM(args['l_size'], activation=args['lstm_act'], kernel_initializer='glorot_uniform', return_sequences=True, dropout=0.2, implementation=args['imp'])(pooling2) # ============================================================================= # Batch Normalization Layer # ============================================================================= batch1 = BatchNormalization()(l1_c1) batch2 = BatchNormalization()(l1_c2) batch3 = BatchNormalization()(l1_c3) # ============================================================================= # The layer specialized in prediction # ============================================================================= l2_c1 = LSTM(args['l_size'], kernel_initializer='glorot_uniform', return_sequences=False, dropout=0.2, implementation=args['imp'])(batch1) # The layer specialized in role prediction l2_c2 = LSTM(args['l_size'], kernel_initializer='glorot_uniform', return_sequences=False, dropout=0.2, implementation=args['imp'])(batch1) # The layer specialized in intercase prediction l2_c3 = LSTM(args['l_size'], kernel_initializer='glorot_uniform', return_sequences=False, dropout=0.2, implementation=args['imp'])(batch2) # The layer specialized in time prediction l2_c4 = LSTM(args['l_size'], activation=args['lstm_act'], kernel_initializer='glorot_uniform', return_sequences=False, dropout=0.2, implementation=args['imp'])(batch3) # ============================================================================= # Output Layer # ============================================================================= act_output = Dense(vec['next_evt']['activities'].shape[1], activation='softmax', kernel_initializer='glorot_uniform', name='act_output')(l2_c1) role_output = Dense(vec['next_evt']['roles'].shape[1], activation='softmax', kernel_initializer='glorot_uniform', name='role_output')(l2_c2) if ('dense_act' in args) and (args['dense_act'] is not None): inter_output = Dense(vec['next_evt']['inter_attr'].shape[1], activation=args['dense_act'], kernel_initializer='glorot_uniform', name='inter_output')(l2_c3) else: inter_output = Dense(vec['next_evt']['inter_attr'].shape[1], kernel_initializer='glorot_uniform', name='inter_output')(l2_c3) if ('dense_act' in args) and (args['dense_act'] is not None): time_output = Dense(1, activation=args['dense_act'], kernel_initializer='glorot_uniform', name='time_output')(l2_c4) else: time_output = Dense(1, kernel_initializer='glorot_uniform', name='time_output')(l2_c4) model = Model(inputs=[ac_input, rl_input, t_input, inter_input], outputs=[act_output, role_output, time_output, inter_output]) if args['optim'] == 'Nadam': opt = Nadam(learning_rate=0.002, beta_1=0.9, beta_2=0.999) elif args['optim'] == 'Adam': opt = Adam(learning_rate=0.001, beta_1=0.9, beta_2=0.999, amsgrad=False) elif args['optim'] == 'SGD': opt = SGD(learning_rate=0.01, momentum=0.0, nesterov=False) elif args['optim'] == 'Adagrad': opt = Adagrad(learning_rate=0.01) model.compile(loss={'act_output': 'categorical_crossentropy', 'role_output': 'categorical_crossentropy', 'time_output': 'mae', 'inter_output': 'mae'}, optimizer=opt) model.summary() early_stopping = EarlyStopping(monitor='val_loss', patience=50) cb = tc.TimingCallback(output_folder) clean_models = cm.CleanSavedModelsCallback(output_folder, 2) # Output file output_file_path = os.path.join(output_folder, 'model_' + str(args['model_type']) + '_{epoch:02d}-{val_loss:.2f}.h5') # Saving model_checkpoint = ModelCheckpoint(output_file_path, monitor='val_loss', verbose=0, save_best_only=True, save_weights_only=False, mode='auto') lr_reducer = ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=10, verbose=0, mode='auto', min_delta=0.0001, cooldown=0, min_lr=0) batch_size = vec['prefixes']['activities'].shape[1] model.fit({'ac_input': vec['prefixes']['activities'], 'rl_input': vec['prefixes']['roles'], 't_input': vec['prefixes']['times'], 'inter_input': vec['prefixes']['inter_attr']}, {'act_output': vec['next_evt']['activities'], 'role_output': vec['next_evt']['roles'], 'time_output': vec['next_evt']['times'], 'inter_output': vec['next_evt']['inter_attr']}, validation_split=0.2, verbose=2, callbacks=[early_stopping, model_checkpoint, lr_reducer, cb, clean_models], batch_size=batch_size, epochs=200)
def _training_model(train_vec, valdn_vec, ac_weights, rl_weights, output_folder, args, log_path=None): """Example function with types documented in the docstring. Args: param1 (int): The first parameter. param2 (str): The second parameter. Returns: bool: The return value. True for success, False otherwise. """ print('Build model...') print(args) # ============================================================================= # Input layer # ============================================================================= ac_input = Input(shape=(train_vec['prefixes']['activities'].shape[1], ), name='ac_input') rl_input = Input(shape=(train_vec['prefixes']['roles'].shape[1], ), name='rl_input') t_input = Input(shape=(train_vec['prefixes']['times'].shape[1], train_vec['prefixes']['times'].shape[2]), name='t_input') inter_input = Input(shape=(train_vec['prefixes']['inter_attr'].shape[1], train_vec['prefixes']['inter_attr'].shape[2]), name='inter_input') # ============================================================================= # Embedding layer for categorical attributes # ============================================================================= ac_embedding = Embedding( ac_weights.shape[0], ac_weights.shape[1], weights=[ac_weights], input_length=train_vec['prefixes']['activities'].shape[1], trainable=False, name='ac_embedding')(ac_input) rl_embedding = Embedding( rl_weights.shape[0], rl_weights.shape[1], weights=[rl_weights], input_length=train_vec['prefixes']['roles'].shape[1], trainable=False, name='rl_embedding')(rl_input) # ============================================================================= # Layer 1 # ============================================================================= concatenate = Concatenate(name='concatenated', axis=2)( [ac_embedding, rl_embedding, t_input, inter_input]) if args['lstm_act'] is not None: l1_c1 = LSTM(args['l_size'], activation=args['lstm_act'], kernel_initializer='glorot_uniform', return_sequences=True, dropout=0.2, implementation=args['imp'])(concatenate) else: l1_c1 = LSTM(args['l_size'], kernel_initializer='glorot_uniform', return_sequences=True, dropout=0.2, implementation=args['imp'])(concatenate) # ============================================================================= # Batch Normalization Layer # ============================================================================= batch1 = BatchNormalization()(l1_c1) # ============================================================================= # The layer specialized in prediction # ============================================================================= l2_c1 = LSTM(args['l_size'], kernel_initializer='glorot_uniform', return_sequences=False, dropout=0.2, implementation=args['imp'])(batch1) # The layer specialized in role prediction l2_c2 = LSTM(args['l_size'], kernel_initializer='glorot_uniform', return_sequences=False, dropout=0.2, implementation=args['imp'])(batch1) # The layer specialized in role prediction l2_c3 = LSTM(args['l_size'], activation=args['lstm_act'], kernel_initializer='glorot_uniform', return_sequences=False, dropout=0.2, implementation=args['imp'])(batch1) # ============================================================================= # Output Layer # ============================================================================= act_output = Dense(ac_weights.shape[0], activation='softmax', kernel_initializer='glorot_uniform', name='act_output')(l2_c1) role_output = Dense(rl_weights.shape[0], activation='softmax', kernel_initializer='glorot_uniform', name='role_output')(l2_c2) if ('dense_act' in args) and (args['dense_act'] is not None): time_output = Dense(train_vec['next_evt']['times'].shape[1], activation=args['dense_act'], kernel_initializer='glorot_uniform', name='time_output')(l2_c3) else: time_output = Dense(train_vec['next_evt']['times'].shape[1], kernel_initializer='glorot_uniform', name='time_output')(l2_c3) model = Model(inputs=[ac_input, rl_input, t_input, inter_input], outputs=[act_output, role_output, time_output]) if args['optim'] == 'Nadam': opt = Nadam(learning_rate=0.002, beta_1=0.9, beta_2=0.999) elif args['optim'] == 'Adam': opt = Adam(learning_rate=0.001, beta_1=0.9, beta_2=0.999, amsgrad=False) elif args['optim'] == 'SGD': opt = SGD(learning_rate=0.01, momentum=0.0, nesterov=False) elif args['optim'] == 'Adagrad': opt = Adagrad(learning_rate=0.01) model.compile(loss={ 'act_output': 'categorical_crossentropy', 'role_output': 'categorical_crossentropy', 'time_output': 'mae' }, optimizer=opt) model.summary() early_stopping = EarlyStopping(monitor='val_loss', patience=40) if log_path: cb = tc.TimingCallback(output_folder, log_path=log_path) else: cb = tc.TimingCallback(output_folder) # Output file output_file_path = os.path.join(output_folder, os.path.splitext(args['file'])[0] + '.h5') # Saving model_checkpoint = ModelCheckpoint(output_file_path, monitor='val_loss', verbose=0, save_best_only=True, save_weights_only=False, mode='auto') lr_reducer = ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=10, verbose=0, mode='auto', min_delta=0.0001, cooldown=0, min_lr=0) batch_size = args['batch_size'] model.fit( { 'ac_input': train_vec['prefixes']['activities'], 'rl_input': train_vec['prefixes']['roles'], 't_input': train_vec['prefixes']['times'], 'inter_input': train_vec['prefixes']['inter_attr'] }, { 'act_output': train_vec['next_evt']['activities'], 'role_output': train_vec['next_evt']['roles'], 'time_output': train_vec['next_evt']['times'] }, validation_data=({ 'ac_input': valdn_vec['prefixes']['activities'], 'rl_input': valdn_vec['prefixes']['roles'], 't_input': valdn_vec['prefixes']['times'], 'inter_input': valdn_vec['prefixes']['inter_attr'] }, { 'act_output': valdn_vec['next_evt']['activities'], 'role_output': valdn_vec['next_evt']['roles'], 'time_output': valdn_vec['next_evt']['times'] }), verbose=2, callbacks=[early_stopping, model_checkpoint, lr_reducer, cb], batch_size=batch_size, epochs=args['epochs']) return model
def _training_model(ac_weights, train_vec, valdn_vec, parms): """Example function with types documented in the docstring. Args: param1 (int): The first parameter. param2 (str): The second parameter. Returns: bool: The return value. True for success, False otherwise. """ print('Build model...') early_stopping = EarlyStopping(monitor='val_loss', patience=50) cb = tc.TimingCallback(parms['output']) batch_size = parms['batch_size'] # Output route path = parms['output'] fname = parms['file'].split('.')[0] if parms['all_r_pool']: proc_model_file = os.path.join(path, fname + '_dpiapr.h5') waiting_model_file = os.path.join(path, fname + '_dwiapr.h5') else: proc_model_file = os.path.join(path, fname + '_dpispr.h5') waiting_model_file = os.path.join(path, fname + '_dwispr.h5') # Train models # with g1.as_default(): proc_model = create_model(ac_weights, train_vec['proc_model'], parms) # Saving model_checkpoint = ModelCheckpoint(proc_model_file, monitor='val_loss', verbose=0, save_best_only=True, save_weights_only=False, mode='auto') lr_reducer = ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=10, verbose=0, mode='auto', min_delta=0.0001, cooldown=0, min_lr=0) proc_model.fit( { 'ac_input': train_vec['proc_model']['pref']['ac_index'], 'features': train_vec['proc_model']['pref']['features'] }, {'time_output': train_vec['proc_model']['next']}, validation_data=({ 'ac_input': valdn_vec['proc_model']['pref']['ac_index'], 'features': valdn_vec['proc_model']['pref']['features'] }, { 'time_output': valdn_vec['proc_model']['next'] }), verbose=2, callbacks=[early_stopping, model_checkpoint, lr_reducer, cb], batch_size=batch_size, epochs=parms['epochs']) waiting_model = create_model(ac_weights, train_vec['waiting_model'], parms) # Saving model_checkpoint = ModelCheckpoint(waiting_model_file, monitor='val_loss', verbose=0, save_best_only=True, save_weights_only=False, mode='auto') lr_reducer = ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=10, verbose=0, mode='auto', min_delta=0.0001, cooldown=0, min_lr=0) waiting_model.fit( { 'ac_input': train_vec['waiting_model']['pref']['ac_index'], 'features': train_vec['waiting_model']['pref']['features'] }, {'time_output': train_vec['waiting_model']['next']}, validation_data=({ 'ac_input': valdn_vec['waiting_model']['pref']['ac_index'], 'features': valdn_vec['waiting_model']['pref']['features'] }, { 'time_output': valdn_vec['waiting_model']['next'] }), verbose=2, callbacks=[early_stopping, model_checkpoint, lr_reducer, cb], batch_size=batch_size, epochs=parms['epochs']) return { 'proc_model': { 'model': proc_model }, 'wait_model': { 'model': waiting_model } }
def _training_model(ac_weights, train_vec, valdn_vec, parms): """Example function with types documented in the docstring. Args: param1 (int): The first parameter. param2 (str): The second parameter. Returns: bool: The return value. True for success, False otherwise. """ print('Build model...') # ============================================================================= # Input layer # ============================================================================= ac_input = Input(shape=(train_vec['pref']['ac_index'].shape[1], ), name='ac_input') n_ac_input = Input(shape=(train_vec['pref']['n_ac_index'].shape[1], ), name='n_ac_input') features = Input(shape=(train_vec['pref']['features'].shape[1], train_vec['pref']['features'].shape[2]), name='features') # ============================================================================= # Embedding layer for categorical attributes # ============================================================================= ac_embedding = Embedding( ac_weights.shape[0], ac_weights.shape[1], weights=[ac_weights], input_length=train_vec['pref']['ac_index'].shape[1], trainable=False, name='ac_embedding')(ac_input) n_ac_embedding = Embedding( ac_weights.shape[0], ac_weights.shape[1], weights=[ac_weights], input_length=train_vec['pref']['n_ac_index'].shape[1], trainable=False, name='n_ac_embedding')(n_ac_input) # ============================================================================= # Layer 1 # ============================================================================= merged = Concatenate(name='concatenated', axis=2)([ac_embedding, n_ac_embedding, features]) l1_c1 = LSTM(parms['l_size'], kernel_initializer='glorot_uniform', return_sequences=True, dropout=0.2, implementation=parms['imp'])(merged) # ============================================================================= # Batch Normalization Layer # ============================================================================= batch1 = BatchNormalization()(l1_c1) # ============================================================================= # The layer specialized in prediction # ============================================================================= l2_c1 = LSTM(parms['l_size'], activation=parms['lstm_act'], kernel_initializer='glorot_uniform', return_sequences=False, dropout=0.2, implementation=parms['imp'])(batch1) # ============================================================================= # Output Layer # ============================================================================= times_output = Dense(train_vec['next'].shape[1], activation=parms['dense_act'], kernel_initializer='glorot_uniform', name='time_output')(l2_c1) model = Model(inputs=[ac_input, n_ac_input, features], outputs=[times_output]) if parms['optim'] == 'Nadam': opt = Nadam(learning_rate=0.002, beta_1=0.9, beta_2=0.999) elif parms['optim'] == 'Adam': opt = Adam(learning_rate=0.001, beta_1=0.9, beta_2=0.999, amsgrad=False) elif parms['optim'] == 'SGD': opt = SGD(learning_rate=0.01, momentum=0.0, nesterov=False) elif parms['optim'] == 'Adagrad': opt = Adagrad(learning_rate=0.01) model.compile(loss={'time_output': 'mae'}, optimizer=opt) model.summary() early_stopping = EarlyStopping(monitor='val_loss', patience=50) cb = tc.TimingCallback(parms['output']) # clean_models = cm.CleanSavedModelsCallback(parms['output'], 2) # Output file output_file_path = os.path.join(parms['output'], parms['file'].split('.')[0] + '.h5') # Saving model_checkpoint = ModelCheckpoint(output_file_path, monitor='val_loss', verbose=0, save_best_only=True, save_weights_only=False, mode='auto') lr_reducer = ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=10, verbose=0, mode='auto', min_delta=0.0001, cooldown=0, min_lr=0) batch_size = parms['batch_size'] model.fit( { 'ac_input': train_vec['pref']['ac_index'], 'n_ac_input': train_vec['pref']['n_ac_index'], 'features': train_vec['pref']['features'] }, {'time_output': train_vec['next']}, validation_data=({ 'ac_input': valdn_vec['pref']['ac_index'], 'n_ac_input': valdn_vec['pref']['n_ac_index'], 'features': valdn_vec['pref']['features'] }, { 'time_output': valdn_vec['next'] }), verbose=2, callbacks=[early_stopping, model_checkpoint, lr_reducer, cb], batch_size=batch_size, epochs=parms['epochs']) return model
def _training_model(vec, ac_weights, rl_weights, output_folder, args): """Example function with types documented in the docstring. Args: param1 (int): The first parameter. param2 (str): The second parameter. Returns: bool: The return value. True for success, False otherwise. """ print('Build model...') # ============================================================================= # Encoder Input layer # ============================================================================= ac_input = Input( shape=(vec['encoder_input_data']['activities'].shape[1], ), name='ac_input') rl_input = Input(shape=(vec['encoder_input_data']['roles'].shape[1], ), name='rl_input') t_input = Input(shape=(vec['encoder_input_data']['times'].shape[1], 1), name='t_input') # ============================================================================= # Embedding layer for categorical attributes # ============================================================================= ac_embedding = Embedding( ac_weights.shape[0], ac_weights.shape[1], weights=[ac_weights], input_length=vec['encoder_input_data']['activities'].shape[1], trainable=False, name='ac_embedding')(ac_input) rl_embedding = Embedding( rl_weights.shape[0], rl_weights.shape[1], weights=[rl_weights], input_length=vec['encoder_input_data']['roles'].shape[1], trainable=False, name='rl_embedding')(rl_input) # ============================================================================= # LSTM Encoder Layer # ============================================================================= merged = Concatenate(name='concatenated', axis=2)([ac_embedding, rl_embedding]) l1_c1, state_l1_c1, state_l1_c1 = LSTM(args['l_size'], kernel_initializer='glorot_uniform', return_state=True, dropout=0.2, implementation=args['imp'])(merged) l1_c3, state_l1_c3, state_l1_c3 = LSTM(args['l_size'], activation=args['lstm_act'], kernel_initializer='glorot_uniform', return_state=True, dropout=0.2, implementation=args['imp'])(t_input) # We discard `encoder_outputs` and only keep the states. encoder_states_l1_c1 = [state_l1_c1, state_l1_c1] encoder_states_l1_c3 = [state_l1_c3, state_l1_c3] # ============================================================================= # Decoder Input layer # ============================================================================= dec_ac_input = Input( shape=(vec['decoder_input_data']['activities'].shape[1], ), name='dec_ac_input') dec_rl_input = Input(shape=(vec['decoder_input_data']['roles'].shape[1], ), name='dec_rl_input') dec_t_input = Input(shape=(vec['decoder_input_data']['times'].shape[1], 1), name='dec_t_input') # ============================================================================= # Embedding layer for categorical attributes # ============================================================================= dec_ac_embedding = Embedding( ac_weights.shape[0], ac_weights.shape[1], weights=[ac_weights], input_length=vec['decoder_input_data']['activities'].shape[1], trainable=False, name='dec_ac_embedding')(dec_ac_input) dec_rl_embedding = Embedding( rl_weights.shape[0], rl_weights.shape[1], weights=[rl_weights], input_length=vec['decoder_input_data']['roles'].shape[1], trainable=False, name='dec_rl_embedding')(dec_rl_input) dec_merged = Concatenate(name='dec_concatenated', axis=2)([dec_ac_embedding, dec_rl_embedding]) l2_c1, _, _ = LSTM(args['l_size'], return_sequences=True, return_state=True, implementation=args['imp'])( dec_merged, initial_state=encoder_states_l1_c1) l2_c3, _, _ = LSTM(args['l_size'], activation=args['lstm_act'], return_sequences=True, return_state=True, dropout=0.2, implementation=args['imp'])( dec_t_input, initial_state=encoder_states_l1_c3) # ============================================================================= # Output # ============================================================================= dec_act_output = Dense(len(args['index_ac']), activation='softmax', name='act_output')(l2_c1) dec_rl_output = Dense(len(args['index_rl']), activation='softmax', name='rl_output')(l2_c1) if ('dense_act' in args) and (args['dense_act'] is not None): dec_time_output = Dense(1, activation=args['dense_act'], kernel_initializer='glorot_uniform', name='time_output')(l2_c3) else: dec_time_output = Dense(1, kernel_initializer='glorot_uniform', name='time_output')(l2_c3) model = Model(inputs=[ ac_input, rl_input, t_input, dec_ac_input, dec_rl_input, dec_t_input ], outputs=[dec_act_output, dec_rl_output, dec_time_output]) if args['optim'] == 'Nadam': opt = Nadam(learning_rate=0.002, beta_1=0.9, beta_2=0.999) elif args['optim'] == 'Adam': opt = Adam(learning_rate=0.001, beta_1=0.9, beta_2=0.999, amsgrad=False) elif args['optim'] == 'SGD': opt = SGD(learning_rate=0.01, momentum=0.0, nesterov=False) elif args['optim'] == 'Adagrad': opt = Adagrad(learning_rate=0.01) model.compile(loss={ 'act_output': 'categorical_crossentropy', 'rl_output': 'categorical_crossentropy', 'time_output': 'mae' }, metrics=['accuracy'], optimizer=opt) print(model.summary()) early_stopping = EarlyStopping(monitor='val_loss', patience=42) cb = tc.TimingCallback(output_folder) clean_models = cm.CleanSavedModelsCallback(output_folder, 2) # Output file output_file_path = os.path.join( output_folder, 'model_' + str(args['model_type']) + '_{epoch:02d}-{val_loss:.2f}.h5') # Saving model_checkpoint = ModelCheckpoint(output_file_path, monitor='val_loss', verbose=0, save_best_only=True, save_weights_only=False, mode='auto') lr_reducer = ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=40, verbose=0, mode='auto', min_delta=0.0001, cooldown=0, min_lr=0) batch_size = vec['encoder_input_data']['activities'].shape[1] model.fit( { 'ac_input': vec['encoder_input_data']['activities'], 'rl_input': vec['encoder_input_data']['roles'], 't_input': vec['encoder_input_data']['times'], 'dec_ac_input': vec['decoder_input_data']['activities'], 'dec_rl_input': vec['decoder_input_data']['roles'], 'dec_t_input': vec['decoder_input_data']['times'] }, { 'act_output': vec['decoder_target_data']['activities'], 'rl_output': vec['decoder_target_data']['roles'], 'time_output': vec['decoder_target_data']['times'] }, batch_size=batch_size, epochs=500, validation_split=0.2, verbose=2, callbacks=[ early_stopping, model_checkpoint, lr_reducer, cb, clean_models ])