project-codenet / model-experiments /token-based-similarity-classification /src /ModelMaker /ExperimentalModel.py
| """ | |
| Module for making experimental DNNs | |
| """ | |
| import sys | |
| import tensorflow | |
| from tensorflow import keras | |
| from tensorflow.keras import models | |
| from tensorflow.keras import layers | |
| from ModelUtils import * | |
| from FuncModelMaker import FuncModelFactory | |
| class ExperimentModelFactory(FuncModelFactory): | |
| """ | |
| Class for making experimental DNNs | |
| Provides functions for creating experimental DNNs | |
| both for classification and similarity analysis of | |
| source code represented with sequence of tokens | |
| """ | |
| def __init__(self, n_labels, regularizer = None): | |
| """ | |
| Initialize factory for DNNs | |
| Parameters: | |
| - n_labels -- number of labels (classes) | |
| - regularizer -- regularizer as a pair (l1, l2) | |
| or None if no regularization is applied | |
| Same regularization is applied to all layers | |
| """ | |
| super(ExperimentModelFactory, self).__init__(n_labels, | |
| regularizer = regularizer) | |
| def doublePoolClassCNN(self, n_tokens, | |
| convolutions, dense, | |
| conv_act = None, conv_bias = True, | |
| dense_bias = True, | |
| input_type = "trainable", | |
| embedding_dim = None, | |
| regul_dense_only = True, | |
| dropout_rate = 0, | |
| optimizer = "rmsprop"): | |
| """ | |
| Classificating CNN with both max and average | |
| global pooling operations | |
| Parameters: | |
| - convolutions -- specification of convolutional layers | |
| as list of tuples: | |
| either (kernel width, n filters, stride) | |
| or (kernel width, n filters) if stride = 1 | |
| - dense -- specification of dense layers as list of | |
| their width except the last one | |
| - conv_act -- activation of convolutional layers | |
| - conv_bias -- use bias for convolutional layers | |
| - dense_bias -- use bias for dense layers | |
| - input_type -- type of input layer: | |
| - categorical - categorical coding | |
| decoded by preprocessing layer | |
| - trainable - categorical coding processed | |
| by trainable embedding layer | |
| - embedding_dim -- size of embedding vectors | |
| It effects trainable embedding only, | |
| i.e. input_type == "trainable" | |
| - dropout_rate -- dropout rate for inserted dropout layer | |
| If it is 0 or None no droput layer is inserted | |
| - optimizer -- training optimizer | |
| - regul_dense_only -- flag to regulirize only dense layers | |
| Returns: | |
| - compiled dnn | |
| """ | |
| _input = layers.Input(shape=(None,)) | |
| _maker = SeqBlockFactory(n_tokens) | |
| _conv_tower1 = _maker.convTower(convolutions, | |
| conv_act = conv_act, out_no_act = True, | |
| conv_bias = conv_bias, | |
| input_type = input_type, | |
| regularizer = self._regularizer, | |
| embedding_dim = embedding_dim, | |
| regul_dense_only = regul_dense_only) | |
| _conv_tower2 = _maker.convTower(convolutions, | |
| conv_act = conv_act, out_no_act = True, | |
| conv_bias = conv_bias, | |
| input_type = input_type, | |
| regularizer = self._regularizer, | |
| embedding_dim = embedding_dim, | |
| regul_dense_only = regul_dense_only) | |
| _conv1 = _conv_tower1(_input) | |
| _conv2 = _conv_tower2(_input) | |
| _max_pool = layers.GlobalMaxPooling1D()(_conv1) | |
| _aver_pool = \ | |
| layers.GlobalAveragePooling1D()(_conv2) | |
| #keras.layers.Lambda(lambda x: keras.backend.stop_gradient(x))(_conv)) | |
| _merged = layers.concatenate([_max_pool, _aver_pool], | |
| axis=-1) | |
| if dropout_rate: | |
| _merged = layers.Dropout(dropout_rate, | |
| seed = UniqueSeed.getSeed())(_merged) | |
| _output = self._denseClassifier(_merged, dense) | |
| return self._compile(_input, _output, | |
| optimizer = optimizer) | |
| def _expCompile(self, inputs, output, | |
| optimizer = "rmsprop", | |
| loss = None): | |
| """ | |
| Experomental version of function for | |
| making functional dnn model and compiling it | |
| Parameters: | |
| - inputs -- list of dnn inputs | |
| - output -- dnn output | |
| - optimizer -- training optimizer | |
| - loss -- loss function used by optimizer | |
| * If loss = None the lost is computed | |
| from the number of labels | |
| Returns compiled DNN | |
| """ | |
| _dnn = models.Model(inputs, output) | |
| _loss = loss if loss else \ | |
| BaseModelFactory.compLoss(self.n_labels) | |
| _dnn = SeqBlockFactory.compileDNN( | |
| _dnn, _loss, optimizer = optimizer) | |
| return _dnn | |
| def _expBiasedDenseLayer(self, input_tensor, width, bias): | |
| """ | |
| Experimental dense layer with fixed value of bias | |
| Parameters: | |
| - input_tensor -- input tensor | |
| - width -- width | |
| - bias -- bias values | |
| """ | |
| _l = layers.Dense(width, activation = 'tanh', | |
| use_bias = bias, | |
| kernel_regularizer=self._regularizer, | |
| kernel_initializer = BaseModelFactory.computeInitializer(), | |
| bias_initializer = keras.initializers.Constant(bias), | |
| bias_constraint = keras.constraints.MinMaxNorm( | |
| min_value=bias, rate=0.5, axis=0)) #max_value=bias, | |
| return _l(input_tensor) | |
| def siameseExperimentalCNN(self, n_tokens, | |
| convolutions, w_dense, | |
| pool = 'max', side_dense = [], | |
| conv_act = None, conv_bias = True, | |
| dense_bias = True, | |
| input_type = "trainable", | |
| embedding_dim = None, | |
| regul_dense_only = True, | |
| dropout_rate = 0, | |
| merge = "concatenate", | |
| optimizer = "rmsprop"): | |
| """ | |
| Make two way convolutional Siamese dnn | |
| for sequence similarity analysis | |
| Parameters: | |
| - n_tokens -- number of types of tokens | |
| - convolutions -- specification of convolutional layers | |
| as list of tuples: | |
| either (kernel width, n filters, stride) | |
| or (kernel width, n filters) if stride = 1 | |
| - w_dense -- specification of dense layers as list of | |
| their width except the last one | |
| - pool -- pooling operation either: | |
| 'max' for maximum or | |
| 'aver' for average | |
| - side_dense -- specification of each branch dense layers | |
| as list of their width | |
| - conv_act -- activation of convolutional layers | |
| - conv_bias -- use bias for convolutional layers | |
| - dense_bias -- use bias for dense layers | |
| - input_type -- type of input layer: | |
| - categorical - categorical coding | |
| decoded by preprocessing layer | |
| - trainable - categorical coding processed | |
| by trainable embedding layer | |
| - embedding_dim -- size of embedding vectors | |
| - dropout_rate -- dropout rate for inserted dropout layer | |
| If it is 0 or None no droput layer is inserted | |
| - merge -- method of merging outputs of Siamese blocks | |
| * if concatenate, the outputs are concatenated | |
| and processed with dense layers | |
| * if subract, absolute value of difference | |
| of the outputs is computed | |
| * if "dot_prod_sigmoid" it is computed | |
| sigmoid of dot product of outputs | |
| * if "cosine" it is computed | |
| normalized dot product of normalized outputs | |
| - regul_dense_only -- flag to regulirize only dense layers | |
| - optimizer -- training optimizer | |
| Returns compiled dnn | |
| """ | |
| _input1 = layers.Input(shape=(None,)) | |
| _input2 = layers.Input(shape=(None,)) | |
| _maker = SeqBlockFactory(n_tokens) | |
| _conv = _maker.convBlock( | |
| convolutions, dense = side_dense, pool = pool, | |
| conv_act = conv_act, conv_bias = conv_bias, | |
| dense_bias = dense_bias, input_type = input_type, | |
| regularizer = self._regularizer, | |
| embedding_dim = embedding_dim, | |
| dropout_rate = dropout_rate, | |
| regul_dense_only = regul_dense_only) | |
| _pool1 = _conv(_input1) | |
| _pool2 = _conv(_input2) | |
| if merge == "concatenate": | |
| _merged = layers.concatenate([_pool1, _pool2]) | |
| _output = self._denseClassifier(_merged, w_dense) | |
| elif merge == "subtract": | |
| _merged = self._absDifference(_pool1, _pool2) | |
| _x = self._expBiasedDenseLayer(_merged, w_dense[0], 4) | |
| _output = self._denseClassifier(_x, w_dense[1:]) | |
| elif merge == "dot_prod_sigmoid": | |
| _output = self._dotProdClassifier(_pool1, _pool2) | |
| elif merge == "cosine": | |
| _output = layers.Dot(axes = 1, | |
| normalize = True)([_pool1, _pool2]) | |
| else: | |
| sys.exit(f"Wrong method {merge} of merging outputs of Siamese blocks") | |
| return self._expCompile([_input1, _input2,], _output, | |
| optimizer = optimizer) | |
| #---------------- End of class ExperimentModelFactory --------------------------- | |