Principais Configurações na Integração de Visão Computacional e Aprendizagem Profunda: Algoritmos e Técnicas

Grupo: LAMIA - Laboratório de Aprendizado de Máquina e Imagens Aplicados à Indústria
Email: lamia-sh@utfpr.edu.br
Organização: Universidade Tecnológica Federal do Paraná - Campus Santa Helena

Status do Projeto: Em desenvolvimento ⚠️

___

Resumo

Os scritps implementam vários modelos do estado da arte da aprendizagem profunda. Dentre eles estão AlexNet, ResNet-34 e MobileNet. Os modelos não se limitam as redes CNNs, assim este repositório contem implementações de Máquinas de Boltzmann e Autocodificadoras. Além dos modelos implementados, os scripts fornecem um protocolo de experimentos que possibilita a visualiação de métricas de avaliação, a criação e restauração de estados dos experimentos. Todo o protocolo de experimentos é configurado no arquivo .json. Os modelos foram contruídos em Tensorflow. Os testes realizados são feitos nas bases CIFAR-10 e MNIST.

Os códigos desenvolvidos fazem parte da monografia: Principais Configurações na Integração de Visão Computacional e Aprendizagem Profunda: Algoritmos e Técnicas. Monografia defendida na UTFPR

Objetivos

O objetivo geral deste projeto é fornecer modelos de apredizagem profunda construídos em Tensorflow para tarefas de visão computacional, que facilitem o desenvolvimento de aplicações de propósito geral, em especial a aplicações de visão computacional. Dentre alguns dos objetivos específicos do projeto estão.

• Implementar um protocolo de experimento para realização de testes com modelos construídos
• Visualizar principais métricas de avalição por meio de gráficos e tabelas
• Criar um módulo para salvar os estados do experimentos

Estrutura dos scripts

arquivo	Descrição
checkpoints.py	Módulo responsável por salvar pesos e os históricos das métricas do modelo em execução. WeightsCheckpoint e HistoryCheckpoint são classes que extendem a classe keras.callbacks.Callback. Os pesos e históricos são salvos a cada 100 épocas. Esta configuração pode ser alterada diretamente no módulo checkpoints.
dataset.py	Possui uma única classe: DatasetFacotry. Esta classe é responsável por gerenciar as bases de dados disponíveis, além de restaurar os indexs da base de dados anterior, afim de dá continuaidade ao experimento interrompido.
experiment.py	Constrói o experimento definido no arquivo experiment.json. Assim, define um novo estado ou recarrega um já existente, se o experimento não foi finalizado. O diretório dos estados do experimento são definidos no arquivo json. Este módulo possui apenas uma classe: Experiment. Após contruir ou recarregar o estado, a classe Experiment inicia o experimento.
experiment.json	Arquivo Json: chave-valor. Aqui é definido modelos, otimizadores, protocolos e outras chaves que caracterizam o experimento. Veja a seção "o arquivo Json" para mais informações das possiveis chaves e seus respectivos valores.
main.py	Módulo que executa a aplicação
metrics.py	Neste módulo está definido as métricas de avaliação disponíveis. Aqui também pode ser implementadas novas métricas
models.py	Módulo com implementação dos modelos e classes de suporte. Veja a seção "Modelos" para consultar todos os algoritmos disponíveis.
optmizers.py	Neste módulo está definido os otimizadores. Os otimizadores são os mesmo que estão disponíveis pelo Keras. Este módulo serve apenas como um adaptador.
save.py	Módulo auxiliar para salvar históricos, modelos, resultados e estados.
state.py	Módulo responsável pelo gerenciamento dos estados do experimento. Um estado é caracterizado por: id do experimento; número de épocas; protocolo de validação e o camhinho onde serão salvos os estados. O protocolo de validação é definido por métodos de validação de modelos preditivos. Dois método foram implementados K-fold e Hold-out. Cada método possui seu próprio estado e este estado é salvo no estado geral do experimento.
utils.py	Módulo com diversas classes e funções para diversos fins. Neste móudulo é encontrado classes para plotar gráficos e funções que auxiliam na construção de modelos
validation.py	Os métodos de validação são definidos neste módulo como classes. Os métodos disponíveis são métodos de validação cruzada: K-fold e Hold-out.

O arquivo Json

O código abaixo é um exemplo de configuração de experimento. O exemplos ilustra todos as chaves possíveis e com alguns de seus valores.

{
    "models": [
        "alexnet"
    ],
    "dataset": "mnist",
    "processing": {
        "flat": false,
        "concat": true,
        "expand": false,
        "normalize": false
    },
    "optimizer": "sgd",
    "opt_params": {
        "learning_rate": 0.01,
        "momentum": 0.9,
        "decay": 0.0001
    },
    "loss": "categorical_crossentropy",
    "metrics": [
        "categorical_accuracy",
        "Precision",
        "Recall",
        "AUC",
        "f1_score"
    ],
    "initializers": false,
    "epochs": 400,
    "batch": 256,
    "data_augmentation": false,
    "decay": true,
    "dir": "/content/drive/My Drive/TCC/",
    "exp":{
        "holdout": [10]
    }
}

As chaves e valores são mostrados a seguir:

chave	valor	tipo
model	alexnet, resnet, moiblenet, autoencoder, bm	vetor de string
dataset	cifar10, mnist	string
processing	dicionário com as chaves flat, concat, expand e normalize	dicionário com valores booleanos
optimizer	sgd, adam	string
opt_params	dicionário com as chaves learning_rate, momento, decay	dicionário com valores decimais
loss	categorical_crossentropy	string
metrics	categorical_accuracy, Precision, Recall, AUC, f1_score	vetor de strings
initializers	true ou false	boolean
epochs	qualquer valor inteiro	inteiro
batch	qualquer valor inteiro	inteiro
data_augmentation	true ou false	boolean
decay	true ou false	boolean
dir	path para salvar o experimento	string
exp	dicionário com o método de validação, holdout ou kfold	dicionário, valores como vetores de inteiros

