def __init__(self, val=1.0, min_max=None, inputs=None, name=None, non_neg=None): inputs = to_list(inputs) if not all([isinstance(x, (Variable, Functional)) for x in inputs]): raise TypeError input_tensors, layers = [], [] for v in inputs: input_tensors += v.outputs layers += v.layers if non_neg is None: non_neg = True layers.append( ParameterBase(val=val, min_max=min_max, non_neg=non_neg, name=name)) if len(input_tensors) > 1: lay = Concatenate() lay.name = "conct_" + lay.name.split("_")[-1] lay_input = lay(input_tensors) else: lay_input = input_tensors[0] outputs = layers[-1](lay_input) super(Parameter, self).__init__(inputs=to_list(input_tensors), outputs=to_list(outputs), layers=to_list(layers))
def __init__(self, val=1.0, inputs=None, name=None, non_neg=None): inputs = to_list(inputs) if not all([isinstance(x, Variable) for x in inputs]): raise TypeError inputs_tensors, layers = [], [] for v in inputs: inputs_tensors += v.outputs layers += v.layers if non_neg is None: non_neg = True layers.append( Parameter(val=val, non_neg=non_neg, name=name) ) lay = Concatenate() lay.name = "conct_" + lay.name.split("_")[-1] lay_input = lay(inputs_tensors) outputs = layers[-1](lay_input) super(ToBeInferred, self).__init__( inputs=to_list(inputs_tensors), outputs=to_list(outputs), layers=to_list(layers) )
def __init__(self, fields=None, variables=None, hidden_layers=None, activation="linear", enrichment="linear", kernel_initializer=default_kernel_initializer, bias_initializer=default_bias_initializer, dtype=None, trainable=True, **kwargs): # check data-type. if dtype is None: dtype = K.floatx() elif not K.floatx() == dtype: K.set_floatx(dtype) # check for copy constructor. if all([x in kwargs for x in ('inputs', 'outputs', 'layers')]): self._inputs = kwargs['inputs'] self._outputs = kwargs['outputs'] self._layers = kwargs['layers'] return # prepares fields. fields = to_list(fields) if all([isinstance(fld, str) for fld in fields]): outputs = [ Field( name=fld, dtype=dtype, kernel_initializer=kernel_initializer, bias_initializer=bias_initializer, trainable=trainable, ) for fld in fields ] elif all([isinstance(fld, Field) for fld in fields]): outputs = fields else: raise TypeError('Please provide a "list" of field names of' + ' type "String" or "Field" objects.') # prepare inputs/outputs/layers. inputs = [] layers = [] variables = to_list(variables) if all([isinstance(var, Functional) for var in variables]): for var in variables: inputs += var.outputs for var in variables: for lay in var.layers: layers.append(lay) else: raise TypeError( "Input error: Please provide a `list` of `Functional`s. \n" "Provided - {}".format(variables)) # prepare hidden layers. if hidden_layers is None: hidden_layers = [] else: hidden_layers = to_list(hidden_layers) # Check and convert activation functions to proper format. assert not isinstance(activation, list), \ 'Expected an activation function name not a "list". ' afunc = get_activation(activation) # check enrichment functions. enrichment = to_list(enrichment) efuncs = get_activation(enrichment) # Input layers. if len(inputs) == 1: net_input = inputs[0] else: layer = Concatenate() layer.name = "conct_" + layer.name.split("_")[-1] net_input = layer(inputs) # Define the output network. net = [] for enrich in efuncs: net.append(net_input) for nLay, nNeuron in enumerate(hidden_layers): # Add the layer. layer = Dense( nNeuron, kernel_initializer=kernel_initializer, bias_initializer=bias_initializer, trainable=trainable, dtype=dtype, ) layer.name = "D{:d}b_".format(nNeuron) + layer.name.split( "_")[-1] layers.append(layer) net[-1] = layer(net[-1]) # Apply the activation. if nLay < len(hidden_layers) - 1 and afunc.__name__ != 'linear': layer = Activation(afunc) layer.name = "{}_".format( afunc.__name__) + layer.name.split("_")[-1] layers.append(layer) net[-1] = layer(net[-1]) # add the activations. if enrich.__name__ != 'linear': layer = Activation(enrich) layer.name = "{}_".format( enrich.__name__) + layer.name.split("_")[-1] layers.append(layer) net[-1] = layer(net[-1]) # store output layers. for out in outputs: layers.append(out) # Assign to the output variable if len(net) == 1: net_output = net[0] else: layer = Concatenate() layer.name = "conct_" + layer.name.split("_")[-1] net_output = layer(net) # Define the final outputs of each network outputs = [out(net_output) for out in outputs] self._inputs = inputs self._outputs = outputs self._layers = layers
def insert_layer_nonseq(model, layer_regex, insert_layer_factory, insert_layer_name=None, position='after', special=False, special_layer=None): # Auxiliary dictionary to describe the network graph network_dict = {'input_layers_of': {}, 'new_output_tensor_of': {}} # Set the input layers of each layer for layer in model.layers: for node in layer._outbound_nodes: layer_name = node.outbound_layer.name if layer_name not in network_dict['input_layers_of']: network_dict['input_layers_of'].update( {layer_name: [layer.name]}) else: network_dict['input_layers_of'][layer_name].append(layer.name) # Set the output tensor of the input layer network_dict['new_output_tensor_of'].update( {model.layers[0].name: model.input}) # Iterate over all layers after the input for layer in model.layers[1:]: # Determine input tensors layer_input = [ network_dict['new_output_tensor_of'][layer_aux] for layer_aux in network_dict['input_layers_of'][layer.name] ] if len(layer_input) == 1: layer_input = layer_input[0] # Insert layer if name matches the regular expression if re.match(layer_regex, layer.name): if position == 'replace': x = layer_input elif position == 'after': x = layer(layer_input) elif position == 'before': pass else: raise ValueError('position must be: before, after or replace') if (special == False): new_layer = insert_layer_factory() if insert_layer_name: new_layer.name = insert_layer_name else: new_layer.name = layer.name x = new_layer(x) else: new_layer = Concatenate([layer_input, special_layer]) if insert_layer_name: new_layer.name = insert_layer_name else: new_layer.name = layer.name x = new_layer if position == 'before': x = layer(x) else: x = layer(layer_input) # Set new output tensor (the original one, or the one of the inserted # layer) network_dict['new_output_tensor_of'].update({layer.name: x}) return Model(inputs=model.inputs, outputs=x)