def spliceAI_model(input_shape, num_classes=3):
"""ResNet Version 2 Model builder [b]
Stacks of (1 x 1)-(3 x 3)-(1 x 1) BN-ReLU-Conv2D or also known as
bottleneck layer
First shortcut connection per layer is 1 x 1 Conv2D.
Second and onwards shortcut connection is identity.
At the beginning of each stage, the feature map size is halved (downsampled)
by a convolutional layer with strides=2, while the number of filter maps is
doubled. Within each stage, the layers have the same number filters and the
same filter map sizes.
Features maps sizes:
conv1 : 32x32, 16
stage 0: 32x32, 64
stage 1: 16x16, 128
stage 2: 8x8, 256
# Arguments
input_shape (tensor): shape of input image tensor
depth (int): number of core convolutional layers
num_classes (int): number of classes (CIFAR10 has 10)
# Returns
model (Model): Keras model instance
"""
# Start model definition.
num_filters_in = 16
num_res_blocks = 4
inputs = Input(shape=input_shape)
# v2 performs Conv2D with BN-ReLU on input before splitting into 2 paths
x = Conv1D(32, kernel_size=1, strides=1, padding='same', dilation_rate=1)(inputs)
y = Conv1D(32, kernel_size=1, strides=1, padding='same', dilation_rate=1)(inputs)
# RB 1: 32 11 1
for stack in range(4):
x = RB_block(x, num_filters=32, kernel_size=11, strides=1, activation='relu', dilation_rate=1)
y = keras.layers.add([x, y])
# RB 2: 32 11 4
for stack in range(4):
x = RB_block(x, num_filters=32, kernel_size=11, strides=1, activation='relu', dilation_rate=4)
y = keras.layers.add([x, y])
# RB 3: 32 21 10
for stack in range(4):
x = RB_block(x, num_filters=32, kernel_size=21, strides=1, activation='relu', dilation_rate=10)
x = Conv1D(32, kernel_size=1, strides=1, padding='same', dilation_rate=1)(x)
# now adding up what was shortcut from the prev layers
x = keras.layers.add([x, y])
x = Conv1D(3, kernel_size=1, strides=1, padding='same', dilation_rate=1)(x)
x = Dense(num_classes, activation='softmax')(x)
outputs = Cropping1D(cropping=(1000, 1000))(x)
model = Model(inputs=inputs, outputs=outputs)
return model
def getModelGivenModelOptionsAndWeightInits(args):
#default params (can be overwritten by providing model_params file as input to the training function)
filters = 1
conv1_kernel_size = 6
control_smoothing = [1, 50]
counts_loss_weight = 1
profile_loss_weight = 1
model_params = get_model_param_dict(args.model_params)
if 'filters' in model_params:
filters = int(model_params['filters'])
if 'conv1_kernel_size' in model_params:
conv1_kernel_size = int(model_params['conv1_kernel_size'])
if 'counts_loss_weight' in model_params:
counts_loss_weight = float(model_params['counts_loss_weight'])
if 'profile_loss_weight' in model_params:
profile_loss_weight = float(model_params['profile_loss_weight'])
print("params:")
print("filters:" + str(filters))
print("conv1_kernel_size:" + str(conv1_kernel_size))
print("counts_loss_weight:" + str(counts_loss_weight))
print("profile_loss_weight:" + str(profile_loss_weight))
#load the fixed weights
tobias_data_dnase_k562 = pickle.load(
open(
"/srv/scratch/annashch/bias_correction/enzymatic_bias/tobias/dnase/K562.filtered_AtacBias.pickle",
'rb'))
tobias_dnase_pssm_forward = np.transpose(
tobias_data_dnase_k562.bias['forward'].pssm[0:4])[:, [0, 2, 3, 1]]
conv1_pwm = np.expand_dims(tobias_dnase_pssm_forward, axis=-1)
conv1_bias = np.zeros((1, ))
conv1_frozen_weights = [conv1_pwm, conv1_bias]
#read in arguments
seed = args.seed
init_weights = args.init_weights
sequence_flank = args.tdb_input_flank[0]
num_tasks = args.num_tasks
seq_len = 2 * sequence_flank
out_flank = args.tdb_output_flank[0]
out_pred_len = 2 * out_flank
print(seq_len)
print(out_pred_len)
#define inputs
inp = Input(shape=(seq_len, 4), name='sequence')
# first convolution without dilation
first_conv = Conv1D(filters,
weights=conv1_frozen_weights,
kernel_size=conv1_kernel_size,
padding='valid',
activation='relu',
name='1st_conv')(inp)
profile_out_prebias_shape = int_shape(first_conv)
cropsize = int(profile_out_prebias_shape[1] / 2) - int(out_pred_len / 2)
if profile_out_prebias_shape[1] % 2 == 0:
crop_left = cropsize
crop_right = cropsize
else:
crop_left = cropsize
crop_right = cropsize + 1
print(crop_left)
print(crop_right)
profile_out_prebias = Cropping1D(
(crop_left, crop_right), name='prof_out_crop2match_output')(first_conv)
profile_out = Conv1D(filters=num_tasks,
kernel_size=1,
name="profile_predictions")(profile_out_prebias)
gap_combined_conv = GlobalAveragePooling1D(name='gap')(first_conv)
count_out = Dense(num_tasks,
name="logcount_predictions")(gap_combined_conv)
model = Model(inputs=[inp], outputs=[profile_out, count_out])
print("got model")
model.compile(optimizer=Adam(),
loss=[MultichannelMultinomialNLL(1), 'mse'],
loss_weights=[profile_loss_weight, counts_loss_weight])
print("compiled model")
return model
def get_model_linear_systems(input_profile_names, target_profile_names, scalar_input_names,
actuator_names, lookbacks, lookahead, profile_length, std_activation, **kwargs):
profile_inshape = (profile_lookback, profile_length)
actuator_inshape = (actuator_lookback + lookahead,)
num_profiles = len(input_profile_names)
num_targets = len(target_profile_names)
num_actuators = len(actuator_names)
profile_inputs = []
for i in range(num_profiles):
profile_inputs.append(
Input(profile_inshape, name='input_' + input_profile_names[i]))
if num_profiles > 1:
profiles = Concatenate(axis=-1)(profile_inputs)
else:
profiles = profile_inputs[0]
profile_response = Dense(
int(profile_length/2*num_profiles), activation=std_activation)(profiles)
profile_response = Dense(
int(profile_length/2*num_profiles), activation=std_activation)(profile_response)
if profile_lookback > 1:
profile_response = LSTM(int(profile_length/2*num_profiles), activation=std_activation,
recurrent_activation='hard_sigmoid',
return_sequences=True)(profile_response)
else:
profile_response = Dense(int(profile_length/2*num_profiles),
activation=std_activation)(profile_response)
profile_response = Dense(int(profile_length/2*num_profiles),
activation=std_activation)(profile_response)
actuator_inputs = []
actuators = []
for i in range(num_actuators):
actuator_inputs.append(
Input(actuator_inshape, name='input_' + actuator_names[i]))
actuators.append(
Reshape((actuator_lookback+lookahead, 1))(actuator_inputs[i]))
if num_actuators > 1:
actuators = Concatenate(axis=-1)(actuators)
else:
actuators = actuators[0]
actuator_response = Dense(
profile_lookback, activation=std_activation)(actuators)
actuator_response = Dense(
profile_lookback, activation=std_activation)(actuator_response)
actuator_response = LSTM(profile_lookback, activation=std_activation,
recurrent_activation='hard_sigmoid',
return_sequences=True)(actuator_response)
total_response = Dot(axes=(2, 1))([actuator_response, profile_response])
total_response = LSTM(int(profile_length/2*num_targets), activation=std_activation,
recurrent_activation='hard_sigmoid')(total_response)
total_response = Dense(int(profile_length*.75*num_targets),
activation=std_activation)(total_response)
total_response = Dense(profile_length*num_targets)(total_response)
total_response = Reshape((num_targets*profile_length, 1))(total_response)
targets = []
for i in range(num_targets):
targets.append(Cropping1D(cropping=(i*profile_length,
(num_targets-i-1)*profile_length))(total_response))
targets[i] = Reshape((profile_length,),
name='target_' + target_profile_names[i])(targets[i])
model = Model(inputs=profile_inputs+actuator_inputs, outputs=targets)
return model
def generator(self):
generator = Sequential()
# Input: 100 * 1
# Output: 33 * 32d
generator.add(
Dense(input_dim=self.z_dim,
units=self.gf_dim * 32 * 33,
kernel_initializer=RandomNormal(stddev=0.02)))
generator.add(LeakyReLU(0.2))
generator.add(
Reshape(target_shape=(33, self.gf_dim * 32),
input_shape=(self.gf_dim * 32 * 33, )))
# Input: 33 * 32d
# Output: 132 * 16d
generator.add(UpSampling1D(size=4))
generator.add(
Conv1D(filters=self.gf_dim * 16, kernel_size=25, padding='same'))
generator.add((LeakyReLU(0.2)))
# Input: 132 * 16d
# Output: 528 * 8d
generator.add(UpSampling1D(size=4))
generator.add(
Conv1D(filters=self.gf_dim * 8, kernel_size=25, padding='same'))
generator.add((LeakyReLU(0.2)))
# Input: 528 * 8d
# Output: 2112 * 4d
generator.add(UpSampling1D(size=4))
generator.add(
Conv1D(filters=self.gf_dim * 4, kernel_size=25, padding='same'))
generator.add((LeakyReLU(0.2)))
# Input: 2112 * 4d
# Output: 8448 * 2d
generator.add(UpSampling1D(size=4))
generator.add(
Conv1D(filters=self.gf_dim * 2, kernel_size=25, padding='same'))
generator.add((LeakyReLU(0.2)))
# Input: 8448 * 2d
# Output: 33792 * d
generator.add(UpSampling1D(size=4))
generator.add(
Conv1D(filters=self.gf_dim, kernel_size=25, padding='same'))
generator.add((LeakyReLU(0.2)))
# Input: 33792 * d
# Output: 135168 * 2
generator.add(UpSampling1D(size=4))
generator.add(
Conv1D(filters=self.output_shape[1],
kernel_size=25,
padding='same'))
generator.add((LeakyReLU(0.2)))
# Input: 135168 * 2
# Output: 132299 * 2
generator.add(Cropping1D((1434, 1435)))
generator.add(Activation('tanh'))
return generator
