Perceptron Multicamadas

Implementação paralela do Perceptron Multicamadas na linguagem CUDA, com o objetivo de comparar a performance e eficiência entre outras implementações do Perceptron Multicamadas (OpenACC e sequencial), já que o treinamento da rede é uma operação altamente custosa.

A implementação

Como o foco do implementação não estava na eficiência do treinamento da rede, e sim no na comparação de perfromance para meu TCC, a implementação utiliza um modelo para o treinamento da mesma bem simples, utilizando o algoritmo backpropagation, já que a rede pode possuir mais de uma camada.

Como compilar

Para compilar, basicamente serão necessários o CUDA Toolkit (que contém o compilador nvcc_) e o nosso querido GNU make (lembrando que todo código foi compilado utilizando um SO Linux, em Windows não faço idéia do comportamento esperado :/ ) para fazer todo o processo de compilação automatizado. Lembrando que no arquivo Makefile há diversas variáveis para configuração do código gerado, como a arquitetura alvo e etc, onde o mesmo está configurado para adaptadores gráficos com Compute Capability 6.1 (o código-fonte é compatível com a grande maioria dos adaptadores mais antigos, pois não usa operações atômicas e etc).

make # Executar este comando na pasta raíz do projeto (e torcer para compilar!)

As etapas (básicas) para o treinamento da rede

Há uma estrutura específica para os armazenar os padrões de treinamento, onde a mesma consiste basicamente de dois vetores, um vetor com a amostra à ser apresentada à rede e outra com a saída desejada para rede:

/**
 * Estrutura que irá representar um padrão de treinamento
 * para ser apresentado à rede.
 */
typedef struct {
  /** A vetor com a amostra (entrada da rede). */
  const float * d_amostra;
  
  /** Vetor com os valores desejados para saída da rede (objetivo). */
  const float * d_alvo;

} PadraoTreinamento;	

Essa estrutura, pode ser populada tanto manualmente, ou através de dois arquivos no formato CSV (um com as amostras e outro com os vetores de objetivo), utilizando a função abaixo (lembrando que os dados serão carregados na memória do adaptador gráfico):

/**
 * Método que carrega os padrões de treinamento de dois arquivos, um com as
 * amostras (que são normalizadas pela função), onde cada linha do mesmo
 * representa uma amostra (com os valores separados por ponto e vírgula ";"), e
 * outro com o vetor de objetivos para cada amostra respectivamente
 * (com os valores separados por ponto e vírgula também).
 *
 * @param nome_arquivo_amostras Nome do arquivo (com extensão) com as amostras
 *                              dos padrões de treinamento ou de teste.
 *
 * @param nome_arquivo_objetivos Nome do arquivo (com extensão) com os
 *                               objetivos dos padrões de treinamento ou
 *                               de teste.
 *
 * @param menor_val_amostra Menor valor presente nas amostras
 *                          (para normalização)
 *
 * @param maior_val_amostra Maior valor presente nas amostras
 *                          (para normalização)
 *
 * @param qtd_itens_amostra Quantidade de itens por amostra.
 *
 * @param qtd_itens_v_objetivo Quantidade de itens por vetor de objetivo.
 *
 * @param qtd_padroes Quantidade de padrões nos arquivos.
 *
 * @return Vetor com os padrões de treinamento ou de teste carregados na memória
 *         do adaptador gráfico ou NULO caso não seja possível abrir os arquivos
 *         para leitura.
 */
PadraoTreinamento * carregar_padroes_arquivo(char * nome_arquivo_amostras,
					     char * nome_arquivo_objetivos,
					     float menor_val_amostra,
					     float maior_val_amostra,
					     int qtd_itens_amostra,
					     int qtd_itens_v_objetivo,
					     int qtd_padroes);

Também é necessário alocar a estrutura do Perceptron Multicamadas na memória utilizando a seguinte função:

/**
 * Método que aloca o Perceptron Multicamadas na memória do hospedeiro,
 * salvo os atributos das camadas que serão salvos no adaptador gráfico.
 *
 * @param qtd_neuronios_entrada Quantidade de neurônios da camada de
 *                              entrada.
 *
 * @param qtd_camadas Quantidade de camadas (em que há processamento).
 *
 * @param qtd_neuronios_camada Vetor com a quantidade de neuronios para cada
 *                             camada.
 * 
 * @param funcao_ativacao_rede Função de ativação da rede, ou seja, todas as
 *                             camadas da rede estarão atribuidas para serem
 *                             ativadas com tal função (usar a enumeração
 *                             "funcoes_ativacao_enum"). Lembrando que, caso se
 *                             deseje que as camadas tenham funções de ativação
 *                             diferente, estabelecer manualmente estes valores
 *                             nas respectivas camadas. 
 *
 * @return Referência para a estrutura alocada.
 */
PerceptronMulticamadas *
inicializar_PerceptronMulticamadas(int qtd_neuronios_entrada,
				   int qtd_camadas,
				   int * qtd_neuronios_camada,
				   int funcao_ativacao_rede);	

FINALMENTE, agora é a hora de iniciar o treinamento com a função abaixo (^_^):

/**
 * Método que realiza o treinamento da rede através do método "backpropagation"
 * utilizando os padrões passados por parâmetro. A rede irá ser treinada
 * até que o erro MSE da mesma seja menor ou igual ao "erro_desejado" OU
 * até que a rede atinja a quantida máxima de épocas (QTD_MAX_EPOCAS).
 *
 * @param pm Perceptron.
 *
 * @param padroes Padrões para treinamento.
 *
 * @param qtd_padroes_treinamento Quantidade de padrões de treinamento.
 *
 * @param taxa_aprendizagem Taxa de aprendizagem.
 *
 * @param erro_desejado Condição de parada para o treinamento
 * da rede.
 *
 * @param gerar_historico Se será necessário gerar o histórico ou não.
 *
 * @return Histórico de treinamento.
 */
HistoricoTreinamento *
treinamento_PerceptronMulticamadas(PerceptronMulticamadas * pm,
				   PadraoTreinamento * padroes,
				   int qtd_padroes_treinamento,
				   float taxa_aprendizagem,
				   float erro_desejado,
				   bool gerar_historico);

Para demais informações em relação as funções, basta olhar os arquivos de cabeçalho, pois as funções estão devidamente documentadas (acredito eu).