def define_model(self): input_img = Input(shape=( self.model_parameters.img_height, self.model_parameters.img_width, self.model_parameters.num_channels )) x = layers.Conv2D(filters=64, kernel_size=(3, 3), strides=(2, 2), padding='same')(input_img) x = layers.LeakyReLU()(x) x = layers.Conv2D(filters=128, kernel_size=(3, 3), strides=(2, 2), padding='same')(x) x = tfa.layers.InstanceNormalization(axis=-1)(x) x = layers.LeakyReLU()(x) x = layers.Conv2D(filters=256, kernel_size=(3, 3), strides=(2, 2), padding='same', )(x) x = tfa.layers.InstanceNormalization(axis=-1)(x) x = layers.LeakyReLU()(x) x = layers.Conv2D( filters=512, kernel_size=(3, 3), strides=(2, 2), padding='same', )(x) x = tfa.layers.InstanceNormalization(axis=-1)(x) x = layers.LeakyReLU()(x) x = layers.Conv2D(filters=512, kernel_size=(3, 3), strides=(2, 2), padding='same')(x) x = tfa.layers.InstanceNormalization(axis=-1)(x) x = layers.LeakyReLU()(x) x = layers.Flatten()(x) x = layers.Dense(units=1)(x) model = Model(name=self.model_name, inputs=input_img, outputs=x) return model
def create_model(self): z = Input(shape=[self.hidden_size]) x = layers.Dense(units=8 * 8 * 256, use_bias=False)(z) x = layers.BatchNormalization()(x) x = layers.LeakyReLU()(x) x = layers.Reshape((8, 8, 256))(x) x = layers.Conv2DTranspose(128, (5, 5), strides=(1, 1), padding='same', use_bias=False)(x) x = layers.BatchNormalization()(x) x = layers.LeakyReLU()(x) x = layers.Conv2DTranspose(128, (5, 5), strides=(2, 2), padding='same', use_bias=False)(x) x = layers.BatchNormalization()(x) x = layers.LeakyReLU()(x) x = layers.Conv2DTranspose(64, (5, 5), strides=(2, 2), padding='same', use_bias=False)(x) x = layers.BatchNormalization()(x) x = layers.LeakyReLU()(x) x = layers.Conv2DTranspose(3, (5, 5), strides=(2, 2), padding='same', use_bias=False, activation='tanh')(x) model = Model(name='Generator', inputs=z, outputs=x) return model
def make_generator_model(): model = tf.keras.Sequential() model.add(layers.Dense(7 * 7 * 256, use_bias=False, input_shape=(100, ))) model.add(layers.BatchNormalization()) model.add(layers.LeakyReLU()) model.add(layers.Reshape((7, 7, 256))) assert model.output_shape == (None, 7, 7, 256 ) # Note: None is the batch size model.add( layers.Conv2DTranspose(128, (5, 5), strides=(1, 1), padding='same', use_bias=False)) assert model.output_shape == (None, 7, 7, 128) model.add(layers.BatchNormalization()) model.add(layers.LeakyReLU()) model.add( layers.Conv2DTranspose(64, (5, 5), strides=(2, 2), padding='same', use_bias=False)) assert model.output_shape == (None, 14, 14, 64) model.add(layers.BatchNormalization()) model.add(layers.LeakyReLU()) model.add( layers.Conv2DTranspose(1, (5, 5), strides=(2, 2), padding='same', use_bias=False, activation='tanh')) assert model.output_shape == (None, 28, 28, 1) return model
def create_disc(Xt, Ct, img_shape=(32, 32, 3), filter_size=5, strides=[2, 2, 2, 2], filters=[64, 128, 256, 512]): with tf.name_scope("Disc"): X = kl.Input(img_shape, tensor=Xt, name="X") C = kl.Input(img_shape, tensor=Ct, name="C") layer = kl.concatenate([X, C], axis=1) layer = kl.GaussianNoise(stddev=0.1)(layer) # Discriminator layer = kl.Conv2D( filters=filters[0], kernel_size=filter_size, padding="same", strides=2)(layer) layer = kl.LeakyReLU()(layer) for l in range(1, len(filters)): conv = kl.Conv2D( filters=filters[l], kernel_size=filter_size, padding="same", strides=strides[l])(layer) layer = kl.LeakyReLU()(conv) layer = kl.Dropout(0.2)(layer) layer = kl.BatchNormalization()(layer) layer = kl.Flatten()(layer) D_out = kl.Dense(1, activation="sigmoid")(layer) model = k.Model(inputs=[X, C], outputs=D_out) return model
def make_discriminator_model(): """ Discriminator network structure. Returns: Sequential model. """ model = tf.keras.Sequential() model.add( layers.Conv2D(64, (5, 5), strides=(2, 2), padding='same', input_shape=[32, 32, 3])) model.add(layers.LeakyReLU()) model.add(layers.Dropout(rate=0.3)) model.add(layers.Conv2D(128, (5, 5), strides=(2, 2), padding='same')) model.add(layers.LeakyReLU()) model.add(layers.Dropout(rate=0.3)) model.add(layers.Flatten()) model.add(layers.Dense(1)) return model
def make_discriminator_model(): """ implements discriminate. Returns: model. """ model = tf.keras.Sequential() model.add( layers.Conv2D(64, (5, 5), strides=(2, 2), padding='same', input_shape=[28, 28, 1])) model.add(layers.LeakyReLU()) model.add(layers.Dropout(rate=0.3)) model.add(layers.Conv2D(128, (5, 5), strides=(2, 2), padding='same')) model.add(layers.LeakyReLU()) model.add(layers.Dropout(rate=0.3)) model.add(layers.Flatten()) model.add(layers.Dense(1)) return model
def make_discriminator_model(num_classes, color_ch=3): cnn = tf.keras.Sequential() cnn.add( layers.Conv2D(128, 4, padding='same', activity_regularizer=l2(1e-4), input_shape=(32, 32, color_ch))) cnn.add(layers.BatchNormalization()) cnn.add(layers.LeakyReLU()) cnn.add(layers.Dropout(0.15)) cnn.add( layers.Conv2D(256, 5, strides=2, padding='same', activity_regularizer=l2(1e-4))) cnn.add(layers.BatchNormalization()) cnn.add(layers.LeakyReLU()) cnn.add(layers.Dropout(0.15)) cnn.add( layers.Conv2D(128, 4, padding='same', activity_regularizer=l2(1e-4))) cnn.add(layers.BatchNormalization()) cnn.add(layers.LeakyReLU()) cnn.add(layers.Dropout(0.15)) cnn.add( layers.Conv2D(256, 5, strides=2, padding='same', activity_regularizer=l2(1e-4))) cnn.add(layers.BatchNormalization()) cnn.add(layers.LeakyReLU()) cnn.add(layers.Dropout(0.15)) cnn.add(layers.Flatten()) cnn.add(layers.Dense(256, activity_regularizer=l2(1e-4))) cnn.add(layers.BatchNormalization()) cnn.add(layers.LeakyReLU()) cnn.add(layers.Dropout(0.4)) cnn.add(layers.Dense(128, activity_regularizer=l2(1e-4))) cnn.add(layers.BatchNormalization()) cnn.add(layers.LeakyReLU()) cnn.add(layers.Dropout(0.3)) cnn.add(layers.Dense(num_classes, activation='softmax', name='auxiliary')) cnn.compile(optimizer=Adam(decay=1e-5), loss=cross_entropy, metrics=[sparse_categorical_accuracy]) return cnn
def encoder_block(a, n_filters): a = layers.Conv2D(filters=n_filters, kernel_size=(4, 4), padding='same', kernel_regularizer=regularizers.l1_l2( l1=Config.l1_kernel_regularization, l2=Config.l2_kernel_regularization))(a) a = layers.BatchNormalization()(a) a = layers.LeakyReLU()(a) a = layers.MaxPool2D(pool_size=(2, 2))(a) if Config.use_spatial_dropout: a = layers.SpatialDropout2D( rate=Config.spatial_dropout_rate)(a) return a
def CNN5(input_tensor, kr=0.01): """ CNN-5 :param input_tensor: :param kr: kernel regularizer rate :return: """ filters = [32, 64, 128, 128, 256] x = input_tensor for i in range(5): x = layers.Conv2D(filters[i], (3, 3), padding='same', kernel_regularizer=l2(kr))(x) x = layers.BatchNormalization()(x) x = layers.LeakyReLU(alpha=0.2)(x) if i == 0: x = layers.MaxPooling2D(pool_size=(2, 2), strides=(1, 1))(x) else: x = layers.MaxPooling2D(pool_size=(2, 2))(x) return x
def discriminator_and_classifier_model(c_dim): inputs = keras.Input(shape=(99,)) x = layers.Dense(1024, input_shape=(64,))(inputs) x = layers.BatchNormalization()(x) x = layers.ReLU()(x) x = layers.Dense(512)(x) x = layers.BatchNormalization()(x) x = layers.ReLU()(x) x = layers.Dense(256)(x) x = layers.BatchNormalization()(x) x = layers.ReLU()(x) d_out = layers.Dense(1)(x) x = layers.Dense(256)(x) x = layers.LeakyReLU()(x) q_out = layers.Dense(c_dim)(x) return keras.Model(inputs=inputs, outputs=d_out), keras.Model(inputs=inputs, outputs=q_out)
def discriminator_2d(): initializer = random_normal_initializer(0., 0.02) inputs = layers.Input(shape=[20, 49, 1]) x = downsample(32, input_shape=[20, 49, 1], layer_type='conv')(inputs) x = downsample(64, input_shape=[10, 25, 32], layer_type='conv')(x) x = downsample(128, input_shape=[5, 13, 64], layer_type='conv')(x) x = layers.Conv2D(256, kernel_size=3, strides=1, kernel_initializer=initializer, use_bias=False, padding='same')(x) x = layers.BatchNormalization()(x) x = layers.LeakyReLU()(x) x = layers.Conv2D(1, kernel_size=3, strides=1, kernel_initializer=initializer, padding='same')(x) return Model(inputs, x)
def create_classifier(): with tf.name_scope("Disc"): X = kl.Input((32, 32, 3), name="X") layer = X for l in range(4): layer = kl.Conv2D( filters=32 * (2**l), kernel_size=3, padding="same", use_bias=False, activation="relu", kernel_regularizer=kr.l2())(layer) layer = kl.BatchNormalization()(layer) layer = kl.Conv2D( filters=32 * (2**l), kernel_size=3, padding="same", use_bias=False, activation="relu", kernel_regularizer=kr.l2())(layer) layer = kl.BatchNormalization()(layer) layer = kl.MaxPool2D()(layer) layer = kl.Dropout(0.5)(layer) layer = kl.Flatten()(layer) layer = kl.Dense(600, kernel_regularizer=kr.l2())(layer) layer = kl.LeakyReLU()(layer) layer = kl.Dropout(0.5)(layer) D_out = kl.Dense(10, activation="softmax", kernel_regularizer=kr.l2())(layer) model = k.Model(inputs=X, outputs=D_out) fidmodel = k.Model(inputs=X, outputs=layer) return model, fidmodel
def create_model(self): # input_img = Input(shape=(self.img_height, self.img_width, self.num_channels)) input_text = Input(shape=self.max_sequence_length) input_image = Input(shape=(self.img_height, self.img_width, self.num_channels)) embedded_id = layers.Embedding(self.vocab_size, self.embedding_size)(input_text) embedded_id = layers.Flatten()(embedded_id) embedded_id = layers.Dense(units=input_image.shape[1] * input_image.shape[2])(embedded_id) embedded_id = layers.Reshape(target_shape=(input_image.shape[1], input_image.shape[2], 1))(embedded_id) x = layers.Concatenate(axis=3)([input_image, embedded_id]) x = layers.Conv2D( filters=64, kernel_size=(4, 4), strides=(2, 2), padding='same', )(input_image) x = layers.LeakyReLU()(x) x = layers.Conv2D( filters=128, kernel_size=(4, 4), strides=(2, 2), padding='same', )(x) x = tfa.layers.InstanceNormalization(axis=-1)(x) x = layers.LeakyReLU()(x) x = layers.Conv2D( filters=256, kernel_size=(4, 4), strides=(2, 2), padding='same', )(x) x = tfa.layers.InstanceNormalization(axis=-1)(x) x = layers.LeakyReLU()(x) x = layers.ZeroPadding2D()(x) x = layers.Conv2D( filters=512, kernel_size=(4, 4), strides=(1, 1), padding='valid', )(x) x = tfa.layers.InstanceNormalization(axis=-1)(x) x = layers.LeakyReLU()(x) x = layers.ZeroPadding2D()(x) x = layers.Conv2D( filters=1, kernel_size=(4, 4), strides=(1, 1), padding='valid', )(x) model = Model(name='discriminator', inputs=[input_text, input_image], outputs=x) return model
if not os.path.isdir(model_dir): continue model = load_model(model_dir) else: #input_tensor = Input(shape=(30,4,1)) input_tensor = Input(shape=(input_size, 4, 1)) layer_x = layers.Conv2D( 16, (1, 4), kernel_regularizer=regularizers.l1(l=regularizer), kernel_initializer="zeros", bias_initializer="zeros")(input_tensor) layer_x = layers.BatchNormalization()(layer_x) layer_x = layers.LeakyReLU(alpha=0.01)(layer_x) layer_x = layers.Conv2D( 16, (4, 1), padding='same', kernel_regularizer=regularizers.l1(l=regularizer), kernel_initializer="zeros", bias_initializer="zeros")(layer_x) layer_x = layers.BatchNormalization()(layer_x) layer_x = layers.LeakyReLU(alpha=0.01)(layer_x) layer_x = layers.Conv2D( 16, (4, 1), padding='same', kernel_regularizer=regularizers.l1(l=regularizer), kernel_initializer="zeros",
def define_model(self): z = Input(shape=[self.model_parameters.latent_size]) class_id = Input(shape=[1]) embedded_id = layers.Embedding(input_dim=10, output_dim=50)(class_id) embedded_id = layers.Dense(units=8 * 8)(embedded_id) embedded_id = layers.Reshape(target_shape=(8, 8, 1))(embedded_id) x = layers.Dense(units=8 * 8 * 256, use_bias=False)(z) x = layers.BatchNormalization(momentum=0.9)(x) x = layers.LeakyReLU(alpha=0.1)(x) x = layers.Reshape((8, 8, 256))(x) inputs = layers.Concatenate(axis=3)([x, embedded_id]) x = layers.Conv2DTranspose(128, kernel_size=(4, 4), strides=(2, 2), padding='same', use_bias=False)(inputs) x = layers.BatchNormalization(momentum=0.9)(x) x = layers.LeakyReLU(alpha=0.1)(x) x = layers.Conv2D(128, kernel_size=(5, 5), strides=(1, 1), padding='same', use_bias=False)(x) x = layers.BatchNormalization(momentum=0.9)(x) x = layers.LeakyReLU(alpha=0.1)(x) x = layers.Conv2DTranspose(128, kernel_size=(4, 4), strides=(2, 2), padding='same', use_bias=False)(x) x = layers.BatchNormalization(momentum=0.9)(x) x = layers.LeakyReLU(alpha=0.1)(x) x = layers.Conv2D(128, kernel_size=(5, 5), strides=(1, 1), padding='same', use_bias=False)(x) x = layers.BatchNormalization(momentum=0.9)(x) x = layers.LeakyReLU(alpha=0.1)(x) x = layers.Conv2D(128, kernel_size=(5, 5), strides=(1, 1), padding='same', use_bias=False)(x) x = layers.BatchNormalization(momentum=0.9)(x) x = layers.LeakyReLU(alpha=0.1)(x) x = layers.Conv2D(3, kernel_size=(5, 5), strides=(1, 1), padding='same', use_bias=False, activation='tanh')(x) model = Model(name=self.model_name, inputs=[z, class_id], outputs=x) return model
#temporal input branch temporal_input_layer = Input(shape=(sequence_length, 7)) main_rnn_layer = layers.LSTM(64, return_sequences=True, recurrent_dropout=0.15)(temporal_input_layer) #demographic input branch demographic_input_layer = Input(shape=(18)) demographic_dense = layers.Dense(16)(demographic_input_layer) demographic_dropout = layers.Dropout(0.15)(demographic_dense) rnn_c = layers.LSTM(32)(main_rnn_layer) merge_c = layers.Concatenate(axis=-1)([rnn_c, demographic_dropout]) dense_c = layers.Dense(128)(merge_c) dropout_c = layers.Dropout(0.3)(dense_c) precases = layers.Dense(1, activation=layers.LeakyReLU(alpha=0.25), name="precases")(dropout_c) rnn_f = layers.LSTM(32)(main_rnn_layer) merge_f = layers.Concatenate(axis=-1)([rnn_f, demographic_dropout]) dense_f = layers.Dense(128)(merge_f) dropout_f = layers.Dropout(0.3)(dense_f) prefatalities = layers.Dense(1, activation=layers.LeakyReLU(alpha=0.25), name="prefatalities")(dropout_f) model = Model([temporal_input_layer, demographic_input_layer], [precases, prefatalities]) model.summary()
def define_model(self) -> keras.Model: x = Input(shape=[ self.model_parameters.img_height, self.model_parameters.img_width, self.model_parameters.num_channels ]) z = Input(shape=[ self.model_parameters.img_height, self.model_parameters.img_width, self.model_parameters.num_channels ]) xz = z if self.model_parameters.has_input_images: xz += x xz = layers.Conv2D( filters=32, kernel_size=(3, 3), padding='same', use_bias=False, )(xz) xz = layers.BatchNormalization()(xz) xz = layers.LeakyReLU(alpha=0.2)(xz) xz = layers.Conv2D( filters=32, kernel_size=(3, 3), padding='same', use_bias=False, )(xz) xz = layers.BatchNormalization()(xz) xz = layers.LeakyReLU(alpha=0.2)(xz) xz = layers.Conv2D( filters=32, kernel_size=(3, 3), padding='same', use_bias=False, )(xz) xz = layers.BatchNormalization()(xz) xz = layers.LeakyReLU(alpha=0.2)(xz) xz = layers.Conv2D( filters=32, kernel_size=(3, 3), padding='same', use_bias=False, )(xz) xz = layers.BatchNormalization()(xz) xz = layers.LeakyReLU(alpha=0.2)(xz) xz = layers.Conv2D( filters=3, kernel_size=(3, 3), padding='same', activation='tanh', use_bias=False, )(xz) if self.model_parameters.has_input_images: xz += x model = Model(name=self.model_name, inputs=[x, z], outputs=xz) return model
def main(thread_num): # causing allocating 2 gpu devices # if tf.test.is_gpu_available(): # select gpu device 0,1 if device_type == 'gpu': os.environ["CUDA_VISIBLE_DEVICES"] = thread_num task = pd.read_csv("task.csv") #print(task) if os.path.isfile("output.csv"): output_csv = pd.read_csv("output.csv") else: output_csv = task output_csv = output_csv.drop(columns=['data_set']) #output_csv['train_acc'] = 0.0 output_csv['final_train_loss'] = 100.0 #output_csv['valid_acc'] = 0.0 output_csv['final_valid_loss'] = 100.0 output_csv['best_trade_acc'] = 0.0 output_csv['best_trade_acc_epoch'] = 0 output_csv['best_trade_f1'] = 0.0 output_csv['best_trade_f1_epoch'] = 0 output_csv['best_trade_precision'] = 0.0 output_csv['best_trade_precision_epoch'] = 0 output_csv['best_trade_recall'] = 0.0 output_csv['best_trade_recall_epoch'] = 0 # output_csv['best_trade_loss'] = 100.0 # output_csv['best_trade_loss_epoch'] = 0 output_csv['completed'] = 0 for index, row in task.iterrows(): #if tf.test.is_gpu_available(): if device_type == 'gpu': if index % 2 != int(thread_num): continue completed = output_csv['completed'][index] if completed == 1: continue data_set = int(task['data_set'][index]) load_dir = os.path.join(os.getcwd(), 'data_set/' + str(data_set)) if not os.path.isdir(load_dir): continue task_id = int(task['task_id'][index]) input_size = int(task['input'][index]) pred_k = int(task['k'][index]) feature_num = int(task['feature_num'][index]) label_threshold = float(task['label_threshold'][index]) lstm_units = int(task['lstm_units'][index]) lr = float(task['learning_rate'][index]) epsilon = float(task['epsilon'][index]) regularizer = float(task['regularizer'][index]) train_x = np.load(os.path.join(load_dir, 'train_x.npy')) train_y = np.load(os.path.join(load_dir, 'train_y_onehot.npy')) valid_x = np.load(os.path.join(load_dir, 'valid_x.npy')) valid_y = np.load(os.path.join(load_dir, 'valid_y_onehot.npy')) trade_y = np.load(os.path.join(load_dir, 'trading_valid_y_onehot.npy')) print('Running experiment {}'.format(task_id)) #clear previous models clear_session() model_dir = os.path.join(os.getcwd(), 'load_model') if os.path.isdir(model_dir): model_dir = os.path.join( model_dir, str(task_id) + '/model/model_epoch_500.h5') if not os.path.isdir(model_dir): continue model = load_model(model_dir) else: #input_tensor = Input(shape=(30,4,1)) input_tensor = Input(shape=(input_size, 4, 1)) layer_x = layers.Conv2D(16, (1, 4), kernel_regularizer=regularizers.l1( l=regularizer))(input_tensor) layer_x = layers.BatchNormalization()(layer_x) layer_x = layers.LeakyReLU(alpha=0.01)(layer_x) layer_x = layers.Conv2D( 16, (4, 1), padding='same', kernel_regularizer=regularizers.l1(l=regularizer))(layer_x) layer_x = layers.BatchNormalization()(layer_x) layer_x = layers.LeakyReLU(alpha=0.01)(layer_x) layer_x = layers.Conv2D( 16, (4, 1), padding='same', kernel_regularizer=regularizers.l1(l=regularizer))(layer_x) layer_x = layers.BatchNormalization()(layer_x) layer_x = layers.LeakyReLU(alpha=0.01)(layer_x) #dual input for ohlc+volume if feature_num == 5: train_x_ohlc = train_x[:, :, :4, :] train_x_volume = train_x[:, :, -1:, :] train_x = [train_x_ohlc, train_x_volume] valid_x_ohlc = valid_x[:, :, :4, :] valid_x_volume = valid_x[:, :, -1:, :] valid_x = [valid_x_ohlc, valid_x_volume] input_tensor2 = Input(shape=(input_size, 1, 1)) layer_x2 = layers.Conv2D(16, (1, 1), kernel_regularizer=regularizers.l1( l=regularizer))(input_tensor2) layer_x2 = layers.BatchNormalization()(layer_x2) layer_x2 = layers.LeakyReLU(alpha=0.01)(layer_x2) layer_x2 = layers.Conv2D(16, (4, 1), padding='same', kernel_regularizer=regularizers.l1( l=regularizer))(layer_x2) layer_x2 = layers.BatchNormalization()(layer_x2) layer_x2 = layers.LeakyReLU(alpha=0.01)(layer_x2) layer_x2 = layers.Conv2D(16, (4, 1), padding='same', kernel_regularizer=regularizers.l1( l=regularizer))(layer_x2) layer_x2 = layers.BatchNormalization()(layer_x2) layer_x2 = layers.LeakyReLU(alpha=0.01)(layer_x2) layer_x = layers.concatenate([layer_x, layer_x2], axis=-1) # Inception Module tower_1 = layers.Conv2D( 32, (1, 1), padding='same', kernel_regularizer=regularizers.l1(l=regularizer))(layer_x) tower_1 = layers.BatchNormalization()(tower_1) tower_1 = layers.LeakyReLU(alpha=0.01)(tower_1) tower_1 = layers.Conv2D( 32, (3, 1), padding='same', kernel_regularizer=regularizers.l1(l=regularizer))(tower_1) tower_1 = layers.BatchNormalization()(tower_1) tower_1 = layers.LeakyReLU(alpha=0.01)(tower_1) tower_2 = layers.Conv2D( 32, (1, 1), padding='same', kernel_regularizer=regularizers.l1(l=regularizer))(layer_x) tower_2 = layers.BatchNormalization()(tower_2) tower_2 = layers.LeakyReLU(alpha=0.01)(tower_2) tower_2 = layers.Conv2D( 32, (5, 1), padding='same', kernel_regularizer=regularizers.l1(l=regularizer))(tower_2) tower_2 = layers.BatchNormalization()(tower_2) tower_2 = layers.LeakyReLU(alpha=0.01)(tower_2) tower_3 = layers.MaxPooling2D((3, 1), padding='same', strides=(1, 1))(layer_x) tower_3 = layers.Conv2D( 32, (1, 1), padding='same', kernel_regularizer=regularizers.l1(l=regularizer))(tower_3) tower_3 = layers.BatchNormalization()(tower_3) tower_3 = layers.LeakyReLU(alpha=0.01)(tower_3) layer_x = layers.concatenate([tower_1, tower_2, tower_3], axis=-1) # concatenate features of tower_1, tower_2, tower_3 layer_x = layers.Reshape((input_size, 96))(layer_x) #layer_x = layers.Reshape((input_size,feature_num))(input_tensor) # # 64 LSTM units #layer_x = layers.LSTM(64)(layer_x) # if using GPU if device_type == 'gpu': print('using GPU') layer_x = layers.CuDNNLSTM( lstm_units, kernel_regularizer=regularizers.l1(l=regularizer))(layer_x) # if using CPU elif device_type == 'cpu': print('using CPU') layer_x = layers.LSTM( lstm_units, kernel_regularizer=regularizers.l1(l=regularizer))(layer_x) else: sys.exit("wrong device type") # # The last output layer uses a softmax activation function output = layers.Dense(3, activation='softmax')(layer_x) if feature_num == 4: model = Model(input_tensor, output) elif feature_num == 5: model = Model([input_tensor, input_tensor2], output) opt = Adam(lr=lr, epsilon=epsilon) model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=['accuracy']) #model.summary() save_dir = os.path.join(os.getcwd(), 'result/' + str(task_id)) if not os.path.isdir(save_dir): os.makedirs(save_dir) final_train_loss, \ final_valid_loss, \ best_trade_acc, \ best_trade_acc_epoch, \ best_trade_f1, \ best_trade_f1_epoch, \ best_trade_precision, \ best_trade_precision_epoch, \ best_trade_recall, \ best_trade_recall_epoch \ = train_model(model, \ save_dir, \ task_id, \ train_x, \ train_y, \ valid_x, \ valid_y, \ trade_y, \ batch_size=512, \ epochs=3) with open(os.path.join(save_dir, 'readme.txt'), 'w') as f: f.write("""'task id = {}\n input size = {}\n prediction k = {}\n feature = {}\n label threshold = {}\n lstm units = {}\n learning rate = {}\n epsilon = {}\n regularizer = {}\n data set = {}'""".format(task_id, \ input_size, \ pred_k, \ feature_num, \ label_threshold, \ lstm_units, \ lr, \ epsilon, \ regularizer, \ data_set)) #output_csv['train_acc'][index] = train_acc output_csv['final_train_loss'][index] = final_train_loss #output_csv['valid_acc'][index] = valid_acc output_csv['final_valid_loss'][index] = final_valid_loss output_csv['best_trade_acc'][index] = best_trade_acc output_csv['best_trade_acc_epoch'][index] = best_trade_acc_epoch output_csv['best_trade_f1'][index] = best_trade_f1 output_csv['best_trade_f1_epoch'][index] = best_trade_f1_epoch output_csv['best_trade_precision'][index] = best_trade_precision output_csv['best_trade_precision_epoch'][ index] = best_trade_precision_epoch output_csv['best_trade_recall'][index] = best_trade_recall output_csv['best_trade_recall_epoch'][index] = best_trade_recall_epoch #output_csv['best_trade_loss'] = best_trade_loss #output_csv['best_trade_loss_epoch'] = best_trade_loss_epoch output_csv['completed'][index] = 1 output_csv.to_csv('output.csv')
def create_model(self): input_images = Input(shape=[self.img_height, self.img_width, self.num_channels]) x1 = layers.Conv2D( filters=64, kernel_size=(7, 7), strides=(2, 2), padding='same', use_bias=False, )(input_images) x1 = tfa.layers.InstanceNormalization()(x1) x1 = layers.ReLU()(x1) x2 = layers.Conv2D( filters=128, kernel_size=(3, 3), strides=(2, 2), padding='same', use_bias=False, )(x1) x2 = tfa.layers.InstanceNormalization()(x2) x2 = layers.ReLU()(x2) x3 = layers.Conv2D( filters=256, kernel_size=(3, 3), strides=(2, 2), padding='same', use_bias=False, )(x2) x3 = tfa.layers.InstanceNormalization()(x3) x3 = layers.ReLU()(x3) x4 = layers.Conv2D( filters=512, kernel_size=(3, 3), strides=(2, 2), padding='same', use_bias=False, )(x3) x4 = tfa.layers.InstanceNormalization()(x4) x4 = layers.ReLU()(x4) x5 = layers.UpSampling2D()(x4) x5 = layers.Concatenate()([x5, x3]) x5 = layers.Conv2D( filters=256, kernel_size=(3, 3), strides=(1, 1), padding='same', use_bias=False, )(x5) x5 = tfa.layers.InstanceNormalization()(x5) x5 = layers.LeakyReLU(alpha=0.2)(x5) x6 = layers.UpSampling2D()(x5) x6 = layers.Concatenate()([x6, x2]) x6 = layers.Conv2D( filters=128, kernel_size=(3, 3), strides=(1, 1), padding='same', use_bias=False, )(x6) x6 = tfa.layers.InstanceNormalization()(x6) x6 = layers.LeakyReLU(alpha=0.2)(x6) x7 = layers.UpSampling2D()(x6) x7 = layers.Concatenate()([x7, x1]) x7 = layers.Conv2D( filters=64, kernel_size=(3, 3), strides=(1, 1), padding='same', use_bias=False, )(x7) x7 = tfa.layers.InstanceNormalization()(x7) x7 = layers.LeakyReLU(alpha=0.2)(x7) x8 = layers.UpSampling2D()(x7) x8 = layers.Concatenate()([x8, input_images]) x8 = layers.Conv2D( filters=32, kernel_size=(3, 3), strides=(1, 1), padding='same', use_bias=False, )(x8) x8 = tfa.layers.InstanceNormalization()(x8) x8 = layers.LeakyReLU(alpha=0.2)(x8) x9 = layers.Conv2D( filters=3, kernel_size=(5, 5), strides=(1, 1), padding='same', use_bias=False, activation='tanh', )(x8) model = Model(name='Generator', inputs=input_images, outputs=x9) return model
def define_model(self): input_images = Input(shape=[ self.model_parameters.img_height, self.model_parameters.img_width, self.model_parameters.num_channels ]) x1 = layers.Conv2D( filters=64, kernel_size=(7, 7), strides=(2, 2), padding='same', use_bias=False, )(input_images) x1 = tfa.layers.InstanceNormalization()(x1) x1 = layers.ReLU()(x1) x2 = layers.Conv2D( filters=128, kernel_size=(3, 3), strides=(2, 2), padding='same', use_bias=False, )(x1) x2 = tfa.layers.InstanceNormalization()(x2) x2 = layers.ReLU()(x2) x3 = layers.Conv2D( filters=256, kernel_size=(3, 3), strides=(2, 2), padding='same', use_bias=False, )(x2) x3 = tfa.layers.InstanceNormalization()(x3) x3 = layers.ReLU()(x3) x4 = advanced_layers.densely_connected_residual_block(x3) x5 = layers.Concatenate()([x4, x3]) x5 = layers.Conv2D( filters=256, kernel_size=(3, 3), strides=(1, 1), padding='same', use_bias=False, )(x5) x5 = tfa.layers.InstanceNormalization()(x5) x5 = layers.LeakyReLU(alpha=0.2)(x5) x6 = layers.UpSampling2D()(x5) x6 = layers.Concatenate()([x6, x2]) x6 = layers.Conv2D( filters=128, kernel_size=(3, 3), strides=(1, 1), padding='same', use_bias=False, )(x6) x6 = tfa.layers.InstanceNormalization()(x6) x6 = layers.LeakyReLU(alpha=0.2)(x6) x7 = layers.UpSampling2D()(x6) x7 = layers.Concatenate()([x7, x1]) x7 = layers.Conv2D( filters=64, kernel_size=(3, 3), strides=(1, 1), padding='same', use_bias=False, )(x7) x7 = tfa.layers.InstanceNormalization()(x7) x7 = layers.LeakyReLU(alpha=0.2)(x7) x8 = layers.UpSampling2D()(x7) x8 = layers.Concatenate()([x8, input_images]) x8 = layers.Conv2D( filters=32, kernel_size=(3, 3), strides=(1, 1), padding='same', use_bias=False, )(x8) x8 = tfa.layers.InstanceNormalization()(x8) x8 = layers.LeakyReLU(alpha=0.2)(x8) x9 = layers.Conv2D( filters=3, kernel_size=(5, 5), strides=(1, 1), padding='same', use_bias=False, activation='tanh', )(x8) model = Model(name=self.model_name, inputs=input_images, outputs=x9) return model
def bn_act(x, act=True): x = layers.BatchNormalization()(x) if act == True: x = layers.LeakyReLU(alpha=0.3)(x) return x
def create_model(self): # inputs = Input(shape=[self.max_sequence_length, self.embedding_size]) z = Input(shape=[self.hidden_size]) captions = Input(shape=self.max_sequence_length) embeddings = layers.Embedding(self.vocab_size, self.embedding_size)(captions) embeddings = attention.multihead_attention_model(embeddings) embeddings = layers.Flatten()(embeddings) embeddings = layers.Dense(units=8 * 8 * 32, use_bias=False)(embeddings) embeddings = layers.BatchNormalization()(embeddings) embeddings = layers.LeakyReLU()(embeddings) embeddings = layers.Reshape((8, 8, 32))(embeddings) x = layers.Dense(units=8 * 8 * 256, use_bias=False)(z) x = layers.BatchNormalization()(x) x = layers.ReLU()(x) x = layers.Reshape((8, 8, 256))(x) x = layers.Concatenate(axis=3)([x, embeddings]) x = layers.UpSampling2D()(x) x = layers.Conv2D( filters=512, kernel_size=(3, 3), strides=(1, 1), padding='same', use_bias=False, )(x) x = layers.BatchNormalization()(x) x = layers.ReLU()(x) x = layers.UpSampling2D()(x) x = layers.Conv2D( filters=256, kernel_size=(3, 3), strides=(1, 1), padding='same', use_bias=False, )(x) x = layers.BatchNormalization()(x) x = layers.ReLU()(x) n_resnet = 6 for _ in range(n_resnet): x = resnet_block(256, x) x = layers.UpSampling2D()(x) x = layers.Conv2D( filters=256, kernel_size=(3, 3), strides=(1, 1), padding='same', use_bias=False, )(x) x = layers.BatchNormalization()(x) x = layers.ReLU()(x) x = layers.UpSampling2D()(x) x = layers.Conv2D( filters=128, kernel_size=(3, 3), strides=(1, 1), padding='same', use_bias=False, )(x) x = layers.BatchNormalization()(x) x = layers.ReLU()(x) x = layers.UpSampling2D()(x) x = layers.Conv2D( filters=64, kernel_size=(3, 3), strides=(1, 1), padding='same', use_bias=False, )(x) x = layers.BatchNormalization()(x) x = layers.ReLU()(x) x = layers.Conv2D( filters=3, kernel_size=(3, 3), strides=(1, 1), padding='same', use_bias=False, activation='tanh', )(x) # model = Model(name='Generator', inputs=z, outputs=x) model = Model(name='Generator', inputs=[z, captions], outputs=x) return model
def general_input(self): role1_actions = Input(shape=(self.input_steps, ), name='role1_actions') role2_actions = Input(shape=(self.input_steps, ), name='role2_actions') # 鉴于embedding就是onehot+全连接,这里加大embedding的size role1_actions_embedding = layers.Embedding( 512, 32, name='role1_actions_embedding')(role1_actions) role2_actions_embedding = layers.Embedding( 512, 32, name='role2_actions_embedding')(role2_actions) role1_energy = Input(shape=(self.input_steps, ), name='role1_energy') role1_energy_embedding = layers.Embedding( 5, 4, name='role1_energy_embedding')(role1_energy) role2_energy = Input(shape=(self.input_steps, ), name='role2_energy') role2_energy_embedding = layers.Embedding( 5, 4, name='role2_energy_embedding')(role2_energy) role1_baoqi = Input(shape=(self.input_steps, ), name='role1_baoqi') role1_baoqi_embedding = layers.Embedding( 2, 8, name='role1_baoqi_embedding')(role1_baoqi) role2_baoqi = Input(shape=(self.input_steps, ), name='role2_baoqi') role2_baoqi_embedding = layers.Embedding( 2, 8, name='role2_baoqi_embedding')(role2_baoqi) role_position = Input(shape=(self.input_steps, 4), name='role_x_y') # 感觉这种环境每次都不同,小批量数据bn可能不太稳定,需要测试 # 步长1 距离,步长2速度 role_position_1 = layers.Conv1D(filters=32, kernel_size=1, strides=1, padding='same')(role_position) role_position_2 = layers.Conv1D(filters=32, kernel_size=2, strides=1, padding='same')(role_position) # role_position_1 = BatchNormalization(name='bn_1')(role_position_1) # role_position_2 = BatchNormalization(name='bn_2')(role_position_2) role_position_1 = layers.LeakyReLU(0.05)(role_position_1) role_position_2 = layers.LeakyReLU(0.05)(role_position_2) actions_input = Input(shape=(self.action_steps, ), name='last_action') actions_embedding = layers.Embedding( self.action_num, 64, name='last_action_embedding')(actions_input) model_input = [ role1_actions, role2_actions, role1_energy, role2_energy, role_position, role1_baoqi, role2_baoqi, actions_input ] encoder_input = [ role1_actions_embedding, role2_actions_embedding, # normal_role_position, normal_role_distance, normal_role_abs_distance, role_position, role_position_1, role_position_2, role1_energy_embedding, role2_energy_embedding, role1_baoqi_embedding, role2_baoqi_embedding, ] decoder_output = actions_embedding return model_input, encoder_input, decoder_output
def _depthwise_conv_block(inputs, pointwise_conv_filters, alpha, depth_multiplier=1, strides=(1, 1), block_id=1): """Adds a depthwise convolution block. A depthwise convolution block consists of a depthwise conv, batch normalization, relu6, pointwise convolution, batch normalization and relu6 activation. # Arguments inputs: Input tensor of shape `(rows, cols, channels)` (with `channels_last` data format) or (channels, rows, cols) (with `channels_first` data format). pointwise_conv_filters: Integer, the dimensionality of the output space (i.e. the number of output filters in the pointwise convolution). alpha: controls the width of the network. - If `alpha` < 1.0, proportionally decreases the number of filters in each layer. - If `alpha` > 1.0, proportionally increases the number of filters in each layer. - If `alpha` = 1, default number of filters from the paper are used at each layer. depth_multiplier: The number of depthwise convolution output channels for each input channel. The total number of depthwise convolution output channels will be equal to `filters_in * depth_multiplier`. strides: An integer or tuple/list of 2 integers, specifying the strides of the convolution along the width and height. Can be a single integer to specify the same value for all spatial dimensions. Specifying any stride value != 1 is incompatible with specifying any `dilation_rate` value != 1. block_id: Integer, a unique identification designating the block number. # Input shape 4D tensor with shape: `(batch, channels, rows, cols)` if data_format='channels_first' or 4D tensor with shape: `(batch, rows, cols, channels)` if data_format='channels_last'. # Output shape 4D tensor with shape: `(batch, filters, new_rows, new_cols)` if data_format='channels_first' or 4D tensor with shape: `(batch, new_rows, new_cols, filters)` if data_format='channels_last'. `rows` and `cols` values might have changed due to stride. # Returns Output tensor of block. """ # channel_axis = 1 if backend.image_data_format() == 'channels_first' else -1 pointwise_conv_filters = int(pointwise_conv_filters * alpha) if strides == (1, 1): x = inputs else: x = layers.ZeroPadding2D(((1, 1), (1, 1)), name='conv_pad_%d' % block_id)(inputs) x = layers.DepthwiseConv2D((3, 3), padding='same' if strides == (1, 1) else 'valid', depth_multiplier=depth_multiplier, strides=strides, use_bias=False, name='conv_dw_%d' % block_id)(x) x = layers.BatchNormalization(name='conv_dw_%d_bn' % block_id)(x) x = layers.ReLU(name='conv_dw_%d_relu' % block_id)(x) x = layers.Conv2D(pointwise_conv_filters, (1, 1), padding='same', use_bias=False, strides=(1, 1), name='conv_pw_%d' % block_id)(x) x = layers.BatchNormalization(name='conv_pw_%d_bn' % block_id)(x) return layers.LeakyReLU(name='conv_pw_%d_relu' % block_id)(x)
def __init__(self, alpha=0.2): super(LeakyRelu, self).__init__() self.leaky_relu = layers.LeakyReLU(alpha=alpha)
def MobilenetConv2D(kernel, alpha, filters): last_block_filters = _make_divisible(filters * alpha, 8) return compose( kl.Conv2D(last_block_filters, kernel, padding='same', use_bias=False), kl.BatchNormalization(), kl.LeakyReLU())
def _conv_block(inputs, filters, alpha, kernel=(3, 3), strides=(1, 1)): """Adds an initial convolution layer (with batch normalization and relu6). # Arguments inputs: Input tensor of shape `(rows, cols, 3)` (with `channels_last` data format) or (3, rows, cols) (with `channels_first` data format). It should have exactly 3 inputs channels, and width and height should be no smaller than 32. E.g. `(224, 224, 3)` would be one valid value. filters: Integer, the dimensionality of the output space (i.e. the number of output filters in the convolution). alpha: controls the width of the network. - If `alpha` < 1.0, proportionally decreases the number of filters in each layer. - If `alpha` > 1.0, proportionally increases the number of filters in each layer. - If `alpha` = 1, default number of filters from the paper are used at each layer. kernel: An integer or tuple/list of 2 integers, specifying the width and height of the 2D convolution window. Can be a single integer to specify the same value for all spatial dimensions. strides: An integer or tuple/list of 2 integers, specifying the strides of the convolution along the width and height. Can be a single integer to specify the same value for all spatial dimensions. Specifying any stride value != 1 is incompatible with specifying any `dilation_rate` value != 1. # Input shape 4D tensor with shape: `(samples, channels, rows, cols)` if data_format='channels_first' or 4D tensor with shape: `(samples, rows, cols, channels)` if data_format='channels_last'. # Output shape 4D tensor with shape: `(samples, filters, new_rows, new_cols)` if data_format='channels_first' or 4D tensor with shape: `(samples, new_rows, new_cols, filters)` if data_format='channels_last'. `rows` and `cols` values might have changed due to stride. # Returns Output tensor of block. """ # channel_axis = 1 if backend.image_data_format() == 'channels_first' else -1 filters = int(filters * alpha) if tuple(strides) == (2, 2): x = layers.ZeroPadding2D(padding=((1, 1), (1, 1)), name='conv1_pad')(inputs) x = layers.Conv2D(filters, kernel, padding='valid', use_bias=False, strides=strides, name='conv1')(x) else: x = layers.Conv2D(filters, kernel, padding='same', use_bias=False, strides=strides, name='conv1')(inputs) x = layers.BatchNormalization(name='conv1_bn')(x) return layers.LeakyReLU(name='conv1_relu')(x)
def conv_block(input_tensor, num_filters): encoder = layers.Conv2D(num_filters, (3, 3), padding='same')(input_tensor) encoder = layers.BatchNormalization()(encoder) encoder = layers.LeakyReLU(alpha=0.3)(encoder) return encoder
dataset = mnist.MnistDataset(model_parameters) def validation_dataset(): return tf.random.normal( [model_parameters.batch_size, model_parameters.latent_size]) validation_dataset = validation_dataset() generator = sequential.SequentialModel(layers=[ keras.Input(shape=[model_parameters.latent_size]), layers.Dense(units=7 * 7 * 256, use_bias=False), layers.BatchNormalization(), layers.LeakyReLU(), layers.Reshape((7, 7, 256)), layers.Conv2DTranspose( 128, (5, 5), strides=(1, 1), padding='same', use_bias=False), layers.BatchNormalization(), layers.LeakyReLU(), layers.Conv2DTranspose( 64, (5, 5), strides=(2, 2), padding='same', use_bias=False), layers.BatchNormalization(), layers.LeakyReLU(), layers.Conv2DTranspose(1, (5, 5), strides=(2, 2), padding='same', use_bias=False, activation='tanh') ])
def DarknetConv2D_BN_Leaky(*args, **kwargs): """Darknet Convolution2D followed by BatchNormalization and LeakyReLU.""" no_bias_kwargs = {'use_bias': False} no_bias_kwargs.update(kwargs) return compose(DarknetConv2D(*args, **no_bias_kwargs), kl.BatchNormalization(), kl.LeakyReLU(alpha=0.1))