Descomposiciones tensoriales aplicadas a arquitecturas de deep learning

Este repositorio contiene el codigo fuente de mi tesis de grado en Ingenieria Informatica para la Facultad de Ingenieria de la Universidad de Buenos Aires denominada "Descomposiciones tensoriales aplicadas a arquitecturas de Deep Learning".

This repository contains the source code of my degree thesis in Computer Engineering for the Faculty of Engineering of the University of Buenos Aires called "Tensor decompositions applied to Deep Learning architectures".

Author: Andres Otero

Director: Cesar Caiafa

Como correr el proyecto

Para poder correr el proyecto es necesario definir ciertos parametros en la clase NetParams, los parametros que siempre deben ser especificados son:

• model: alguno de los modelos definidos en EnumModel.
• dataset : alguno de los sets de datos definidos en EnumDataset.
• train_method : tiene que ser alguno de los dos metodos definidos en TrainMethods. Las alternativas principales son si el set de datos es de texto o si es de imagenes, esto cambia el proceso de entrenamiento de la red.
• learning_rate : es un parámetro de ajuste que sirve para determinar que tan rapido el modelo se adapta al problema.
• optimizer : cual es el optimizador que utilizara la red, en el trabajo se utilizo principalmente ADAM, para mas detalle ver OptimizerFactory.
• cuda_is_available : si la opcion de utilizar CUDA esta disponible en la plataforma donde se realiza el aprendizaje.

Hay varios parametros que tienen valores predeterminados pero se pueden definir en caso de ser necesario:

• m : el tamaño del feature map
• divides_in_row : la cantidad de dviisiones en filas del tensor de entrada.
• divides_in_col : la cantidad de divisiones en columnas del tensor de salida.
• rank : el rango elegido del tensor.
• batch_size : el tamaño del lote de entrenamiento.
• test_batch_size : el tamaño del lote para la prueba.
• epochs : la cantidad de epocas de entrenamiento para la red
• momentum : para especificar el momento del optimizador (solo utlizado para el caso de SGD).
• log_interval : el intervalo para el cual la red inserta un mensaje en el log.
• save: booleano para especificar si guardar o no el modelo.
• cuda : booleano para especificar si se utiliza o no CUDA.
• categories : cantidad de categorias para las cuales tiene que clasificar la red.
• log_while_training : si loggear mensajes o no durante el entrenamiento
• tensor_size : el tamaño de entrada del tensor.
• embedding : el tamaño del embedding utilizado (en el caso de que este exista).
• fixed_lenght : el tamaño de corte del tensor (0 para que no haya corte).
• init_value : el valor a utilizar para la inicializacion de los tensores (solo utilizdo en el caso de una red tensorial).
• rank_first_and_last : rango del primer y ultimo tensor de la red (solo utilizado en el caso de Tensor Ring).
• dropout : dropout utilizado en la red (en el caso que la red lo tenga).

Aqui se agrega un ejemplo de como se define un experimento:

result_data = {}
net_params = NetParams(EnumModel.TT_SHARED_MODEL, EnumDataset.FASHION_MNIST_FLAT_DIVISIONS,
              EnumTrainMethods.TRAIN_VISION_METHOD, 1e-4, Constant.ADAM,
              torch.cuda.is_available(), divides_in_col=4,
              divides_in_row=4, tensor_size=Constant.TENSOR_SIZE_MNIST,
              categories=Constant.CATEGORIES_CIFAR, m=64, rank=38,
              init_value=1)
run_net(net_params, result_data)

Para mas informacion por favor referirse al trabajo referenciado.

How to run an experiment

In order to run ab experiment it is necessary to define certain parameters in the [NetParams] class (https://github.com/AndresOtero/TensorDecompositionMachineLearning/blob/main/Utils/NetParams.py), the parameters that must always be specified are:

• model: any of the models defined in [EnumModel] (https://github.com/AndresOtero/TensorDecompositionMachineLearning/blob/main/Utils/EnumModel.py).
• dataset: any of the data sets defined in [EnumDataset] (https://github.com/AndresOtero/TensorDecompositionMachineLearning/blob/main/Utils/EnumDataset.py).
• train_method: it has to be one of the two methods defined in [TrainMethods] (https://github.com/AndresOtero/TensorDecompositionMachineLearning/blob/main/Utils/TrainMethods.py). The main alternatives are if the data set is text or if it is images, this changes the training process of the network.
• learning_rate: it is an adjustment parameter that is used to determine how fast the model adapts to the problem.
• optimizer: which is the optimizer that the network will use, ADAM was used mainly at work, for more details see [OptimizerFactory] (https://github.com/AndresOtero/TensorDecompositionMachineLearning/blob/main/Utils/OptimizerFactory.py) .
• cuda_is_available: if the option to use [CUDA] (https://developer.nvidia.com/cuda-zone) is available on the platform where the learning takes place.

There are several parameters that have default values ​​but can be defined if necessary:

• m: the size of the feature map
• divides_in_row: the number of divisions in rows of the input tensor.
• divides_in_col: the number of divisions in columns of the output tensor.
• rank: the chosen range of the tensioner.
• batch_size: the size of the training batch.
• test_batch_size - The batch size for the test.
• epochs: the number of training epochs for the network
• momentum: to specify the moment of the optimizer (only used in the case of SGD).
• log_interval: the interval for which the network inserts a message in the log.
• save: Boolean to specify whether or not to save the model.
• cuda: Boolean to specify whether or not CUDA is used.
• categories: number of categories for which you have to classify the network.
• log_while_training: whether to log messages or not during training
• tensor_size: the input size of the tensor.
• embedding: the size of the embedding used (if it exists).
• fixed_lenght: the cut size of the tensioner (0 for no cut).
• init_value: the value to use for the initialization of the tensors (only used in the case of a tensor network).
• rank_first_and_last: rank of the first and last tensor of the network (only used in the case of Tensor Ring).
• dropout: dropout used in the network (if the network has it).

Here is an example of how an experiment is defined:

result_data = {}
net_params = NetParams(EnumModel.TT_SHARED_MODEL, EnumDataset.FASHION_MNIST_FLAT_DIVISIONS,
              EnumTrainMethods.TRAIN_VISION_METHOD, 1e-4, Constant.ADAM,
              torch.cuda.is_available(), divides_in_col=4,
              divides_in_row=4, tensor_size=Constant.TENSOR_SIZE_MNIST,
              categories=Constant.CATEGORIES_CIFAR, m=64, rank=38,
              init_value=1)
run_net(net_params, result_data)

For more information please refer to the referenced paper.