project-codenet / model-experiments /token-based-similarity-classification /src /ModelMaker /ModelUtils.py
| """ | |
| Model for making Neural Network models | |
| for classification of source code. | |
| The module provides factory class for making | |
| Neural Network models | |
| """ | |
| import sys | |
| import tensorflow | |
| from tensorflow.keras import models | |
| from tensorflow.keras import layers | |
| from tensorflow.keras import initializers | |
| class UniqueSeed(): | |
| """ | |
| Class for generating unique seed for | |
| model initializing DNN models | |
| """ | |
| #Initial value of seed | |
| seed = 1234 | |
| #Step at which seed is incrtemented after its each query | |
| step = 17 | |
| def getSeed(cls): | |
| """ | |
| Get unique seed | |
| """ | |
| cls.seed += cls.step | |
| return cls.seed | |
| def setSeed(cls, seed, step = 17): | |
| """ | |
| Initialize seed externally | |
| Parameters: | |
| - seed -- Initial value of seed | |
| - step -- Step at which seed is incretemented | |
| after its each query | |
| """ | |
| cls.seed = seed | |
| cls.step = step | |
| def __init__(self): | |
| pass | |
| class BaseModelFactory(): | |
| """ | |
| Base class for factories of DNN models | |
| Supplies utility methods of other DNN factories | |
| """ | |
| def computeInitializer(cls, seed = None): | |
| """ | |
| Compute layer initializer | |
| Parameters: | |
| - seed -- seed for random generator used by analyzer | |
| If it is None a unique repeatable seed is generated | |
| """ | |
| _seed = seed if seed else UniqueSeed.getSeed() | |
| #_initializer=initializers.GlorotNormal(seed=seed) | |
| _initializer=initializers.GlorotUniform(seed=seed) | |
| return _initializer | |
| def computeRegularizer(cls, regular): | |
| """ | |
| Compute l1 and l2 regulizer | |
| Parameters: | |
| - regular -- regularizer as a pair (l1, l2) | |
| or None if no regularization is applied. | |
| """ | |
| return None if regular is None \ | |
| else tensorflow.keras.regularizers.l1_l2(l1=regular[0], | |
| l2=regular[1]) | |
| def compClassification(cls, labels): | |
| """ | |
| Compute classification function | |
| Parameters: | |
| - labels -- number of labels (classes) | |
| """ | |
| return "sigmoid" if labels == 1 \ | |
| else "softmax" | |
| def compLoss(cls, labels): | |
| """ | |
| Compute loss function | |
| Parameters: | |
| - labels -- number of labels (classes) | |
| """ | |
| return "binary_crossentropy" if labels == 1 \ | |
| else "sparse_categorical_crossentropy" | |
| def compileDNN(cls, dnn, loss, optimizer = "rmsprop"): | |
| """ | |
| Compile sequential DNN | |
| Parameters: | |
| - dnn -- DNN to compile | |
| - loss -- loss to use for training | |
| - optimizer -- training optimizer | |
| Returns compiled DNN | |
| """ | |
| dnn.compile(optimizer = optimizer, loss = loss, | |
| metrics = ['accuracy']) | |
| print("Summary of DNN constructed") | |
| dnn.summary() | |
| return dnn | |
| def __init__(self): | |
| pass | |
| #---------------- End of class BaseModelFactory --------------------------- | |
| class SeqBlockFactory(BaseModelFactory): | |
| """ | |
| Factory of sequential DNN blocks for processing sequences of tokens | |
| for code classification and similarity analysis | |
| Provides functions for creating sequential DNN building blocks | |
| """ | |
| def __init__(self, tokens): | |
| """ | |
| Initialize factory of DNN sequential building blocks | |
| Parameters: | |
| - tokens -- number of types of tokens | |
| It is the size (dimensionality) of sequence vectors | |
| or number of values for cathegorical input coding | |
| """ | |
| super(SeqBlockFactory, self).__init__() | |
| self.n_tokens = tokens | |
| def addConv1Layer(self, dnn, convolution, activation = None, | |
| bias = True, regularizer = None): | |
| """ | |
| Add to the dnn a convolutional layer | |
| Parameters: | |
| - dnn -- dnn to buld | |
| - convolution -- specification of the convolutional layer | |
| as list of tuples: | |
| either (n filters, kernel width, stride) | |
| or (n filters, kernel width) if stride = 1 | |
| - activation -- activation on convolutional layer | |
| - bias -- use or do not use bias on convolutional layer | |
| - regularizer -- regularizer of convolution kernels | |
| Returns exit code: | |
| - 0 if the layer is successfully added | |
| - 1 if the layer is specified incorrectly | |
| """ | |
| if len(convolution) == 3: | |
| dnn.add(layers.Conv1D(convolution[0], convolution[1], | |
| strides=convolution[2], | |
| activation = activation, | |
| use_bias = bias, | |
| kernel_regularizer = regularizer, | |
| kernel_initializer = BaseModelFactory.computeInitializer())) | |
| return 0 | |
| elif len(convolution) == 2: | |
| dnn.add(layers.Conv1D(convolution[0], convolution[1], | |
| activation = activation, | |
| use_bias = bias, | |
| kernel_regularizer = regularizer, | |
| kernel_initializer = BaseModelFactory.computeInitializer())) | |
| return 0 | |
| else: | |
| return 1 | |
| def addConv1(self, dnn, convolutions, activation = None, | |
| bias = True, out_no_act = True, | |
| regularizer = None): | |
| """ | |
| Add to the dnn a stack of convolutional layers | |
| Parameters: | |
| - dnn -- dnn to buld | |
| - convolutions -- specification of convolutional layers | |
| as list of tuples: | |
| either (n filters, kernel width, stride) | |
| or (n filters, kernel width) if stride = 1 | |
| - activation -- activation on all convolutional layers | |
| but the last one | |
| - bias -- use or do not use bias on convolutional layers | |
| - out_no_act -- flag of no activation on last layer | |
| - regularizer -- regularizer of convolution kernels | |
| """ | |
| for _i in range(len(convolutions)): | |
| _act = None if _i == len(convolutions) - 1 and out_no_act \ | |
| else activation | |
| if self.addConv1Layer(dnn, convolutions[_i], activation = _act, | |
| bias = bias, regularizer = regularizer): | |
| print(f"Wrong specification of convolutional layer {-i}") | |
| _n_conv_parms = len(convolutions[_i]) | |
| print(f"It has incorrect number {_n_conv_parm} of parameters") | |
| sys.exit(0) | |
| def addDense(self, dnn, dense, bias = True, regularizer = None): | |
| """ | |
| Add a stack of dense layers to the dnn | |
| Parameters: | |
| - dnn -- dnn to buld | |
| - dense -- specification of dense layers as list of | |
| their width | |
| - bias -- use or do not use bias on dense layers | |
| - regularizer -- regularizer of dense weight matrix | |
| """ | |
| if not dense: return | |
| for _w in dense: | |
| dnn.add(layers.Dense(_w, activation = 'relu', | |
| use_bias = bias, | |
| kernel_regularizer=regularizer, | |
| kernel_initializer = BaseModelFactory.computeInitializer())) | |
| def addPooling(self, dnn, pool): | |
| """ | |
| Add pooling layer to the dnn | |
| Parameters: | |
| - dnn -- dnn to buld | |
| - pool -- pooling operation; either | |
| 'max' for maximum or 'aver' for average | |
| """ | |
| if pool == 'max': | |
| dnn.add(layers.GlobalMaxPooling1D()) | |
| elif pool == 'aver': | |
| dnn.add(layers.GlobalAveragePooling1D()) | |
| else: | |
| print(f"Error: Wrong pooling operation {pool}\n" + | |
| "It should be either max or aver") | |
| sys.exit(0) | |
| def addDropout(self, dnn, rate): | |
| """ | |
| Add droput layer to dnn | |
| Parameters: | |
| - dnn -- dnn to buld | |
| - rate -- dropout rate | |
| If it is 0 or None no droput layer is inserted | |
| """ | |
| if rate: | |
| dnn.add(layers.Dropout(rate, seed = UniqueSeed.getSeed())) | |
| def addEmbedding(self, dnn, trainable = False, width = None, | |
| regularizer = None): | |
| """ | |
| Add embedding layer to the DNN | |
| Parameters: | |
| - dnn -- dnn to buld | |
| - trainable -- flag defining that embedding should be trainable | |
| If it is False embedding layer transforms | |
| categorical coding into one hot coding | |
| - width -- dimension of embedding vectors | |
| It effects trainable embedding only. | |
| If it is None self.n_tokens is used. | |
| - regularizer -- regularizer of convolution and dense kernels | |
| effects on trainable embedding | |
| """ | |
| if trainable: | |
| _output_dim = width if width else self.n_tokens | |
| _initializer = \ | |
| tensorflow.keras.initializers.RandomUniform(seed = \ | |
| UniqueSeed.getSeed()) | |
| dnn.add(layers.Embedding( | |
| input_dim = self.n_tokens + 1, | |
| output_dim = _output_dim, | |
| embeddings_initializer = _initializer, | |
| mask_zero = True, | |
| embeddings_regularizer = regularizer)) | |
| else: | |
| #Transformation of categorical coding into one-hot | |
| _initializer = tensorflow.keras.initializers.Identity() | |
| dnn.add(layers.Embedding( | |
| input_dim = self.n_tokens + 1, | |
| output_dim = self.n_tokens, | |
| embeddings_initializer = _initializer, | |
| mask_zero = True)) | |
| def convTower(self, convolutions, | |
| conv_act = None, out_no_act = True, | |
| conv_bias = True, | |
| input_type = "one_hot", | |
| regularizer = None, embedding_dim = None, | |
| regul_dense_only = True): | |
| """ | |
| Make sequential DNN building block of stack | |
| of convolutional layers | |
| Parameters: | |
| - convolutions -- specification of convolutional layers | |
| as list of tuples: | |
| either (kernel width, n filters, stride) | |
| or (kernel width, n filters) if stride = 1 | |
| - conv_act -- activation of convolutional layers | |
| - out_no_act -- flag of no activation on last convolutional layer | |
| - conv_bias -- use bias for convolutional layers | |
| - input_type -- type of input layer: | |
| - one_hot - one hot coding of input samples | |
| - categorical - categorical coding | |
| decoded by preprocessing layer | |
| - trainable - categorical coding processed | |
| by trainable embedding layer | |
| - regularizer -- regularizer applied to weights of dense layer | |
| and to convolutionand embedding layers if | |
| parameters regul_dense_only = False | |
| - embedding_dim -- size of embedding vectors | |
| It effects trainable embedding only, | |
| i.e. input_type == "trainable" | |
| If it is None self.n_tokens is used. | |
| If it is None self.n_tokens is used | |
| - regul_dense_only -- flag to regulirize only dense layers | |
| Returns: | |
| - dnn -- constructed DNN building block | |
| """ | |
| _conv_regul = None if regul_dense_only else regularizer | |
| _embed_regul = None if regul_dense_only else regularizer | |
| _dnn = models.Sequential() | |
| if input_type == "one_hot": | |
| _dnn.add(layers.Input(shape=(None, self.n_tokens,))) | |
| elif input_type == "categorical" or input_type == "trainable": | |
| _trainable = (input_type == "trainable") | |
| _dnn.add(layers.Input(shape=(None,))) | |
| self.addEmbedding(_dnn, trainable = _trainable, | |
| width = embedding_dim, | |
| regularizer = _embed_regul) | |
| else: | |
| sys.exit(f"Wrong type {input_type} of input_type parameter of sequentinal convolution block") | |
| self.addConv1(_dnn, convolutions, activation = conv_act, | |
| bias = conv_bias, | |
| out_no_act = out_no_act, | |
| regularizer = _conv_regul) | |
| return _dnn | |
| def convBlock(self, convolutions, dense = [], pool = 'max', | |
| conv_act = None, conv_bias = True, | |
| dense_bias = True, input_type = "one_hot", | |
| regularizer = None, embedding_dim = None, | |
| dropout_rate = 0, | |
| regul_dense_only = True): | |
| """ | |
| Make sequential convolutional DNN building block | |
| 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 | |
| - pool -- pooling operation either: | |
| 'max' for maximum or | |
| 'aver' for average | |
| - 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: | |
| - one_hot - one hot coding of input samples | |
| - categorical - categorical coding | |
| decoded by preprocessing layer | |
| - trainable - categorical coding processed | |
| by trainable embedding layer | |
| - regularizer -- regularizer applied to weights of dense layer | |
| and to convolutionand embedding layers if | |
| parameters regul_dense_only = False | |
| - embedding_dim -- size of embedding vectors | |
| It effects trainable embedding only, | |
| i.e. input_type == "trainable" | |
| If it is None self.n_tokens is used. | |
| If it is None self.n_tokens is used | |
| - dropout_rate -- dropout rate for inserted dropout layer | |
| If it is 0 or None no droput layer is inserted | |
| - regul_dense_only -- flag to regulirize only dense layers | |
| Returns: | |
| - dnn -- constructed DNN building block | |
| """ | |
| _conv_regul = None if regul_dense_only else regularizer | |
| _embed_regul = None if regul_dense_only else regularizer | |
| _dnn = models.Sequential() | |
| if input_type == "one_hot": | |
| _dnn.add(layers.Input(shape=(None, self.n_tokens,))) | |
| elif input_type == "categorical" or input_type == "trainable": | |
| _trainable = (input_type == "trainable") | |
| _dnn.add(layers.Input(shape=(None,))) | |
| self.addEmbedding(_dnn, trainable = _trainable, | |
| width = embedding_dim, | |
| regularizer = _embed_regul) | |
| else: | |
| sys.exit(f"Wrong type {input_type} of input_type parameter of functional convolution block") | |
| self.addConv1(_dnn, convolutions, activation = conv_act, | |
| bias = conv_bias, | |
| out_no_act = (pool == 'max'), | |
| regularizer = _conv_regul) | |
| self.addPooling(_dnn, pool) | |
| self.addDense(_dnn, dense, bias = dense_bias, | |
| regularizer = regularizer) | |
| self.addDropout(_dnn, dropout_rate) | |
| return _dnn | |
| def addClassifier(self, dnn, labels, bias = True, | |
| regularizer = None): | |
| """ | |
| Add to the dnn a dense layer 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: | |
| - dnn -- dnn to complete | |
| - labels -- number of labels (classes) | |
| - bias -- use or do not use bias on dense layers | |
| - regularizer -- regularizer applied to weights of | |
| convolution, dense, and embedding layers | |
| """ | |
| dnn.add(layers.Dense(labels, | |
| activation = self.compClassification(labels), | |
| use_bias = bias, | |
| kernel_regularizer=regularizer, | |
| kernel_initializer = BaseModelFactory.computeInitializer())) | |
| #---------------- End of class SeqBlockFactory ---------------------- | |