project-codenet / model-experiments /token-based-similarity-classification /src /ModelMaker /ExpSiamModel.py
| """ | |
| Module for making experimental Siamese DNNs for similarity | |
| analysis | |
| """ | |
| import sys | |
| import tensorflow as tf | |
| from tensorflow import keras | |
| from tensorflow.keras import models | |
| from tensorflow.keras import layers | |
| from ModelUtils import * | |
| from FuncModelMaker import FuncModelFactory | |
| #LOSS FUNCTIONS | |
| register = keras.utils.register_keras_serializable('loss_function', name='loss_function') | |
| def cappedCrossEntropy(y_true, y_pred): | |
| """ | |
| Capped binary cross entropy loss function | |
| """ | |
| return -(keras.backend.cast(y_true, tf.float32) * | |
| tf.math.minimum((keras.backend.log(y_pred) + 0.1), 0) + | |
| 5 * (1.0 - keras.backend.cast(y_true, tf.float32)) * | |
| tf.math.minimum((keras.backend.log(1 - y_pred) + 0.01), 0) ) | |
| #@register | |
| def relaxedCrossEntropy(y_true, y_pred): | |
| """ | |
| Relaxed binary cross entropy loss function | |
| """ | |
| return -(keras.backend.cast(y_true, tf.float32) * | |
| keras.backend.log(y_pred) + | |
| (1.0 - keras.backend.cast(y_true, tf.float32)) * | |
| keras.backend.log((1 - y_pred + 0.1) / (1 + 0.1))) | |
| #@register | |
| def sinCrossEntropy(y_true, y_pred): | |
| """ | |
| Binary cross entropy loss function | |
| with sin transformation of predicted probability | |
| """ | |
| return -(keras.backend.cast(y_true, tf.float32) * | |
| keras.backend.log(keras.backend.sin(3.1415926 * (y_pred - 0.5)) / 2.0 + 0.5000001) + | |
| (1.0 - keras.backend.cast(y_true, tf.float32)) * | |
| keras.backend.log(keras.backend.sin(3.1415926 * (0.5 - y_pred)) / 2.0 + 0.5000001)) | |
| def getLossFunction(loss = None): | |
| """ | |
| Compute loss function as function of the argument | |
| Parameters: | |
| - loss -- loss function as a string | |
| """ | |
| if loss is None: | |
| return "binary_crossentropy" | |
| elif loss == "relaxedCrossEntropy": | |
| return relaxedCrossEntropy | |
| elif loss == "sinCrossEntropy": | |
| return sinCrossEntropy | |
| elif loss == "cappedCrossEntropy": | |
| return cappedCrossEntropy | |
| else: | |
| sys.exit(f"Unknown loss function {loss}") | |
| #---------------- End of lOSS FUNCTIONS --------------------------- | |
| class ExpSiameseModelFactory(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 | |
| Set all external parameters of DNNs, | |
| which can be amended or even modified in each | |
| """ | |
| def __init__(self, n_labels, regularizer = None, loss = 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(ExpSiameseModelFactory, self).__init__(n_labels, | |
| regularizer = regularizer) | |
| self.loss = getLossFunction(loss) | |
| def makeCNN(self, dnn, | |
| 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 = "adam"): | |
| """ | |
| Make experimental two way convolutional Siamese dnn | |
| for sequence similarity analysis | |
| Parameters to each DNN are passed as self object member | |
| Parameters: | |
| - dnn -- string specifying type of DNN to make | |
| - 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 | |
| """ | |
| self.n_tokens =n_tokens | |
| self.convolutions = convolutions | |
| self.w_dense = w_dense | |
| self.pool = pool | |
| self.side_dense = side_dense | |
| self.conv_act = conv_act | |
| self.conv_bias = conv_bias | |
| self.dense_bias = dense_bias | |
| self.input_type = input_type | |
| self.embedding_dim = embedding_dim | |
| self.regul_dense_only = regul_dense_only | |
| self.dropout_rate = dropout_rate | |
| self.merge = merge | |
| self.optimizer = optimizer | |
| if dnn == "concatenate": | |
| return self.concatCNN() | |
| elif dnn == "subtract": | |
| return self.subtractCNN() | |
| elif dnn == "dot_prod_sigmoid": | |
| return self.dot_prodCNN() | |
| elif dnn == "cosine": | |
| return self.cosineCNN() | |
| elif dnn == "multiply": | |
| return self.multiplyCNN() | |
| elif dnn == "plain": | |
| return self.plainCNN() | |
| else: | |
| sys.exit(f"Requested dnn {dnn} is not known") | |
| def expCompile(self, inputs, output, | |
| optimizer = "rmsprop", | |
| loss = "binary_crossentropy", | |
| metrics = ["accuracy"]): | |
| """ | |
| 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 binary_crossentropy | |
| - metrics -- list of metric functions used by optimizer | |
| Returns compiled DNN | |
| """ | |
| _dnn = models.Model(inputs, output) | |
| _loss = loss if loss else "binary_crossentropy" | |
| _dnn.compile(optimizer = optimizer, loss = loss, | |
| metrics = metrics) | |
| print("Summary of DNN constructed") | |
| _dnn.summary() | |
| return _dnn | |
| def siameseBlock(self): | |
| """ | |
| Make Siamese block of CNN | |
| Outputs are Max pooled tensors of convolved input sequence | |
| Parameters are taken from members of object self | |
| Returns 4 tensors: | |
| - input tensor 1 | |
| - input tensor 2 | |
| - output tensor 1 | |
| - output tensor 2 | |
| """ | |
| _input1 = layers.Input(shape=(None,)) | |
| _input2 = layers.Input(shape=(None,)) | |
| _maker = SeqBlockFactory(self.n_tokens) | |
| _conv = _maker.convBlock( | |
| self.convolutions, | |
| dense = self.side_dense, | |
| pool = self.pool, | |
| conv_act = self.conv_act, | |
| conv_bias = self.conv_bias, | |
| dense_bias = self.dense_bias, | |
| input_type = self.input_type, | |
| regularizer = self._regularizer, | |
| embedding_dim = self.embedding_dim, | |
| dropout_rate = self.dropout_rate, | |
| regul_dense_only = self.regul_dense_only) | |
| _pool1 = _conv(_input1) | |
| _pool2 = _conv(_input2) | |
| return _input1, _input2, _pool1, _pool2 | |
| def denseTower(self, input_tensor, dense, | |
| bias = True, activation = "relu"): | |
| """ | |
| Make a stack of dense layers | |
| Stack may have no layers | |
| It is expected that input shape is known | |
| Parameters: | |
| - input_tensor -- input tensor | |
| - dense -- specification of dense layers as list of | |
| their width except the last one | |
| - bias -- use or do not use bias on dense layers | |
| - activation of all layers except the last one | |
| Returns: output tensor | |
| """ | |
| _output = input_tensor | |
| _output = input_tensor | |
| if dense: | |
| for _w in dense: | |
| _output = layers.Dense(_w, activation = activation, | |
| use_bias = bias, | |
| kernel_regularizer=self._regularizer, | |
| kernel_initializer = BaseModelFactory.computeInitializer() | |
| )(_output) | |
| return _output | |
| def expDenseClassifier(self, input_tensor, dense, | |
| bias = True, activation = "relu"): | |
| """ | |
| Make a stack of dense layers with classifier | |
| Classifier is either softmax for more than 2 classes | |
| or sigmoid for 2 classes | |
| It is expected that input shape is known | |
| Parameters: | |
| - input_tensor -- input tensor | |
| - dense -- specification of dense layers as list of | |
| their width except the last one | |
| - bias -- use or do not use bias on dense layers | |
| - activation of all layers except the last one | |
| Returns: output tensor | |
| """ | |
| _output = self.denseTower(input_tensor, dense, | |
| bias =bias, activation = activation) | |
| _output = layers.Dense(self.n_labels, | |
| activation = self.class_layer, | |
| use_bias = bias, | |
| kernel_regularizer=self._regularizer, | |
| kernel_initializer = BaseModelFactory.computeInitializer())(_output) | |
| return _output | |
| def concatCNN(self): | |
| """ | |
| Siamese CNN with merging by concatenation | |
| """ | |
| _input1, _input2, _pool1, _pool2 = self.self.siameseBlock() | |
| _merged = layers.concatenate([_pool1, _pool2]) | |
| _output = self._denseClassifier(_merged, self.w_dense) | |
| return self.expCompile([_input1, _input2,], _output, | |
| optimizer = self.optimizer) | |
| def biasedDenseLayer(self, input_tensor, width, | |
| min_bias, rate_bias = 0.5, activation = "tanh"): | |
| """ | |
| Experimental dense layer with fixed value of bias | |
| Parameters: | |
| - input_tensor -- input tensor | |
| - width -- width | |
| - min_bias -- minimum bias value to shift 0 value of | |
| previous layer output | |
| - rate_bias -- rate of enforcing bias constraint | |
| - activation -- activation function | |
| Returns output tensor | |
| """ | |
| _l = layers.Dense(width, activation = activation, | |
| use_bias = True, | |
| kernel_regularizer=self._regularizer, | |
| kernel_initializer = initializers.RandomUniform( | |
| minval=0, maxval=0.1, seed=UniqueSeed.getSeed()), | |
| #kernel_constraint = keras.constraints.NonNeg(), | |
| bias_initializer = keras.initializers.Constant(min_bias), | |
| bias_constraint = keras.constraints.MinMaxNorm( | |
| min_value=min_bias, rate=rate_bias, axis=0)) | |
| return _l(input_tensor) | |
| def subtractCNN(self): | |
| """ | |
| Siamese CNN with merging by computing | |
| absolute value of difference | |
| """ | |
| _bias_shift = 3.0 #minimum bias shift | |
| _rate_bias = 0.5 #rate of enforcing bias constraint | |
| _diff_activation = "tanh" # activation of layer processing | |
| #difference of feature vectors | |
| #either tanh or None | |
| _input1, _input2, _pool1, _pool2 = self.siameseBlock() | |
| _merged = self._absDifference(_pool1, _pool2) | |
| _x = self.biasedDenseLayer(_merged, self.w_dense[0], | |
| _bias_shift, rate_bias = _rate_bias, | |
| activation = "relu") | |
| _output = self.expDenseClassifier(_x, self.w_dense[1:]) | |
| return self.expCompile([_input1, _input2,], _output, | |
| optimizer = self.optimizer) | |
| def dot_prodCNN(self): | |
| """ | |
| Siamese CNN with merging by dot product | |
| """ | |
| _input1, _input2, _pool1, _pool2 = self.siameseBlock() | |
| _output = layers.Dot(axes = 1, normalize = False)([_pool1, _pool2]) | |
| _output = layers.Activation("sigmoid")(_output) | |
| return self.expCompile([_input1, _input2,], _output, | |
| optimizer = self.optimizer) | |
| def cosineCNN(self): | |
| """ | |
| Siamese CNN with merging by cosine | |
| """ | |
| _input1, _input2, _pool1, _pool2 = self.siameseBlock() | |
| _output = layers.Dot(axes = 1, | |
| normalize = True)([_pool1, _pool2]) | |
| return self.expCompile([_input1, _input2,], _output, | |
| optimizer = self.optimizer, | |
| loss = keras.losses.SquaredHinge(), | |
| metrics = [keras.metrics.SquaredHinge()]) | |
| #loss = keras.losses.Hinge(reduction="auto"), | |
| #metrics = [keras.metrics.Hinge()]) | |
| def multiplyCNN(self): | |
| """ | |
| Siamese CNN with merging by multiplication | |
| """ | |
| _input1, _input2, _pool1, _pool2 = self.siameseBlock() | |
| #_pool1 = layers.Activation("tanh")(_pool1) | |
| #_pool2 = layers.Activation("tanh")(_pool2) | |
| _multiplied = keras.layers.Multiply()([_pool1, _pool2]) | |
| _output = self.expDenseClassifier(_multiplied, self.w_dense) | |
| return self.expCompile([_input1, _input2,], _output, | |
| optimizer = self.optimizer) | |
| def plainCNN(self, loss_function = "binary_crossentropy"): | |
| """ | |
| Old plain siamese CNN | |
| Parameters: | |
| - loss_function -- loss function | |
| """ | |
| _input1, _input2, _pool1, _pool2 = self.siameseBlock() | |
| _merged = self._absDifference(_pool1, _pool2) | |
| _output = self._denseClassifier(_merged, self.w_dense) | |
| return self.expCompile([_input1, _input2,], _output, | |
| optimizer = self.optimizer, | |
| loss = self.loss) | |
| #---------------- End of class ExpSiameseModelFactory --------------------------- | |