Como Utilizar

Para clonar e rodar está aplicação será necessário o Git e o Python3 (python 3.6 ou superior) instalados em sua máquina. A partir da linha de comando descrita abaixo será possível clonar este repositório.

# Clone this repository
$ git clone https://github.com/lamiautfpr/TCC-01-2019-PRINCIPAIS-CONFIGURACOES-NA-INTEGRACAO-DE-VISAO-COMPUTACIONAL-E-DEEP-LEARNING-ALGORITMOS.git

# Go into the repository
$ cd TCC-01-2019-PRINCIPAIS-CONFIGURACOES-NA-INTEGRACAO-DE-VISAO-COMPUTACIONAL-E-DEEP-LEARNING-ALGORITMOS

Note: If you're using Linux Bash for Windows, see this guide or use the command prompt from your IDE.

Agora que você já está com o repositório clonado será necessário criar um virtual environment para armazenamento das bibliotecas presentes no requeriments. No diretório do projeto utilize as linhas de comando abaixo:

# Create virtualenv
$ virtualenv venv

# Execute virtual env
$ source venv/bin/activate

Note: Este passo pode ser ignorado caso não possua uma ambiente virtual. Ambientes virtuais são recomendados para a execução de aplicações em python.

Com o virtual enviroment criado, será necessário baixar as bibliotecas presentes no requeriments.txt. Para isso basta utilizar o pip3 para fazer a instalação recursiva de todas as bibliotecas presentes no arquivo de texto. Certifique-se que o shell está no diretório do requeriments. Recomenda-se a utilização da execução em super usuário utilizando sudo.

# Install all requeriments
$ sudo pip3 install -r requeriments.txt

Com a criação do ambiente finalizada, configure o arquivo experiment.json com os dados do experimento que queira executar (veja a seja sobre o arquivo json para cada campo). Após a configuração do experimento utilize o comando a baixo:

$ python src/main.py src/config/experiment.json

O comando descrito acima construirá todos o modelos e executará os testes com o protocolo de experimento escolhido. É recomendado que os modelos implementados sejam executados sobre GPU ou TPU, dada a complexidade computacional exigida por algoritmos baseados em aprendizagem profunda. O Google Colaboratory pode ser utilizado para realização de testes em aceleradores gráficos. Também recomendamos a replicação dos resultados da monografia, afim verificar se todas as cofiguraçoes foram feitas corretamente. Para isso, copie o protocolo descrito na monografia de referência.

As bibliotecas utilizadas no projeto estão presentes no arquivo requeriments.txt.

google-auth==1.18.0
google-auth-oauthlib==0.4.1
google-pasta==0.2.0
Keras-Preprocessing==1.1.2
matplotlib==3.3.0
numpy==1.19.0
pandas==1.0.5
Pillow==7.1.2
scikit-learn==0.23.1
scipy==1.4.1
seaborn==0.10.1
sklearn==0.0
tensorboard==2.2.2
tensorboard-plugin-wit==1.7.0
tensorflow-cpu==2.2.0
tensorflow-estimator==2.2.0

Considerações na instalação do Tensorflow

O método mais simples de instalação do Tensorflow é utilizando o pacote pip disponível no repositório oficial do python. Entretanto, pode apresentar erros se a máquina alvo não suportar as configurações do pacote construído pela Google. Um erro recente é o suporte ao AVX (Advanced Vector Extensions) da CPU, visto que processadores antigos não possuem esta flag. O erro é mostrado abaixo:

Illegal instruction (core dumped)

Para verificar se a máquina alvo possui a flag AVX utilize:

more /proc/cpuinfo | grep flags

Existem algumas formas de contornar este problema. A primeira dela é compilação do Tensorflow na própria máquina. Com a compilação na máquina alvo é possivel otimizar o Tensorflow com as flags disponíveis na própria CPU. O site oficial do Tensorflow mostra os passos para a compilação personlizada. outros sites podem auxiliar na compilação, veja https://tech.amikelive.com/node-882/how-to-build-and-install-the-latest-tensorflow-without-cuda-gpu-and-with-optimized-cpu-performance-on-ubuntu/ e https://tech.amikelive.com/node-887/how-to-resolve-error-illegal-instruction-core-dumped-when-running-import-tensorflow-in-a-python-program/. Este método é dispendioso e dependedo da máquina pode levar dias para o término.

A segunda forma é a utilização do Tensorflow já compilado sem AVX pelo site BountySource. Este site possui um repositório de wheels do Tensorflow mantidas por usuários. Lá é possivel o download de pacotes sem AVX. Para instalar pacotes no pip que não estão no repositório oficial utilize o comando:

pip install <caminho do arquivo.whl>

Modelos

A aplicação usa os seguintes algoritmos:

• AlexNet - Rede convolucional com 8 camadas pioneira no uso de GPU para o seu treinamento
• ResNet - Rede convolucional com o uso de blocos residuais. Rede super profunda.
• MobileNet - Rede Convolucional com para dispositivos móveis ou com restrições computacionais.
• Autoencoder para redução de dimensionalidade - Rede Autoencoder especializada em reduzir a dimensionalidade dos dados.
• Autoencoder de filtragem de ruído - Rede Autoencoder especializada em filtrar ruídos do dados.