def BuildGraphEmeddingConcatenation( self, forward_layer: Layer = None, backward_layer: Layer = None, hidden_dim: int = 100, kernel_init: str = 'glorot_uniform', act: activations = activations.softmax, kernel_regularizer: regularizers = regularizers.l2(0.01), activity_regularizer: regularizers = regularizers.l1(0.01)): """ This functions builds the node embedding to graph embedding sub model and is element of the encoder structure. :param forward_layer:Layer: previous forward layer :param backward_layer:Layer: previous backward layer :param hidden_dim:int: hidden dimension depends on the embedding dimension e.g. GloVe vector length used. [Default 100] :param kernel_init:str: kernel initializer [Default glorot_uniform] :param act:activations: activation function [Default relu] #:param kernel_regularizer:regularizers: kernel regularizers [Default l2(0.01)] #:param activity_regularizer:regularizers: activity regularizers [Default l1(0.01)] """ try: AssertNotNone(forward_layer, 'forward_layer') AssertNotNone(backward_layer, 'backward_layer') concat = concatenate([forward_layer, backward_layer], name="fw_bw_concatenation", axis=1) """ Deprecated! hidden = Dense( hidden_dim, kernel_initializer=kernel_init, activation=act, kernel_regularizer=kernel_regularizer, activity_regularizer=activity_regularizer, name="concatenation_act")(concat) """ hidden = Dense(units=hidden_dim, activation=act, name='reduce_concatenation_act')(concat) concat_pool = None if (not self.input_is_2d): concat_pool = GlobalMaxPooling1D( data_format='channels_last', name='concat_max_pooling')(hidden) else: concat_pool = Lambda( lambda x: K.reshape(K.max(x, axis=0), (-1, hidden_dim)), name='concat_max_pool')(hidden) graph_embedding_state_h = concat_pool graph_embedding_state_c = concat_pool return [hidden, graph_embedding_state_h, graph_embedding_state_c] except Exception as ex: template = "An exception of type {0} occurred in [ModelBuilder.BuildGraphEmeddingConcatenation]. Arguments:\n{1!r}" message = template.format(type(ex).__name__, ex.args) print(message)
def MakeModel(self, layers: Layer): """ This function creates the model by given inputs. :param layers:Layer: structure that defines your model """ try: inputs = self.get_inputs() AssertNotNone(inputs, 'inputs') AssertNotNone(layers, 'layers') return Model(inputs=inputs, outputs=layers) except Exception as ex: template = "An exception of type {0} occurred in [ModelBuilder.MakeModel]. Arguments:\n{1!r}" message = template.format(type(ex).__name__, ex.args) print(message)
def get_inputs(self): """ This getter returns the encoder and decoder inputs in exactly this order [encoder, decoder]. """ try: AssertNotNone(self.encoder_inputs, 'encoder inputs') AssertNotNone(self.decoder_inputs, 'decoder inputs') return [ self.encoder_inputs[0], self.encoder_inputs[1], self.encoder_inputs[2], self.decoder_inputs ] except Exception as ex: template = "An exception of type {0} occurred in [ModelBuilder.get_inputs]. Arguments:\n{1!r}" message = template.format(type(ex).__name__, ex.args) print(message)
def GetAllSamplesAggregatedFeatures(self): """ This function collects and aggregates all given features next hop neighbourhood feature vectors for all samples. Attention! => since the neighbourhood tensors have to be for each sample an (MxM) matrix i collect the dim from last shape value! """ try: samples_results = [] dims = len(self.neighbouring.shape) vecs = self.neighbouring.shape[dims - 1] for sample in range(self.features.shape[0].value): sample_concatenate = None sample_features = self.features[sample, :, :] if ( dims > 2) else self.features sample_neigbourhood = self.neighbouring[sample, :, :] if ( dims > 2) else self.neighbouring agg_f_vecs = self.GetSamplesAggregatedFeatures( features=sample_features, neighbourhood=sample_neigbourhood, features_size=vecs) sample_concatenate = K.concatenate( [sample_features, agg_f_vecs]) AssertNotNone(sample_concatenate, 'sample_concatenate') samples_results.append(sample_concatenate) assert samples_results, 'No results calculated for feature and neighbourhood samples!' return samples_results except Exception as ex: template = "An exception of type {0} occurred in [NeighbourhoodCollector.GetAllSamplesAggregatedFeatures]. Arguments:\n{1!r}" message = template.format(type(ex).__name__, ex.args) print(message)
def GetSamplesAggregatedFeatures(self, features, neighbourhood, features_size: int): """ This function collects and aggregates all given features next hop neighbourhood feature vectors for 1 sample. :param features: samples previous or initial features :param neighbourhood: samples graph neighbourhood look up :param features_size:int: amount of features in the sample """ try: agg_f_vecs = None for i in range(features_size): found_neighbour_vectors = self.GetVectorNeighbours( features, neighbourhood, i) aggregator_result = Aggregators(found_neighbour_vectors, self.axis, self.aggregator).Execute() AssertNotNone(aggregator_result, 'aggregator_result') if (agg_f_vecs is None): agg_f_vecs = [aggregator_result] else: agg_f_vecs.append(aggregator_result) agg_f_vecs = agg_f_vecs[0] if ( features_size < 2) else K.concatenate(agg_f_vecs) return K.transpose(K.reshape(agg_f_vecs, (features_size, -1))) except Exception as ex: template = "An exception of type {0} occurred in [NeighbourhoodCollector.GetSamplesAggregatedFeatures]. Arguments:\n{1!r}" message = template.format(type(ex).__name__, ex.args) print(message)
def Plot(self, model: training.Model, file_name: str, show_shapes: bool = True): """ This function plots and store a given model to desired file. :param model:Model: keras model :param file_name:str: name of the image file :param show_shapes:bool =True: show layer shape in the graph """ try: AssertNotNone(model, 'plotting_tensor'), 'Plotting model was None!' AssertNotNone(file_name, 'name_plot_file'), 'Plot file name was None!' plot_model(model, to_file=file_name, show_shapes=show_shapes) except Exception as ex: template = "An exception of type {0} occurred in [ModelBuilder.Plot]. Arguments:\n{1!r}" message = template.format(type(ex).__name__, ex.args) print(message)
def GetVectorNeighbours(self, features, neighbouring, index: int): """ This function collects the neighbourhood vectors for a spezific vertex given by index. :param features: previous features :param neighbouring: neighbourhood look up :param index:int: viewed feature index """ try: AssertNotNegative(index) AssertNotNone(features, 'features') AssertNotNone(neighbouring, 'neighbouring look-up') neighbouring = neighbouring[index, :] neighbouring = K.reshape(neighbouring, (neighbouring.shape[0], -1)) return multiply([features, neighbouring]) except Exception as ex: template = "An exception of type {0} occurred in [NeighbourhoodCollector.GetVectorNeighbours]. Arguments:\n{1!r}" message = template.format(type(ex).__name__, ex.args) print(message)
def Summary(self, model: training.Model): """ This function prints the summary of a model. :param model:training.Model: a build model """ try: AssertNotNone(model, 'plotting_tensor'), 'Plotting model was None!' print(model.summary(line_length=200)) except Exception as ex: template = "An exception of type {0} occurred in [ModelBuilder.Summary]. Arguments:\n{1!r}" message = template.format(type(ex).__name__, ex.args) print(message)
def NhoodLambdaLayer(self, features, look_up, hop: int, aggregator: str = 'mean', layer_name: str = 'Nhood_Layer'): """ This function builds a neighbourhood collecting keras lambda layer. :param features: 2D tensor with rows of vectoriced words :param look_up: 2D tensor with neighbourhood description for foward,backward or both in one :param hop:int: hop position in the network model structure :param aggregator:str: aggretaor function [Default mean] :param layer_name:str: name of the layer (remind an extension will be added) """ try: AssertIsKerasTensor(features) AssertIsKerasTensor(look_up) AssertNotNone(features, 'features'), 'Input tensor for features was None!' AssertNotNone(look_up, 'look_up'), 'Input tensor for look_up was None!' AssertNotNegative(hop), 'input dimension was negative or none!' name = layer_name if layer_name is not None else '' name_ext = '_lambda_init' if hop == 0 else '_lambda_step' dataset = [features, look_up] hood_func = lambda x: Nhood(batch_sz=self.batch_size, aggregator=aggregator, is_2d=self.input_is_2d).Execute( x[0], x[1]) return Lambda(function=hood_func, name=name + name_ext)(dataset) except Exception as ex: template = "An exception of type {0} occurred in [ModelBuilder.NhoodLambdaLayer]. Arguments:\n{1!r}" message = template.format(type(ex).__name__, ex.args) print(message)