def test_one_alt_conv_cat_twice_fc(self):
# inp_seq -> C -> Concat -> D -> Concat -> D -> y
# inp_alt --^-----------^
inp_seq = tf.keras.Input((100, 4))
inp_alt = tf.keras.Input((10, ))
x = tf.keras.layers.Conv1D(20, 3)(inp_seq)
x = tf.keras.layers.Flatten()(x)
x = tf.keras.layers.Concatenate()([x, inp_alt])
x = tf.keras.layers.Dense(10)(x)
x = tf.keras.layers.Concatenate()([inp_alt, x])
x = tf.keras.layers.Dense(1)(x)
# both order of inputs
model1 = tf.keras.Model(inputs=[inp_seq, inp_alt], outputs=x)
model2 = tf.keras.Model(inputs=[inp_alt, inp_seq], outputs=x)
fast_ism_model1 = fastISM.FastISM(model1,
seq_input_idx=0,
test_correctness=False)
fast_ism_model2 = fastISM.FastISM(model2,
seq_input_idx=1,
test_correctness=False)
self.assertTrue(fast_ism_model1.test_correctness())
self.assertTrue(fast_ism_model2.test_correctness())
def test_one_alt_double_cat_three_out(self):
# test multiple outputs
# |----> D -> y1
# inp_seq -> C -> Concat ----> D -> D -> y2
# ^ |
# inp_alt -> D -|-> D ->Concat -> D -> y3
inp_seq = tf.keras.Input((100, 4))
inp_alt = tf.keras.Input((10, ))
x = tf.keras.layers.Conv1D(20, 3)(inp_seq)
x = tf.keras.layers.Flatten()(x)
y1 = tf.keras.layers.Dense(1)(x)
x_alt = tf.keras.layers.Dense(10)(inp_alt)
x = tf.keras.layers.Concatenate()([x, x_alt])
x_alt = tf.keras.layers.Dense(10)(x_alt)
x = tf.keras.layers.Dense(10)(x)
x_alt = tf.keras.layers.Concatenate()([x, x_alt])
y2 = tf.keras.layers.Dense(1)(x)
y3 = tf.keras.layers.Dense(1)(x_alt)
# both order of inputs
model1 = tf.keras.Model(inputs=[inp_seq, inp_alt],
outputs=[y1, y2, y3])
model2 = tf.keras.Model(inputs=[inp_alt, inp_seq],
outputs=[y1, y2, y3])
fast_ism_model1 = fastISM.FastISM(model1,
seq_input_idx=0,
test_correctness=False)
fast_ism_model2 = fastISM.FastISM(model2,
seq_input_idx=1,
test_correctness=False)
self.assertTrue(fast_ism_model1.test_correctness())
self.assertTrue(fast_ism_model2.test_correctness())
def test_two_alt_inp_conv_cat_fc(self):
# inp_alt1 -|
# inp_seq -> C -> Concat -> D -> y
# inp_alt2 --^
inp_seq = tf.keras.Input((100, 4))
inp_alt1 = tf.keras.Input((10, ))
inp_alt2 = tf.keras.Input((10, ))
x = tf.keras.layers.Conv1D(20, 3)(inp_seq)
x = tf.keras.layers.Flatten()(x)
x = tf.keras.layers.Concatenate()([x, inp_alt1, inp_alt2])
x = tf.keras.layers.Dense(1)(x)
# different order of inputs
model1 = tf.keras.Model(inputs=[inp_seq, inp_alt1, inp_alt2],
outputs=x)
model2 = tf.keras.Model(inputs=[inp_alt2, inp_seq, inp_alt1],
outputs=x)
model3 = tf.keras.Model(inputs=[inp_alt2, inp_alt1, inp_seq],
outputs=x)
fast_ism_model1 = fastISM.FastISM(model1,
seq_input_idx=0,
test_correctness=False)
fast_ism_model2 = fastISM.FastISM(model2,
seq_input_idx=1,
test_correctness=False)
fast_ism_model3 = fastISM.FastISM(model3,
seq_input_idx=2,
test_correctness=False)
self.assertTrue(fast_ism_model1.test_correctness())
self.assertTrue(fast_ism_model2.test_correctness())
self.assertTrue(fast_ism_model3.test_correctness())
def test_mini_dense_net_2(self):
# _________ ___________ _________ ___________
# ^ | ^ | ^ | ^ |
# inp -> C -> C-> Add -> C -> Add -> MXP -> C -> C-> Add -> C -> Add -> D -> y
# |____________________^ |____________________^
inp = tf.keras.Input((100, 4))
x = tf.keras.layers.Conv1D(20, 3)(inp)
x1 = tf.keras.layers.Conv1D(20, 3, padding='same')(x)
x1 = tf.keras.layers.Add()([x, x1])
x2 = tf.keras.layers.Conv1D(20, 5, padding='same')(x1)
x2 = tf.keras.layers.Add()([x, x1, x2])
x2 = tf.keras.layers.MaxPooling1D(3)(x2)
x2 = tf.keras.layers.Conv1D(10, 2)(x2)
x3 = tf.keras.layers.Conv1D(10, 7, padding='same')(x2)
x3 = tf.keras.layers.Maximum()([x2, x3])
x4 = tf.keras.layers.Conv1D(10, 4, padding='same')(x3)
x4 = tf.keras.layers.Add()([x2, x3, x4])
x4 = tf.keras.layers.Flatten()(x4)
y = tf.keras.layers.Dense(1)(x4)
model = tf.keras.Model(inputs=inp, outputs=y)
fast_ism_model = fastISM.FastISM(model, test_correctness=False)
self.assertTrue(fast_ism_model.test_correctness())
def test_input_split_complex(self):
# /- C -> MXP -> C -> MXP -> D -> y1
# inp \_ C -> MXP -> D -> D -> y2
# \_ C -> MXP -> D -> y3
inp = tf.keras.Input((100, 4))
# first row
x1 = tf.keras.layers.Conv1D(20, 3, dilation_rate=2)(inp)
x1 = tf.keras.layers.MaxPooling1D(2)(x1)
x11 = tf.keras.layers.Conv1D(20, 3, dilation_rate=3)(x1)
x11 = tf.keras.layers.MaxPooling1D(2)(x11)
x11f = tf.keras.layers.Flatten()(x11)
y1 = tf.keras.layers.Dense(5)(x11f)
# second row
x12 = tf.keras.layers.Conv1D(15, 2, padding='same',
activation='relu')(x1)
x12 = tf.keras.layers.MaxPooling1D(2)(x12)
x12f = tf.keras.layers.Flatten()(x12)
y2 = tf.keras.layers.Dense(5)(x12f)
y2 = tf.keras.layers.Dense(2, activation='tanh')(y2)
# third row
x2 = tf.keras.layers.Conv1D(10, 4, padding='same')(inp)
x2 = tf.keras.layers.MaxPool1D(3)(x2)
x2f = tf.keras.layers.Flatten()(x2)
y3 = tf.keras.layers.Dense(1)(x2f)
model = tf.keras.Model(inputs=inp, outputs=[y1, y2, y3])
fast_ism_model = fastISM.FastISM(model, test_correctness=False)
self.assertTrue(fast_ism_model.test_correctness())
def test_four_conv_maxpool_two_fc_4_10bp_change_range(self):
# inp -> C -> MXP -> C -> MXP -> C -> MXP -> C -> MXP -> D -> D -> y
# with Dropout and GlobalAveragePoolng1D
inp = tf.keras.Input((200, 4))
x = tf.keras.layers.Conv1D(10, 5, use_bias=False, padding='same')(inp)
x = tf.keras.layers.MaxPooling1D(2)(x)
x = tf.keras.layers.Conv1D(
25, 4, padding='same', activation='relu')(inp)
x = tf.keras.layers.Dropout(0.5)(x)
x = tf.keras.layers.MaxPooling1D(2)(x)
x = tf.keras.layers.Conv1D(30, 2, dilation_rate=2, use_bias=False,
padding='valid', activation='tanh')(x)
x = tf.keras.layers.MaxPooling1D(2)(x)
x = tf.keras.layers.Dropout(0.8)(x)
x = tf.keras.layers.Conv1D(10, 3, padding='same')(x)
x = tf.keras.layers.MaxPooling1D(2)(x)
x = tf.keras.layers.GlobalAveragePooling1D()(x)
x = tf.keras.layers.Dense(10)(x)
x = tf.keras.layers.Dropout(0.3)(x)
x = tf.keras.layers.Dense(1)(x)
model = tf.keras.Model(inputs=inp, outputs=x)
fast_ism_model = fastISM.FastISM(
model, change_ranges=[(i, i+10) for i in range(0, 200, 10)],
test_correctness=False)
self.assertTrue(fast_ism_model.test_correctness())
def test_bpnet_9_dilated_500(self):
model = bpnet_model(seqlen=500, num_dilated_convs=9)
fast_ism_model = fastISM.FastISM(model, test_correctness=False)
# seems to need lower numerical to always pass
self.assertTrue(fast_ism_model.test_correctness(atol=1e-5))
def test_four_conv_maxpool_two_fc_4_sequential(self):
# inp -> C -> MXP -> C -> MXP -> C -> MXP -> C -> MXP -> D -> D -> y
# with Dropout and GlobalAveragePoolng1D
# same as above but with Sequential
model = tf.keras.Sequential()
model.add(tf.keras.Input((200, 4)))
model.add(tf.keras.layers.Conv1D(
10, 5, use_bias=False, padding='same'))
model.add(tf.keras.layers.MaxPooling1D(2))
model.add(tf.keras.layers.Conv1D(
25, 4, padding='same', activation='relu'))
model.add(tf.keras.layers.Dropout(0.5))
model.add(tf.keras.layers.MaxPooling1D(2))
model.add(tf.keras.layers.Conv1D(30, 2, dilation_rate=2, use_bias=False,
padding='valid', activation='tanh'))
model.add(tf.keras.layers.MaxPooling1D(2))
model.add(tf.keras.layers.Dropout(0.8))
model.add(tf.keras.layers.Conv1D(10, 3, padding='same'))
model.add(tf.keras.layers.MaxPooling1D(2))
model.add(tf.keras.layers.GlobalAveragePooling1D())
model.add(tf.keras.layers.Dense(10))
model.add(tf.keras.layers.Dropout(0.3))
model.add(tf.keras.layers.Dense(1))
fast_ism_model = fastISM.FastISM(
model, test_correctness=False)
self.assertTrue(fast_ism_model.test_correctness())
def test_conv_dilated_fc(self):
# inp -> C -> D -> y
inp = tf.keras.Input((100, 4))
x = tf.keras.layers.Conv1D(20, 3, dilation_rate=3)(inp)
x = tf.keras.layers.Flatten()(x)
x = tf.keras.layers.Dense(1)(x)
model = tf.keras.Model(inputs=inp, outputs=x)
fast_ism_model = fastISM.FastISM(
model, test_correctness=False)
self.assertTrue(fast_ism_model.test_correctness())
def test_conv_even_kernel_same_padding_fc(self):
# inp -> C -> D -> y
inp = tf.keras.Input((100, 4))
x = tf.keras.layers.Conv1D(20, 4, padding='same')(inp)
x = tf.keras.layers.Flatten()(x)
x = tf.keras.layers.Dense(1)(x)
model = tf.keras.Model(inputs=inp, outputs=x)
fast_ism_model = fastISM.FastISM(
model, test_correctness=False)
self.assertTrue(fast_ism_model.test_correctness())
def test_conv_fc_sequential(self):
# inp -> C -> D -> y
# same as above but with Sequential
model = tf.keras.Sequential()
model.add(tf.keras.Input((100, 4)))
model.add(tf.keras.layers.Conv1D(20, 3))
model.add(tf.keras.layers.Flatten())
model.add(tf.keras.layers.Dense(1))
fast_ism_model = fastISM.FastISM(
model, test_correctness=False)
self.assertTrue(fast_ism_model.test_correctness())
def test_conv_maxpool_fc(self):
# inp -> C -> MXP -> D -> y
inp = tf.keras.Input((100, 4))
x = tf.keras.layers.Conv1D(10, 7)(inp)
x = tf.keras.layers.MaxPooling1D(3)(x)
x = tf.keras.layers.Flatten()(x)
x = tf.keras.layers.Dense(2)(x)
model = tf.keras.Model(inputs=inp, outputs=x)
fast_ism_model = fastISM.FastISM(
model, test_correctness=False)
self.assertTrue(fast_ism_model.test_correctness())
def test_one_alt_inp_conv_add_error(self):
# inp_seq -> C -> Add -> D -> y
# inp_alt -> C -----^
#
# Currently not supported to mix alternate with seq
# before a STOP_LAYER. Should raise NotImplementedError
inp_seq = tf.keras.Input((100, 4))
inp_alt = tf.keras.Input((100, 4))
x1 = tf.keras.layers.Conv1D(20, 3)(inp_seq)
x2 = tf.keras.layers.Conv1D(20, 3)(inp_alt)
x = tf.keras.layers.Add()([x1, x2])
x = tf.keras.layers.Dense(1)(x)
# both order of inputs
model1 = tf.keras.Model(inputs=[inp_seq, inp_alt], outputs=x)
model2 = tf.keras.Model(inputs=[inp_alt, inp_seq], outputs=x)
with self.assertRaises(NotImplementedError):
fastISM.FastISM(model1, seq_input_idx=0, test_correctness=False)
with self.assertRaises(NotImplementedError):
fastISM.FastISM(model2, seq_input_idx=0, test_correctness=False)
def test_conv_two_fc(self):
# /- D -> y1
# inp -> C
# \_ D -> y2
inp = tf.keras.Input((100, 4))
x = tf.keras.layers.Conv1D(20, 3)(inp)
x = tf.keras.layers.Flatten()(x)
y1 = tf.keras.layers.Dense(1)(x)
y2 = tf.keras.layers.Dense(1)(x)
model = tf.keras.Model(inputs=inp, outputs=[y1, y2])
fast_ism_model = fastISM.FastISM(model, test_correctness=False)
self.assertTrue(fast_ism_model.test_correctness())
def test_conv_add_two_fc(self):
# inp -> C -> C-> Add -> D -> y
# |_______^
inp = tf.keras.Input((100, 4))
x = tf.keras.layers.Conv1D(20, 3)(inp)
x1 = tf.keras.layers.Conv1D(20, 3, padding='same')(x)
x = tf.keras.layers.Add()([x, x1])
x = tf.keras.layers.Flatten()(x)
y = tf.keras.layers.Dense(1)(x)
model = tf.keras.Model(inputs=inp, outputs=y)
fast_ism_model = fastISM.FastISM(model, test_correctness=False)
self.assertTrue(fast_ism_model.test_correctness())
def test_three_conv_two_fc(self):
# inp -> [ C -> M -> C -> M -> C -> M ] -> [ D -> D -> y ]
convs = conv_block()
fcs = fc_block()
inp = tf.keras.Input((108, 4))
x = convs(inp)
x = tf.keras.layers.Flatten()(x)
x = fcs(x)
model = tf.keras.Model(inputs=inp, outputs=x)
fast_ism_model = fastISM.FastISM(model, test_correctness=False)
self.assertTrue(fast_ism_model.test_correctness())
def test_input_split_conv_fc(self):
# /- C -> D -> y1
# inp
# \_ C -> D -> y2
inp = tf.keras.Input((100, 4))
x1 = tf.keras.layers.Conv1D(20, 3)(inp)
x2 = tf.keras.layers.Conv1D(10, 4)(inp)
x1f = tf.keras.layers.Flatten()(x1)
x2f = tf.keras.layers.Flatten()(x2)
y1 = tf.keras.layers.Dense(1)(x1f)
y2 = tf.keras.layers.Dense(1)(x2f)
model = tf.keras.Model(inputs=inp, outputs=[y1, y2])
fast_ism_model = fastISM.FastISM(model, test_correctness=False)
self.assertTrue(fast_ism_model.test_correctness())
def test_skip_then_mxp(self):
# _________
# ^ |
# inp -> C -> C-> Add -> MXP -> [without Flatten!] D -> y
# y has output dim [32,5] per example
inp = tf.keras.Input((100, 4))
x = tf.keras.layers.Conv1D(20, 3)(inp)
x1 = tf.keras.layers.Conv1D(20, 3, padding='same')(x)
x1 = tf.keras.layers.Add()([x, x1])
x2 = tf.keras.layers.MaxPooling1D(3)(x1)
y = tf.keras.layers.Dense(5)(x2)
model = tf.keras.Model(inputs=inp, outputs=y)
fast_ism_model = fastISM.FastISM(model, test_correctness=False)
self.assertTrue(fast_ism_model.test_correctness())
def test_mini_dense_net_1(self):
# _________ ___________
# ^ | ^ |
# inp -> C -> C-> Add -> C -> Add -> D -> y
# |____________________^
inp = tf.keras.Input((100, 4))
x = tf.keras.layers.Conv1D(20, 3)(inp)
x1 = tf.keras.layers.Conv1D(20, 3, padding='same')(x)
x1 = tf.keras.layers.Add()([x, x1])
x2 = tf.keras.layers.Conv1D(20, 5, padding='same')(x1)
x2 = tf.keras.layers.Add()([x, x1, x2])
x2 = tf.keras.layers.Flatten()(x2)
y = tf.keras.layers.Dense(1)(x2)
model = tf.keras.Model(inputs=inp, outputs=y)
fast_ism_model = fastISM.FastISM(model, test_correctness=False)
self.assertTrue(fast_ism_model.test_correctness())
def test_conv_res_mxp_two_fc(self):
# _________
# ^ |
# inp -> C [ -> C -> Add ] -> M -> [ D -> D -> y ]
res = res_block()
fcs = fc_block(input_shape=(36 * 20, ))
inp = tf.keras.Input((108, 4))
x = tf.keras.layers.Conv1D(20, 3, padding='same')(inp)
x = res(x)
x = tf.keras.layers.MaxPooling1D(3)(x)
x = tf.keras.layers.Flatten()(x)
x = fcs(x)
model = tf.keras.Model(inputs=inp, outputs=x)
fast_ism_model = fastISM.FastISM(model, test_correctness=False)
self.assertTrue(fast_ism_model.test_correctness())
def test_four_conv_maxpool_two_fc_1(self):
# inp -> C -> MXP -> C -> MXP -> C -> MXP -> C -> MXP -> D -> D -> y
inp = tf.keras.Input((200, 4))
x = tf.keras.layers.Conv1D(10, 7, padding='same')(inp)
x = tf.keras.layers.MaxPooling1D(2)(x)
x = tf.keras.layers.Conv1D(20, 4, padding='same')(inp)
x = tf.keras.layers.MaxPooling1D(2)(x)
x = tf.keras.layers.Conv1D(30, 2, padding='valid')(x)
x = tf.keras.layers.MaxPooling1D(2)(x)
x = tf.keras.layers.Conv1D(10, 6, padding='same')(x)
x = tf.keras.layers.MaxPooling1D(2)(x)
x = tf.keras.layers.Flatten()(x)
x = tf.keras.layers.Dense(20)(x)
x = tf.keras.layers.Dense(1)(x)
model = tf.keras.Model(inputs=inp, outputs=x)
fast_ism_model = fastISM.FastISM(
model, test_correctness=False)
self.assertTrue(fast_ism_model.test_correctness())
def test_conv_my_add_mxp_two_fc(self):
# _________
# ^ |
# inp -> C -> C ->[ Add ] -> M -> [ D -> D -> y ]
# testing a nested block that takes in multiple inputs
my_add = my_add_block()
fcs = fc_block(input_shape=(36 * 20, ))
inp = tf.keras.Input((108, 4))
x1 = tf.keras.layers.Conv1D(20, 3, padding='same')(inp)
x2 = tf.keras.layers.Conv1D(20, 3, padding='same')(x1)
y = my_add([x1, x2])
y = tf.keras.layers.MaxPooling1D(3)(y)
y = tf.keras.layers.Flatten()(y)
y = fcs(y)
model = tf.keras.Model(inputs=inp, outputs=y)
fast_ism_model = fastISM.FastISM(model, test_correctness=False)
self.assertTrue(fast_ism_model.test_correctness())
def test_four_conv_maxpool_two_fc_3(self):
# inp -> C -> MXP -> C -> MXP -> C -> MXP -> C -> MXP -> D -> D -> y
inp = tf.keras.Input((200, 4))
x = tf.keras.layers.Conv1D(10, 5, use_bias=False, padding='same')(inp)
x = tf.keras.layers.MaxPooling1D(2)(x)
x = tf.keras.layers.Conv1D(
25, 4, padding='same', activation='relu')(inp)
x = tf.keras.layers.MaxPooling1D(2)(x)
x = tf.keras.layers.Conv1D(30, 2, dilation_rate=2, use_bias=False,
padding='valid', activation='tanh')(x)
x = tf.keras.layers.MaxPooling1D(2)(x)
x = tf.keras.layers.Conv1D(10, 3, padding='same')(x)
x = tf.keras.layers.MaxPooling1D(2)(x)
x = tf.keras.layers.Flatten()(x)
x = tf.keras.layers.Dense(10)(x)
x = tf.keras.layers.Dense(1)(x)
model = tf.keras.Model(inputs=inp, outputs=x)
fast_ism_model = fastISM.FastISM(
model, test_correctness=False)
self.assertTrue(fast_ism_model.test_correctness())
def test_three_conv_maxpool_fc_per_conv(self):
# /- D -> y1
# inp -> C -> MX -> C -> MX -> C -> MX -> D -> y2
# \_ C -> D -> y3
inp = tf.keras.Input((100, 4))
x1 = tf.keras.layers.Conv1D(20, 3, padding='same')(inp)
x1 = tf.keras.layers.MaxPool1D(2)(x1)
x2 = tf.keras.layers.Conv1D(10, 4, padding='same')(x1)
x2 = tf.keras.layers.MaxPool1D(2)(x2)
x3 = tf.keras.layers.Conv1D(10, 3)(x2)
x3 = tf.keras.layers.MaxPool1D(3)(x3)
x1f = tf.keras.layers.Flatten()(x1)
x2f = tf.keras.layers.Flatten()(x2)
x3f = tf.keras.layers.Flatten()(x3)
y1 = tf.keras.layers.Dense(1)(x1f)
y2 = tf.keras.layers.Dense(1)(x2f)
y3 = tf.keras.layers.Dense(1)(x3f)
model = tf.keras.Model(inputs=inp, outputs=[y1, y2, y3])
fast_ism_model = fastISM.FastISM(model, test_correctness=False)
self.assertTrue(fast_ism_model.test_correctness())
def test_conv_my_sub_mxp_two_fc(self):
# TODO: fails as of now since inbound_edges does not contain
# the correct node order
# _________
# ^ |
# inp -> C -> C ->[ Sub ] -> M -> [ D -> D -> y ]
# testing a nested block that takes in multiple inputs
my_sub = my_sub_block()
fcs = fc_block(input_shape=(36 * 20, ))
inp = tf.keras.Input((108, 4))
x1 = tf.keras.layers.Conv1D(20, 3, padding='same')(inp)
x2 = tf.keras.layers.Conv1D(20, 3, padding='same')(x1)
y = my_sub([x1, x2])
y = tf.keras.layers.MaxPooling1D(3)(y)
y = tf.keras.layers.Flatten()(y)
y = fcs(y)
model = tf.keras.Model(inputs=inp, outputs=y)
fast_ism_model = fastISM.FastISM(model, test_correctness=False)
self.assertTrue(fast_ism_model.test_correctness())
def test_basset_200(self):
model = basset_model(seqlen=200)
fast_ism_model = fastISM.FastISM(model, test_correctness=False)
self.assertTrue(fast_ism_model.test_correctness())
def test_bpnet_5_dilated_500(self):
model = bpnet_model(seqlen=500, num_dilated_convs=5)
fast_ism_model = fastISM.FastISM(model, test_correctness=False)
self.assertTrue(fast_ism_model.test_correctness())
def test_factorized_basset_500(self):
model = factorized_basset_model(seqlen=500)
fast_ism_model = fastISM.FastISM(model, test_correctness=False)
self.assertTrue(fast_ism_model.test_correctness())
