def convert_functional_model(
model_config,
nonlinear_mxts_mode=\
NonlinearMxtsMode.DeepLIFT_GenomicsDefault,
verbose=True,
dense_mxts_mode=DenseMxtsMode.Linear,
conv_mxts_mode=ConvMxtsMode.Linear,
maxpool_deeplift_mode=default_maxpool_deeplift_mode,
layer_overrides={},
custom_conversion_funcs={}):
if (verbose):
print("nonlinear_mxts_mode is set to: " + str(nonlinear_mxts_mode))
converted_model_container = functional_container_conversion(
config=model_config,
name="",
verbose=verbose,
nonlinear_mxts_mode=nonlinear_mxts_mode,
dense_mxts_mode=dense_mxts_mode,
conv_mxts_mode=conv_mxts_mode,
maxpool_deeplift_mode=maxpool_deeplift_mode,
layer_overrides=layer_overrides,
custom_conversion_funcs=custom_conversion_funcs)
for output_layer in converted_model_container.output_layers:
output_layer.build_fwd_pass_vars()
return models.GraphModel(
name_to_layer=converted_model_container.name_to_deeplift_layer,
input_layer_names=converted_model_container.input_layer_names)
def convert_graph_model(model,
nonlinear_mxts_mode=NonlinearMxtsMode.DeepLIFT,
verbose=True,
dense_mxts_mode=DenseMxtsMode.Linear,
maxpool_deeplift_mode=default_maxpool_deeplift_mode,
auto_build_outputs=True):
name_to_blob = OrderedDict()
keras_layer_to_deeplift_blobs = OrderedDict()
keras_non_input_layers = []
#convert the inputs
for keras_input_layer_name in model.inputs:
keras_input_layer = model.inputs[keras_input_layer_name]
input_shape = keras_input_layer.get_config()['input_shape']
if (input_shape[0] is not None):
input_shape = [None] + [x for x in input_shape]
assert input_shape[0] is None #for the batch axis
deeplift_input_layer =\
blobs.Input(shape=input_shape, num_dims=None,
name=keras_input_layer_name)
name_to_blob[keras_input_layer_name] = deeplift_input_layer
keras_layer_to_deeplift_blobs[id(keras_input_layer)] =\
[deeplift_input_layer]
#convert the nodes/outputs
for layer_name, layer in list(model.nodes.items()):
conversion_function = layer_name_to_conversion_function(
layer.get_config()[KerasKeys.name])
keras_non_input_layers.append(layer)
deeplift_layers = conversion_function(
layer=layer,
name=layer_name,
verbose=verbose,
nonlinear_mxts_mode=nonlinear_mxts_mode,
dense_mxts_mode=dense_mxts_mode,
maxpool_deeplift_mode=maxpool_deeplift_mode)
deeplift.util.connect_list_of_layers(deeplift_layers)
keras_layer_to_deeplift_blobs[id(layer)] = deeplift_layers
for deeplift_layer in deeplift_layers:
name_to_blob[deeplift_layer.get_name()] = deeplift_layer
#connect any remaining things not connected to their inputs
for keras_non_input_layer in keras_non_input_layers:
deeplift_layers =\
keras_layer_to_deeplift_blobs[id(keras_non_input_layer)]
previous_keras_layer = get_previous_layer(keras_non_input_layer)
previous_deeplift_layer =\
keras_layer_to_deeplift_blobs[id(previous_keras_layer)][-1]
deeplift.util.apply_softmax_normalization_if_needed(
deeplift_layers[0], previous_deeplift_layer)
deeplift_layers[0].set_inputs(previous_deeplift_layer)
if (auto_build_outputs):
for layer in model.outputs.values():
layer_to_build = keras_layer_to_deeplift_blobs[id(layer)][-1]
layer_to_build.build_fwd_pass_vars()
return models.GraphModel(name_to_blob=name_to_blob,
input_layer_names=model.inputs.keys())
def convert_graph_model(model,
mxts_mode=MxtsMode.DeepLIFT,
auto_build_outputs=True):
name_to_blob = OrderedDict()
keras_layer_to_deeplift_blobs = OrderedDict()
keras_non_input_layers = []
#convert the inputs
for keras_input_layer_name in model.inputs:
keras_input_layer = model.inputs[keras_input_layer_name]
deeplift_input_layer =\
blobs.Input_FixedDefault(
default=0.0,
num_dims=(len(keras_input_layer.get_config()['input_shape'])+1),
name=keras_input_layer_name)
name_to_blob[keras_input_layer_name] = deeplift_input_layer
keras_layer_to_deeplift_blobs[id(keras_input_layer)] =\
[deeplift_input_layer]
#convert the nodes/outputs
for layer_name, layer in list(model.nodes.items()):
conversion_function = layer_name_to_conversion_function[
layer.get_config()[KerasKeys.name]]
deeplift_layers = conversion_function(layer=layer,
name=layer_name,
mxts_mode=mxts_mode)
connect_list_of_layers(deeplift_layers)
keras_layer_to_deeplift_blobs[id(layer)] = deeplift_layers
for deeplift_layer in deeplift_layers:
name_to_blob[deeplift_layer.get_name()] = deeplift_layer
keras_non_input_layers.append(layer)
#connect any remaining things not connected to their inputs
for keras_non_input_layer in keras_non_input_layers:
deeplift_layers =\
keras_layer_to_deeplift_blobs[id(keras_non_input_layer)]
previous_keras_layer = keras_non_input_layer.previous
previous_deeplift_layer =\
keras_layer_to_deeplift_blobs[id(previous_keras_layer)][-1]
apply_softmax_normalization_if_needed(deeplift_layers[0],
previous_deeplift_layer)
deeplift_layers[0].set_inputs(previous_deeplift_layer)
if (auto_build_outputs):
for layer in model.outputs.values():
layer_to_build = keras_layer_to_deeplift_blobs[id(layer)][-1]
layer_to_build.build_fwd_pass_vars()
return models.GraphModel(name_to_blob=name_to_blob,
input_layer_names=model.inputs.keys())
def convert_graph_model(model,
nonlinear_mxts_mode=NonlinearMxtsMode.DeepLIFT,
verbose=True,
dense_mxts_mode=DenseMxtsMode.Linear,
conv_mxts_mode=ConvMxtsMode.Linear,
maxpool_deeplift_mode=default_maxpool_deeplift_mode,
auto_build_outputs=True):
name_to_blob = OrderedDict()
keras_layer_to_deeplift_blobs = OrderedDict()
keras_non_input_layers = []
#convert the inputs
for keras_input_layer_name in model.inputs:
keras_input_layer = model.inputs[keras_input_layer_name]
input_shape = keras_input_layer.get_config()['input_shape']
if (input_shape[0] is not None):
input_shape = [None] + [x for x in input_shape]
assert input_shape[0] is None #for the batch axis
deeplift_input_layer =\
blobs.Input(shape=input_shape, num_dims=None,
name=keras_input_layer_name)
name_to_blob[keras_input_layer_name] = deeplift_input_layer
keras_layer_to_deeplift_blobs[id(keras_input_layer)] =\
[deeplift_input_layer]
#convert the nodes/outputs
for layer_name, layer in list(model.nodes.items()):
#need some special handling when previous layer
#is Merge as merge is not given its own node
if (type(get_previous_layer(layer)).__name__ == 'Merge'):
merge_layer = get_previous_layer(layer)
keras_non_input_layers.append(merge_layer)
deeplift_merge_layer = merge_conversion(layer=merge_layer,
name='merge_before_' +
layer_name,
verbose=verbose)
keras_layer_to_deeplift_blobs[id(merge_layer)] =\
deeplift_merge_layer
assert len(deeplift_merge_layer) == 1
name_to_blob[deeplift_merge_layer[0].get_name()] =\
deeplift_merge_layer[0]
#now for converting the actual layer
conversion_function = layer_name_to_conversion_function(
type(layer).__name__)
keras_non_input_layers.append(layer)
deeplift_layers = conversion_function(
layer=layer,
name=layer_name,
verbose=verbose,
nonlinear_mxts_mode=nonlinear_mxts_mode,
dense_mxts_mode=dense_mxts_mode,
conv_mxts_mode=conv_mxts_mode,
maxpool_deeplift_mode=maxpool_deeplift_mode)
deeplift.util.connect_list_of_layers(deeplift_layers)
keras_layer_to_deeplift_blobs[id(layer)] = deeplift_layers
for deeplift_layer in deeplift_layers:
name_to_blob[deeplift_layer.get_name()] = deeplift_layer
#connect any remaining things not connected to their inputs
for keras_non_input_layer in keras_non_input_layers:
deeplift_layers =\
keras_layer_to_deeplift_blobs[id(keras_non_input_layer)]
previous_keras_layers = get_previous_layer(keras_non_input_layer)
if (isinstance(previous_keras_layers, list)):
previous_deeplift_layers =\
[keras_layer_to_deeplift_blobs[id(x)][-1]
for x in previous_keras_layers]
deeplift_layers[0].set_inputs(previous_deeplift_layers)
else:
previous_deeplift_layer =\
keras_layer_to_deeplift_blobs[id(previous_keras_layers)][-1]
deeplift_layers[0].set_inputs(previous_deeplift_layer)
if (auto_build_outputs):
for layer in model.outputs.values():
layer_to_build = keras_layer_to_deeplift_blobs[id(layer)][-1]
layer_to_build.build_fwd_pass_vars()
return models.GraphModel(name_to_blob=name_to_blob,
input_layer_names=model.inputs.keys())
def convert_functional_model(
model,
nonlinear_mxts_mode=\
NonlinearMxtsMode.DeepLIFT_GenomicsDefault,
verbose=True,
dense_mxts_mode=DenseMxtsMode.Linear,
conv_mxts_mode=ConvMxtsMode.Linear,
maxpool_deeplift_mode=default_maxpool_deeplift_mode,
auto_build_outputs=True):
if (verbose):
print("nonlinear_mxts_mode is set to: " + str(nonlinear_mxts_mode))
keras_layer_name_to_keras_nodes = OrderedDict()
for keras_node_depth in sorted(model.nodes_by_depth.keys()):
keras_nodes_at_depth = model.nodes_by_depth[keras_node_depth]
for keras_node in keras_nodes_at_depth:
keras_layer_name = keras_node.outbound_layer.name
if (keras_layer_name not in keras_layer_name_to_keras_nodes):
keras_layer_name_to_keras_nodes[keras_layer_name] = []
keras_layer_name_to_keras_nodes[keras_layer_name]\
.append(keras_node)
name_to_blob = OrderedDict()
#for each node, we only know the input tensor ids. Thus, to figure out
#which nodes link to which ids, we need to create a mapping from output
#tensor ids to node ids (this is a many-to-one mapping as a single node
#can have multiple output tensors)
keras_tensor_id_to_node_id = {}
keras_node_id_to_deeplift_blobs = {}
for keras_layer_name in keras_layer_name_to_keras_nodes:
keras_nodes = keras_layer_name_to_keras_nodes[keras_layer_name]
num_nodes_for_layer = len(keras_nodes)
for i, keras_node in enumerate(keras_nodes):
#record the mapping from output tensor ids to node
for keras_tensor in keras_node.output_tensors:
keras_tensor_id_to_node_id[id(keras_tensor)] = id(keras_node)
#figure out what to call the deeplift layer based on whether
#there are multiple shared instances of the associated layer
if (num_nodes_for_layer == 1):
deeplift_layer_name = keras_layer_name
else:
deeplift_layer_name = keras_layer_name + "_" + str(i)
keras_layer = keras_node.outbound_layer
#convert the node
if (type(keras_layer).__name__ == "InputLayer"):
#there should be only one edition of each input layer
#so the deeplift layer name and keras layer name should
#converge
assert deeplift_layer_name == keras_layer.name
converted_deeplift_blobs = [
input_layer_conversion(keras_input_layer=keras_layer,
layer_name=deeplift_layer_name)
]
else:
conversion_function = layer_name_to_conversion_function(
type(keras_layer).__name__)
converted_deeplift_blobs = conversion_function(
layer=keras_layer,
name=deeplift_layer_name,
verbose=verbose,
nonlinear_mxts_mode=nonlinear_mxts_mode,
dense_mxts_mode=dense_mxts_mode,
conv_mxts_mode=conv_mxts_mode,
maxpool_deeplift_mode=maxpool_deeplift_mode)
deeplift.util.connect_list_of_layers(converted_deeplift_blobs)
#record the converted blobs in name_to_blob
for blob in converted_deeplift_blobs:
name_to_blob[blob.get_name()] = blob
#record the converted blobs in the node id -> blobs dict
keras_node_id_to_deeplift_blobs[id(keras_node)] =\
converted_deeplift_blobs
#link up all the blobs
for node_depth in sorted(model.nodes_by_depth.keys()):
for node in model.nodes_by_depth[node_depth]:
if (type(node.outbound_layer).__name__ != "InputLayer"):
input_node_ids = []
#map the input tensors of each node to the node ids
for input_tensor in node.input_tensors:
if id(input_tensor) not in input_node_ids:
input_node_ids.append(
keras_tensor_id_to_node_id[id(input_tensor)])
#map the node ids to deeplift blobs
#if a single node id translates into multiple deeplift blobs
#(eg, if the node came with an activation), take the last
#deeplift blob in the list.
input_deeplift_blobs = [
keras_node_id_to_deeplift_blobs[x][-1]
for x in input_node_ids
]
#if there is only one input blob, unlist
if (len(input_deeplift_blobs) == 1):
input_deeplift_blobs = input_deeplift_blobs[0]
#link the inputs
keras_node_id_to_deeplift_blobs[id(node)][0]\
.set_inputs(input_deeplift_blobs)
if (auto_build_outputs):
for output_node in model.nodes_by_depth[0]:
layer_to_build = keras_node_id_to_deeplift_blobs[id(
output_node)][-1]
layer_to_build.build_fwd_pass_vars()
return models.GraphModel(name_to_blob=name_to_blob,
input_layer_names=model.input_names)
