def optimize_model(input_shape, X, Y, study): K.set_floatx('float16') for trial in study: model = build_model(input_shape, trial.parameters) epochs = 50 for i in range(epochs): print("Epoch ", i + 1) # Cross validation split for each epoch x_train, x_validation, y_train, y_validation = train_test_split( X, Y, test_size=0.2) data_generator = daily_generator(x_train, y_train) valid_generator = daily_generator(x_validation, y_validation) # Train for one epoch and call back to TensorBoard and Sherpa hist = model.fit_generator(generator=data_generator, steps_per_epoch=len(x_train), validation_data=valid_generator, validation_steps=len(x_validation), use_multiprocessing=True, initial_epoch=i, epochs=i + 1, callbacks=[ study.keras_callback( trial, objective_name='val_loss'), TensorBoard(log_dir="scripts/logs") ]) print(hist.history) study.finalize(trial)
def main(): backend.set_floatx("float16") backend.set_epsilon(1e-4) data = get_dataset( block_interval=8, block_size=INPUT_COUNT, file_count=40, output_size=OUTPUT_COUNT, ) train_data = data.train_data.reshape(len(data.train_data), INPUT_COUNT, 1) test_data = data.test_data.reshape(len(data.test_data), INPUT_COUNT, 1) model = ExperimentalModel() model.load() # model.train(train_data, data.train_out, test_data, data.test_out) for i in range(min(len(data.files), min(len(data.files), 10))): result = data.files[i][40] inp = result.reshape(INPUT_COUNT, 1) result = list(result) generate_steps = 4000 iterations = int(generate_steps / OUTPUT_COUNT) for j in range(iterations): if j % 1000 == 0: print(f"Progress: {j} / {iterations}") out = model.predict_output(inp.reshape(1, *inp.shape)) result.extend(out[0]) # inp = out.reshape(32, 1) inp = np.concatenate([inp, out.reshape(OUTPUT_COUNT, 1)])[-INPUT_COUNT:] data.write_wav(f"output-lstm-{MODEL_ID}-{i}.wav", np.array(result))
def _enable_float16(self): dtype = 'float16' K.set_floatx(dtype) K.set_epsilon(1e-4) return dtype
def _enable_float32(self): dtype = 'float32' K.set_floatx(dtype) K.set_epsilon(1e-7) return dtype
def get_precomputed_statistics(directory, num_samples=50): # Keras generators use float32 which gives weird values. K.set_floatx('float64') # Get a clean datagen. vanilla_datagen = get_data(directory) # Collect a bunch of samples. x = np.zeros((num_samples, IMAGE_SIZE, IMAGE_SIZE, 3)) index = 0 for x_, _ in vanilla_datagen: if index >= num_samples: break offset = min(num_samples - index, x_.shape[0]) x[index:index+offset] = x_[:offset] index += offset # Actually fit the data and compute statistics. statistics_datagen = ImageDataGenerator( featurewise_std_normalization=True, featurewise_center=True) statistics_datagen.fit(x) print("Dataset path: %s" % directory) print("Sample mean: %s" % statistics_datagen.mean) print("Sample standard deviation: %s" % statistics_datagen.std) return statistics_datagen.mean, statistics_datagen.std
def run_model(): # Setting state variables K.set_image_dim_ordering('th') K.set_floatx('float32') np.random.seed(17) # Reading in data train_data = np.load('train.npy') train_target = np.load('train_target.npy') # Cross fold training x_train,x_val_train,y_train,y_val_train = train_test_split(train_data,train_target,test_size=0.4, random_state=17) # Data Augmentation datagen = ImageDataGenerator( rotation_range=40, width_shift_range=0.2, height_shift_range=0.2, shear_range=0.2, zoom_range=0.2, horizontal_flip=True, fill_mode='nearest') #datagen = ImageDataGenerator(rotation_range=0.3, zoom_range=0.3) datagen.fit(train_data) # Run Model model = create_model() model.fit_generator(datagen.flow(x_train,y_train, batch_size=15, shuffle=True), nb_epoch=200, samples_per_epoch=len(x_train), verbose=20, validation_data=(x_val_train, y_val_train)) return model
def main(): backend.set_floatx("float16") backend.set_epsilon(1e-4) data = get_dataset(block_interval=int(INPUT_COUNT / 4), block_size=INPUT_COUNT, file_count=10) # train_data = data.train_data.reshape(len(data.train_data), INPUT_COUNT, 1) # test_data = data.test_data.reshape(len(data.test_data), INPUT_COUNT, 1) train_data = data.train_data test_data = data.test_data # plt.plot(train_data.flatten()) # plt.show() # plot_data = np.bincount((train_data.flatten() * 255).astype(int)) # plt.plot(plot_data) # plt.show() # print(plot_data.shape) model = AutoEncoder() model.load() model.train(train_data, test_data) for i in range(min(len(data.files), 10)): output = model.predict_output(data.files[i]) data.write_wav(f"output-conv-{CONV_ID}-{i}.wav", output)
def initialise_backend (args): """Initialise the Keras backend. Args: args: Namespace containing command-line arguments from argparse. These settings specify which back-end should be configured, and how. """ # Check(s) assert 'keras' not in sys.modules, \ "initialise_backend: Keras was imported before initialisation." if args.gpu and args.theano and args.devices > 1: raise NotImplementedError("Distributed training on GPUs is current not enabled.") # Specify Keras backend and import module os.environ['KERAS_BACKEND'] = "theano" if args.theano else "tensorflow" # Get number of cores on CPU(s), name of CPU devices, and number of physical # cores in each device. try: cat_output = subprocess.check_output(["cat", "/proc/cpuinfo"]).split('\n') num_cpus = len(filter(lambda line: line.startswith('cpu cores'), cat_output)) name_cpu = filter(lambda line: line.startswith('model name'), cat_output)[0] \ .split(':')[-1].strip() num_cores = int(filter(lambda line: line.startswith('cpu cores'), cat_output)[0] \ .split(':')[-1].strip()) log.info("Found {} {} devices with {} cores each.".format(num_cpus, name_cpu, num_cores)) except subprocess.CalledProcessError: # @TODO: Implement CPU information for macOS num_cores = 1 log.warning("Could not retrieve CPU information -- probably running on macOS. Therefore, multi-core running is disabled.") pass try: #num_cores=os.environ["SLURM_CPUS_PER_TASK"] #num_cores=os.environ["SLURM_JOB_CPUS_PER_NODE"] num_cores=int(os.environ["SLURM_CPUS_ON_NODE"]) log.info("BUT Inside SLURM: {} cpus(cores) of this task".format(num_cores)) except: pass # Configure backend if args.theano: _ = configure_theano(args, num_cores) else: session = configure_tensorflow(args, num_cores) pass # Import Keras backend import keras.backend as K K.set_floatx('float32') if not args.theano: # Set global Tensorflow session K.set_session(session) pass return
def test_setfloatx_correct_values(self): # Keep track of the old value old_floatx = floatx() # Check correct values for value in ['float16', 'float32', 'float64']: set_floatx(value) assert floatx() == value # Restore old value set_floatx(old_floatx)
def GRU_multi_16bit(bs, time_steps, alphabet_size): K.set_floatx('float16') model = Sequential() model.add(Embedding(alphabet_size, 32, batch_input_shape=(bs, time_steps))) model.add(CuDNNGRU(32, stateful=False, return_sequences=True)) model.add(CuDNNGRU(32, stateful=False, return_sequences=True)) model.add(Flatten()) model.add(Dense(64, activation='relu')) model.add(Dense(alphabet_size, activation='softmax')) return model
def init_left(self): """ Used to generate a leftmask :return: """ K.set_floatx('float32') k_weights_tem_2d_left = K.arange(self.kernel.shape[0]) k_weights_tem_2d_left = tf.expand_dims(k_weights_tem_2d_left, 1) k_weights_tem_3d_left = K.cast(K.repeat_elements(k_weights_tem_2d_left, self.kernel.shape[2], axis=1), dtype='float32') - self.k_weights[0, :, :] self.k_weights_3d_left = tf.expand_dims(k_weights_tem_3d_left, 1)
def FC_4layer_16bit(bs, time_steps, alphabet_size): K.set_floatx('float16') model = Sequential() model.add(Embedding(alphabet_size, 5, batch_input_shape=(bs, time_steps))) model.add(Flatten()) model.add(Dense(128, activation=ELU(1.0))) model.add(Dense(128, activation=ELU(1.0))) model.add(Dense(128, activation=ELU(1.0))) model.add(Dense(128, activation=ELU(1.0))) model.add(Dense(alphabet_size, activation='softmax')) return model
def biLSTM_16bit(bs, time_steps, alphabet_size): K.set_floatx('float16') model = Sequential() model.add(Embedding(alphabet_size, 32, batch_input_shape=(bs, time_steps))) model.add( Bidirectional(CuDNNLSTM(32, stateful=False, return_sequences=True))) model.add( Bidirectional(CuDNNLSTM(32, stateful=False, return_sequences=False))) model.add(Dense(64, activation='relu')) model.add(Dense(alphabet_size, activation='softmax')) return model
def test_setfloatx_incorrect_values(self): # Keep track of the old value old_floatx = floatx() # Try some incorrect values initial = floatx() for value in ['', 'beerfloat', 123]: with pytest.raises(Exception): set_floatx(value) assert floatx() == initial # Restore old value set_floatx(old_floatx)
def build_model_keras(self, architecture, input_num_events, regulariser=None, mem_alloc=0.049): logging.debug("Building keras architecture with %d input neurons.", input_num_events) backend.set_floatx('float32') config = tf.ConfigProto() #config.gpu_options.per_process_gpu_memory_fraction = mem_alloc config.gpu_options.allow_growth = True set_session(tf.Session(config=config)) model = Sequential() keras_regulariser = None if regulariser == Regularisation.L1: keras_regulariser = regularizers.l1(0.01) elif regulariser == Regularisation.L2: keras_regulariser = regularizers.l2(0.01) elif regulariser == Regularisation.L1L2: keras_regulariser = regularizers.l1_l2(0.01) else: logging.error("Do not recognise regulariser: %s", str(regulariser)) raise ValueError() if architecture == [0]: # linear model model.add(Dense(1, activation='linear', input_dim=input_num_events)) else: model.add( Dense(architecture[0], input_dim=input_num_events, activation='relu', kernel_regularizer=keras_regulariser, use_bias=False)) model.add(BatchNormalization()) for layer in architecture[1:]: model.add( Dense(layer, activation='relu', kernel_regularizer=keras_regulariser, activity_regularizer=keras_regulariser, use_bias=False)) model.add(BatchNormalization()) model.add(Dense(1, use_bias=False, activation='linear')) return model
def __init__(self, config_filename): self.config_filename = config_filename args = parse_args(self.config_filename) with open(args.config_file) as fp: config = yaml.safe_load(fp) # パラメータの読み込み self.input_timesteps = config["input_timesteps"] # 入力タイムステップ self.output_timesteps = config["output_timesteps"] # 出力タイムステップ self.set_float = config["set_float"] # 内部処理の設定 self.Network_type = config["Network_type"] # 使用するネットワーク self.layer_num = config["layer_num"] # Residual Block数 self.channel = config["channel"] # チャンネル数 self.filter_size = config["filter_size"] # CNNフィルタサイズ self.gate = config["gate"] # ゲートの活性化関数 self.LSTM_ch = config["LSTM_ch"] # チャンネル数(LSTM) self.GPU_use = config["GPU_use"] # LSTM層とcuDNNLSTM層の切り替え self.batch_size = config["batch_size"] # バッチサイズ self.max_epochs = config["max_epochs"] # エポック数 self.patience = config["patience"] # 打ち止めエポック数 self.p_wave = config["p_wave"] # ハイパーパラメータ(波形) self.p_freq = config["p_freq"] # ハイパーパラメータ(周波数) self.wave_loss = config["wave_loss"] # 損失関数(波形領域) self.freq_loss = config["freq_loss"] # 損失関数(周波数領域) self.FX = config["FX"] # モデリングするエフェクタ self.param_save = config["param_save"] # ネットワークパラメータの保存 self.loss_shift = config["loss_shift"] # 学習途中でlossの重みを変更 self.shift_epoch = config["shift_epoch"] self.single_conv = config["single_conv"] K.set_floatx(self.set_float) self.plot_x_range = config["plot_x_range"] # 学習の初期は位相の反転を防ぐために波形の損失のみ用いる self.lambda_wave_start = 1 if self.loss_shift == True: self.lambda_freq_start = 0 else: self.lambda_freq_start = self.p_freq self.wave_name = "Loss_wave" self.freq_name = "Loss_freq" if self.freq_loss != "None": self.time_freq_loss = True else: self.time_freq_loss = False # 補助特徴量を使用するか判断する self.FX_num = len(self.FX) # モデリングを行うエフェクタの数 if self.FX_num != 1: self.Condition = True else: self.Condition = False dir_flag = "result" in os.listdir("./") if dir_flag == False: os.mkdir("./result")
def main(): dtype = 'float32' K.set_floatx(dtype) np.set_printoptions(threshold=np.inf) trainX, trainY = load_data(Train_path) trainX_50, trainY_50, trainX_100, trainY_100 = splid_data_50( trainX, trainY) #5 * 2 fold cross-validation trainX, trainY, validX, validY, testX, testY = split_data( trainX_50, trainY_50) #trainX, trainY, validX, validY, testX, testY = split_data(trainX, trainY) Neural_Network_MobileNetV2(trainX, trainY, validX, validY, testX, testY)
def test_conv_float64(input_shape, conv_class): kernel_size = 3 strides = 1 filters = 3 K.set_floatx('float64') layer_test(conv_class, kwargs={'filters': filters, 'kernel_size': kernel_size, 'padding': 'valid', 'strides': strides}, input_shape=input_shape) K.set_floatx('float32')
def LSTM_multi_selu_16bit(bs, time_steps, alphabet_size): K.set_floatx('float16') model = Sequential() model.add(Embedding(alphabet_size, 32, batch_input_shape=(bs, time_steps))) model.add(CuDNNLSTM(32, stateful=False, return_sequences=True)) model.add(CuDNNLSTM(32, stateful=False, return_sequences=True)) model.add(Flatten()) init = keras.initializers.lecun_uniform(seed=0) model.add( Dense(64, activation=keras.activations.selu, kernel_initializer=init)) model.add(Dense(alphabet_size, activation='softmax')) return model
def __getitem__(self, idx): if (idx + 1) * self.batch_size < len(self.video_files): batch = self.video_files[idx * self.batch_size:(idx + 1) * self.batch_size] else: batch = self.video_files[idx * self.batch_size:] batch_vi = [] batch_em = [] Ploc = [] mu = [] K.set_floatx('float32') for i in range(len(batch)): vid = batch[i] gt_video = np.load('flintstones_dataset/video_frames/' + vid + '.npy') video = np.empty((128, 128, 3 * self.F), dtype=np.float64) anno = self.annotations[vid] entities = [] for obj in anno['objects']: entities.append(obj) for car in anno['characters']: entities.append(car) sorted(entities, key=lambda x: x['entitySpan'][0]) for entity in entities: #batch_em.append(embeddings[int((entity['entitySpan'][0]+entity['entitySpan'][1])/2),:]) inp = np.load('flintstones_dataset/layoutcomposer_in/' + entity['globalID'] + '.npz') batch_vi.append( inp['Vi'] [:, :, np.array([30, 31, 32, 120, 121, 122, 210, 211, 212])]) batch_em.append(inp['embedding']) out = np.load('flintstones_dataset/layoutcomposer_gtF3/' + entity['globalID'] + '.npz') Ploc.append(out['Ploc']) mu.append(out['mu']) #mask = np.load('flintstones_dataset/entity_segmentation/'+entity['globalID']+'_segm.npy.npz')['arr_0'] #segmented = np.empty((self.F, 128,128,3), dtype=np.float64) #for i in range(3): # segmented[:, :, :, i] = mask * gt_video[:, :, :, i] #frame = 0 #for i in range(self.F): # for l in range(3): # for j in range(128): # for k in range(128): # if np.where(segmented[i][j][k][l] > 0): # video[j][k][frame] = segmented[i][j][k][l] # frame = frame + 1 #batch_vi.append(video) return [np.array(batch_vi), np.array(batch_em)], [np.array(mu), np.array(Ploc)]
def lossfn(self,y_true, y_pred): K.set_floatx('float32') Ploc_true = (y_true[0]) mu_true = (y_true[1]) Ploc_pred = (y_pred[0]) mu_pred = (y_pred[1]) print(y_pred[1]) sigma = K.cast_to_floatx(np.diag(np.full((2*self.F,), 0.005))) cost = (-tf.log(Ploc_pred) + (0.5) * tf.log(tf.matrix_determinant(sigma)) + (0.5) * K.dot(tf.transpose(mu_true - mu_pred), K.dot(tf.matrix_inverse(sigma), (mu_true - mu_pred))) + tf.log(2 * m.pi)) return cost
def __init__(self, path, file, layer_name="vector_layer", dtype='float16'): self._model = None self._path = path self._file = file self.layer_name = layer_name self._data_gen = None self._train_gen = None self.image_set = self._get_image_names() self.fib_dict = {} self.special_num = [] self.inverted_index = {} self.master_inverted_index = {} self.fp_index = {} backend.set_floatx(dtype)
def unet_model(model_file, weight_file): # unet model K.set_image_data_format('channels_last') K.set_floatx('float64') json_file = open(model_file, "r") loaded_model_json = json_file.read() json_file.close() unet = model_from_json(loaded_model_json) unet.load_weights(weight_file) unet.compile(optimizer=Adam(lr=1e-4), loss='binary_crossentropy', metrics=['mse', 'mae']) return unet
def main(): backend.set_floatx("float16") backend.set_epsilon(1e-4) data = get_dataset(block_interval=1000, block_size=2000, file_count=10) # train_data = data.train_data.reshape(len(data.train_data), 2000, 1) # test_data = data.test_data.reshape(len(data.test_data), 2000, 1) model = AutoEncoder() model.load() # model.train(train_data, test_data) for i in range(10): inp = data.files[i].reshape(len(data.files[i]), 2000, 1) output = model.predict_output(inp).reshape(len(data.files[i]), 2000) data.write_wav(f"output-conv{i}.wav", output)
def __init__(self, model_filepath, input_dir, resource_dir, layer_name='vector_layer', dtype='float16'): self._base = os.path.dirname(os.path.realpath(__file__)) self._model_filepath = model_filepath self._input_dir = input_dir self._resource_dir = resource_dir self._layer_name = layer_name self._model = None backend.set_floatx(dtype) self._load_model() self._load_vectors()
def main(): backend.set_floatx("float16") backend.set_epsilon(1e-4) data = get_dataset(block_interval=1, block_size=INPUT_COUNT, file_count=1) train_data = data.train_data.reshape(len(data.train_data), INPUT_COUNT, 1) test_data = data.test_data.reshape(len(data.test_data), INPUT_COUNT, 1) model = ExperimentalModel() model.load() # model.train(train_data, test_data) for i in range(min(len(data.files), min(len(data.files), 10))): inp = data.files[i].reshape(len(data.files[i]), INPUT_COUNT, 1) output = model.predict_output(inp).reshape(len(data.files[i]), INPUT_COUNT) data.write_wav(f"output-lstm-{MODEL_ID}-{i}.wav", output)
def init_tensorflow(seed, use_float16=False): if use_float16: import keras.backend as K dtype = 'float16' K.set_floatx(dtype) K.set_epsilon(1e-4) # Solves an issue with regard to the use of newest CUDA versions from tensorflow.compat.v1 import ConfigProto from tensorflow.compat.v1 import InteractiveSession config = ConfigProto() config.gpu_options.allow_growth = True _ = InteractiveSession(config=config) tf.random.set_seed(seed)
def main(): process_run = False model_run = True print(cpu_count()) np.random.seed(17) if process_run: process_data() # K.set_image_dim_ordering('th') if model_run: # read in data train_data = np.load('train.npy') train_target = np.load('train_target.npy') # split data x_train, x_val_train, y_train, y_val_train = train_test_split( train_data, train_target, test_size=0.4, random_state=17) # Image preprocessing, rotating images and performing random zooms datagen = ImageDataGenerator(rotation_range=0.9, zoom_range=0.3) datagen.fit(train_data) # Create Image model K.set_floatx('float32') model = create_model() model.fit_generator(datagen.flow(x_train, y_train, batch_size=15, shuffle=True), nb_epoch=200, samples_per_epoch=len(x_train), verbose=20, validation_data=(x_val_train, y_val_train)) # Load processed data test_data = np.load('test.npy') test_id = np.load('test_id.npy') # run classification pred = model.predict_proba(test_data) df = pd.DataFrame(pred, columns=['Type_1', 'Type_2', 'Type_3']) df['image_name'] = test_id df.to_csv( '~/kaggle_intel_mobileODT_cervix_classification/submission.csv', index=False)
def __init__(self): self.config_filename = yml_filename args = parse_args(self.config_filename) with open(args.config_file) as fp: config = yaml.safe_load(fp) " Parameters " self.input_timesteps = config["input_timesteps"] # Network input size self.buff_size = config["output_timesteps"] # buff size self.fs = config["Fs"] # sampling frequency [Hz] self.set_float = config["set_float"] # betowrk data format self.data_format = pyaudio.paInt16 # bir rate (16bit) self.ch_num = 1 # channel num (default: mono) self.buff_hold = np.zeros(self.input_timesteps, dtype=np.float32) # Load WaveNet K.set_floatx(self.set_float) self.wavenet = WaveNet(yml_filename) self.wavenet.Model_Loader("test", h5_path) self.wavenet.Load_Model(h5_path) self.p = pyaudio.PyAudio() self.index_list = [] self.Show_Device_Information() device_num = 12 # get device num while (True): device_num = int(input("device index>>>")) if (device_num in self.index_list): break else: print("input is wrong.") # open stream self.stream = self.p.open( format=self.data_format, rate=self.fs, channels=self.ch_num, frames_per_buffer=self.buff_size, # buff size input=True, input_device_index=device_num, # input information output=True, output_device_index=device_num) # output information # start stream self.stream.start_stream()
def get_generator(self, model_type): if model_type == 0: model_loc = self.model_path + '/harmonic_model.h5' temp = args.h_parser.parse_args().temp else: model_loc = self.model_path + '/aperiodic_model.h5' temp = args.a_parser.parse_args().temp if not os.path.isfile(model_loc): sys.exit('Cannot find model :' + model_loc) else: K.set_floatx('float64') model = load_model(model_loc, compile=False) sample_layer = Lambda(self.sample_output, name="sample_layer", arguments={'temp': temp})(model.output) generator = Model(model.input, sample_layer) return generator
def test_set_floatx(self): """ Make sure that changes to the global floatx are effectively taken into account by the backend. """ # Keep track of the old value old_floatx = floatx() set_floatx('float16') var = variable([10]) check_dtype(var, 'float16') set_floatx('float64') var = variable([10]) check_dtype(var, 'float64') # Restore old value set_floatx(old_floatx)
from keras.wrappers.scikit_learn import KerasClassifier from keras.models import Sequential from keras.layers.core import Dense, Dropout, Flatten, Activation from keras.layers.convolutional import Convolution2D, ZeroPadding2D, MaxPooling2D from keras import optimizers from keras.preprocessing.image import ImageDataGenerator from sklearn.model_selection import train_test_split from keras import backend as K from keras.optimizers import SGD from keras.callbacks import EarlyStopping from keras.utils import np_utils from sklearn.metrics import log_loss K.set_image_dim_ordering('th') K.set_floatx('float32') import pandas as pd import numpy as np np.random.seed(17) train_data = np.load('train.npy') train_target = np.load('train_target.npy') x_train,x_val_train,y_train,y_val_train = train_test_split(train_data,train_target,test_size=0.4, random_state=17) def create_model(opt_='adamax'): model = Sequential() model.add(ZeroPadding2D((1, 1), input_shape=(3, 32, 32), dim_ordering='th')) model.add(Convolution2D(4, 3, 3, activation='relu', dim_ordering='th')) model.add(ZeroPadding2D((1, 1), dim_ordering='th'))
from keras.optimizers import Adam import glob import keras.backend as K import os.path import rfutils import sys gl = glob.glob(os.path.join('train', '*.[sf]')) poscount, locidx = rfutils.count_locpos(gl) embedding_dim = 4 dropout_prob = 0.4 dense_count = int(sys.argv[3]) if len(sys.argv) > 3 else 50 optr = Adam(lr=0.03) K.set_floatx('float64') in_vals = Input((poscount, 1), name='vals', dtype='float64') normd = BatchNormalization( axis=1, gamma_constraint=min_max_norm(), beta_constraint=min_max_norm())(in_vals) in_locs = Input((poscount, ), name='locs', dtype='uint64') embed_locs = Embedding( locidx.watermark, embedding_dim, input_length=poscount)(in_locs) merged = concatenate([embed_locs, normd]) dense_list = [] for i in range(dense_count): dense_list.append( Dropout(dropout_prob)(Dense(1, activation='sigmoid')(Flatten()( merged)))) mult = multiply(dense_list)