Manual do SCAE

Índice

1 Introdução
2 Tutorial sobre o SCAE
3 Organização do SCAE

Introdução

Este manual visa explicar como utilizar o SCAE, desde sua instalação e manutenção até sua utilização.

Tutorial sobre o SCAE

Introdução

O Sistema de Codificação Automática de Atividades Econômicas (SCAE) possui a arquitetura mostrada na Figura 1. A interface de usuário com o Sistema é um navegador Internet (browser), que se comunica com o módulo Servidor de Aplicação (SA) do SCAE. Este módulo, por sua vez, se comunica com os outros dois módulos do SCAE: Core e Banco de Dados (BD).

Figura 1: Arquitetura do SCAE

Em uma solicitação de classificação de atividade econômica, o usuário, por meio da interface (via web), envia ao SA uma descrição de atividade econômica. O SA, por sua vez, envia esta descrição ao Core, que a classifica e retorna códigos CNAE e medidas de confiança quanto às associações destes códigos com a descrição de atividade econômica recebida. De posse dos códigos CNAE, o SA requisita ao BD seus textos associado (descritores).

O Core também se comunica com o módulo BD, que é responsável por armazenar todo o conhecimento do SCAE (dicionário eletrônico; representação, interna ao Sistema, da tabela CNAE e das descrições de atividades econômicas usadas em treinamento; etc.). Além de realizar a classificação, o Core manipula as tabelas do Sistema (cria, insere dados, remove dados, etc.) armazenadas em BD. Diferentes submódulos do Core são responsáveis por esta manipulação. O SA está sendo desenvolvido em PHP, o BD em C, e o Core em C, Perl e Java.

Download

Como Acessar o Repositório do SCAE

É possível acessar o repositório do SCAE através de um navegador ou ainda baixar seus códigos direto para sua máquina. O acesso só é permitido a usuários do Projeto SCAE cadastrados e com conta no LCAD.

Organização do Repositório

O repositório está dividido da seguinte maneira:

code
- CORES (códigos-fonte dos categorizadores)
  - DB_CORE
  - USER_INTERFACE
  - VS_CORE
  - WISARD_CORE
  - WNN_CORE
  - WNN_COR_CORE
  - config
  - shared (diretório da biblioteca compartilhada de comunicação)
- db_server (código da API do Oracle -- em desuso no momento)
- scaeweb (código da Interface WEB)
data (dados do Oracle -- em desuso no momento)
install (diretório de instalações)
Roteiros

Navegando no Repositório

Para acessar o repositório através de um navegador, basta seguir para http://www.lcad.inf.ufes.br/svn/scae e utilizar sua conta/senha do LCAD.

Baixando o SCAE para sua Máquina

Antes de baixar o repositório do SCAE, recomenda-se navegar pelo mesmo e identificar qual(is) de suas partes será(ão) utilizada(s). Dessa forma, é possível fazer o download apenas das partes de interesse, evitando um longo download de todo seu conteúdo.

Para baixar o repositório completo do SCAE para sua máquina utilize

svn co http://www.lcad.inf.ufes.br/svn/scae

Para baixar apenas uma parte, por exemplo, um diretório da árvore do repositório, acrescente o caminho ao endereço. Exemplo:

Baixar apenas os códigos-fonte dos CORES

svn co http://www.lcad.inf.ufes.br/svn/scae/code/CORES

Outras informações sobre o svn podem ser encontradas no nosso manual de Uso Básico do Subversion.

Como Acessar o Repositório MAE

Também é possível acessar o repositório da Máquina Associadora de Eventos (MAE) através de um navegador ou ainda baixar seus códigos direto para sua máquina. O acesso só é permitido a usuários do Projeto SCAE cadastrados e com conta no LCAD.

Organização do Repositório

O Repositório está dividido da seguinte maneira:

bin
docs
etc
examples
- biological_vergence
- brain
- calibration
- character
- circle
- class_cnae
- doorman
- face_recog
- face_recog2.2
- face_recog_new
- face_recog_without_filters
- log_polar
- monks
- qian
- qian_analysis
- robot
- robot008
- robot013
- robot020
- robot050
- robot_explorer
- robot_motion
- robot_mult_freq
- robot_smv
- robot_smv_10.0
- robot_smv_11.0
- robot_smv_12.0
- robot_smv_13.0
- robot_smv_2.0
- robot_smv_3.0
- robot_smv_4.0
- robot_smv_5.0
- robot_smv_7.0
- robot_smv_8.0
- robot_smv_9.0
- robot_without_filters
- simple_xor
- smv
- smv1.1
- smv2.0
- stereo
- test_filter
- vergence
- visual_search
- visual_search_1.0
- visual_search_10.0
- visual_search_1.1
- visual_search_1.2
- visual_search_2.0
- visual_search_2.1
- visual_search_4.0
- visual_search_5.0
- visual_search_7.0
- visual_search_8.0
- visual_search_9.0
- visual_search_smv
- visual_search_statisc
- visual_search_without_filters
- wnn_cnae
- wnn_cor_cnae
images
include
lib
src
tools

Navegando no Repositório

Para acessar o repositório através de um navegador, basta seguir para http://www.lcad.inf.ufes.br/svn/MAE e utilizar sua conta/senha do LCAD.

Baixando a MAE para sua Máquina

Para baixar o repositório completo da MAE para sua máquina utilize:

svn co http://www.lcad.inf.ufes.br/svn/MAE

Importante: recomenda-se fortemente salvar o diretório raiz da MAE em /opt.

Instalação

Um roteiro detalhado de instalação do SCAE pode ser encontrado em http://www.lcad.inf.ufes.br/svn/scae/Roteiros. Neste tutorial, apresentamos apenas um procedimento de instalação simplificado, que assume que o sistema operacional utilizado é o Fedora Core 8 e que várias bibliotecas já estão instaladas (em muitas instalações Fedora, mesmo anteriores à versão 8, ele deve ser o suficiente para colocar o SCAE em operação). Contudo, verifique se as bibliotecas w3c-libwww e xmlrpc-c estão instaladas com os comandos (se elas não estiverem instaladas, estes comandos as instalarão):

yum install w3c-libwww
yum install w3c-libwww-devel
yum install xmlrpc-c
yum install xmlrpc-c-devel

Notamos que, caso a versão das bibliotecas w3c-libwww e xmlrpc-c instaladas no seu sistema seja a mesma versão disponível no repositório do SCAE em:

  http://www.lcad.inf.ufes.br/svn/scae/install/xmlrpc/,

é necessário que elas sejam removidas e reinstaladas a partir da versão disponível no repositório do Fedora, usando o comando yum, como especificado acima.

Para iniciar a instalação do SCAE, baixe (download) seus arquivos de instalação. Para isso, vá para o diretório raiz de sua conta e digite o comando (você vai precisar de uma senha para baixar os arquivos; solicite-a via o e-mail de suporte do LCAD):

svn co http://www.lcad.inf.ufes.br/svn/scae/code

Este comando vai criar o diretório code e vários subdiretórios (se você precisar remover todo o diretório code não se esqueça de deletar o arquivo .subversion que fica no seu diretório raiz).

Instalação do corretor ortográfico

A partir da Versão do SVN 490

Antes de compilar o DB_CORE, é necessário instalar as bibliotecas do corretor ortográfico do SCAE. Para isso, siga os passos abaixo:

1 - Verifique se o diretório DB_CORE/SPELLER/scaeaspell-0.60.5/ existe. Caso contrário, digite:

svn up

2 - Entre no diretório DB_CORE/SPELLER/scaeaspell-0.60.5/ e digite:

./configure --prefix=/usr --sysconfdir=/etc --enable-shared
make

3 - Inclua no .bashrc o caminho das bibliotecas do Aspell:

#SCAE SPELLER
LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$HOME/scae/code/CORES/DB_CORE/SPELLER/scaeaspell-0.60.5/.libs
export LD_LIBRARY_PATH

4 - Atualize as variáveis de ambiente:

source .bashrc

Agora, o DB_CORE está pronto para ser compilado.

Antes da Versão do SVN 490

Antes de compilar o DB_CORE, é necessário instalar as bibliotecas do corretor ortográfico do SCAE. Para isso, siga os passos abaixo como root:

1 - Verifique se o Aspell está instalado na máquina. Caso esteja instalado passe para o passo 2. Caso contrário, digite na linha de comando:

yum install aspell

2 - Realizar o download do source do SCAEAspell para o diretório /opt:

cd /opt
svn co http://www.lcad.inf.ufes.br/svn/scae/code/CORES/install/scaeaspell/
tar -xzf scaeaspell/scaeaspell-0.60.5.tar.gz
tar -xjf scaeaspell/aspell6-pt_BR-20070411-0.tar.bz2
rm -rf scaeaspell/

4 - Instale o dicionário pt_BR no Aspell:

cd /opt/aspell6-pt_BR-20070411-0
./configure
make
make install

5 - Instale as bibliotecas do SCAE:

cd /opt/scaeaspell-0.60.5
./configure --prefix=/usr --sysconfdir=/etc --enable-shared
make
make install

O dicionário no formato do Aspell já foi gerado e encontra-se no diretório code/CORES/DB_CORE/SPELLER/dictionary. Para utilizá-lo, copie os seguintes arquivos para o diretório /usr/lib/aspell-0.60:

cp  code/CORES/DB_CORE/SPELLER/dictionary/dict_scae.multi /usr/lib/aspell-0.60/
cp  code/CORES/DB_CORE/SPELLER/dictionary/dict_scae.rws /usr/lib/aspell-0.60/
cp  code/CORES/DB_CORE/SPELLER/dictionary/keyboard.kbd /usr/lib/aspell-0.60/

O arquivo dict_scae.multi é apenas um alias para dict_scae.rws, e o arquivo keyboard.kbd é um mapeamento do teclado ABNT para análise tipográfica.

Obs.: O corretor ortográfico do SCAE é baseado no corretor Aspell e utiliza um dicionário gerado a partir do arquivio dicionário_completo_corrigido.csv. Para gerar o dicionário no formato do Aspell, digite na linha de comando:

aspell --lang=pt_BR --encoding=UTF-8 create master ./dict_scae < arquivo_entrada

O arquivo de entrada deve ter uma palavra por linha.

Posteriormente, siga para a compilação do DB_CORE.

Compilando e Executando o BD

Antes de compilar o DB_CORE é necessário seguir os passos abaixo (como root):

Por default, o Fedora Core 6 vem com um Java antigo instalado, então você precisa instalar a versão mais nova do Java Runtime Environment para desfrutar de todas as suas funcionalidades. Abaixo, nós o ensinaremos a instalar/atualizar seu Java Environment.

O primeiro passo é realizar o dowload daqui [1]. Você precisará aceitar a licença e selecionar linux como plataforma. Após clicar em continue, um nova página será aberta, na qual você deverá selecionar o arquivo .bin de nome jdk-6u4-linux-i586.bin. Após a seleção o download será iniciado.

Mova o arquvio para o /opt:

 mv jdk-6u4-linux-i586.bin /opt

Transforme este arquivo em um executável chmod +x jdk-6u4-linux-i586.bin

Execute o .bin com o seguinte comando:

./jdk-6u4-linux-i586.bin

Você será perguntado, novamente, se concordar com os termos da licença, aperte espaço até aparecer a pergunta se concorda ou não. Digite yes e a extração começará.

Crie o seguinte arquivo com seu editor de texto preferido:

vim /etc/profile.d/java.sh
chmod +x /etc/profile.d/java.sh

Agora cole as seguintes opções no arquivo. Lembre-se do carriage return depois destas linhas, então salve-o:

export JAVA_HOME=/opt/jdk1.6.0_04
export PATH=$JAVA_HOME/bin:$PATH

Agora execute o seguinte comando para tornar o arquivo disponível:

source /etc/profile.d/java.sh

Então execute o seguinte comando para ver se o path está correto:

which java

Você deveria ver algo como: /opt/jdk1.6.0_04/bin/java

Agora execute os seguintes comandos:

/usr/sbin/alternatives --install /usr/bin/java java /opt/jdk1.6.0_04/bin/java 2
/usr/sbin/alternatives --config java

Após ter inserido o último comando, você será perguntado sobre o tipo de Java que deseja para o sistema. Pressione 2 e aperte enter.

Para ver a versão do seu Java Runtime Environment, execute:

java -version

Deveria ser igual a este:

java version "1.6.0_04"
Java(TM) SE Runtime Environment (build 1.6.0_04-b12)
Java HotSpot(TM) Client VM (build 10.0-b19, mixed mode, sharin

Por último, adicione as seguintes linhas ao seu .bashrc

#JAVA
LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$JAVA_HOME/jre/lib/i386
export LD_LIBRARY_PATH
LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$JAVA_HOME/jre/lib/i386/client
export LD_LIBRARY_PATH

Agora sim o DB_CORE pode ser compilado com sucesso.

Compile o BD (Figura 1) executando os seguintes comandos:

cd code/CORES/DB_CORE
make clean
make

Estes comandos vão criar o executável db_core no diretório code/CORES/DB_CORE. Este arquivo, quando executado, será um daemon que implementa o BD.

CRIAÇÃO DE TABELAS

Após compilado, podemos utilizar o db_core para criar um conjunto básico de tabelas que permitem demonstrar as funcionalidades do SCAE (assuma sempre que o diretório corrente é o último especificado por um comando cd). Executemos, por exemplo, o script abaixo:

./build_tables_subclasse_110_tf.bat

A saída deste comando deve ser:

Locale set to pt_BR.UTF-8.
Loading known tables from .csv
Number of known tables = 18
Creating KNOWN_LEXICONS_saved.csv file.
Creating KNOWN_TTVS_saved.csv file.
Creating KNOWN_TRAININGS_saved.csv file.
Creating KNOWN_TESTS_saved.csv file.
Loading dictionary .csv
Number of dictionary words = 1212255
Number of distincts words = 843235
Loading cnae subclasses .csv
Number of CNAE-Subclasses = 1183
Loading dados 'CSV_FILES/dados_vitoria_110.csv'
Number of economic activities descriptions = 14204
Number of distinct economic activities descriptions = 3281
Loading dados 'CSV_FILES/dados_bh_110.csv'
Number of economic activities descriptions = 175770
Number of distinct economic activities descriptions = 87999
Lexicon size = 1356. Number of words discarded due to word frequency (PFS) = 0.

CRIAÇÃO DE DICIONÁRIOS A PARTIR DE FILTROS

O DB_CORE permite que você construa dicionários filtrados a partir de tabelas (CNAE e/oui dados) ou a partir de um dicionário preexistente. Abaixo, descreveremos dois scripts que geram tais dicionários.

Criando um dicionário a partir de tabelas

O script abaixo usa o db_core para criar um dicionário filtrado a partir de: um filtro especificado, opções de filtragem e tabelas (CNAE e/ou dados):

./build_filtered_dictionary_from_tables.bat

Este script contém as seguintes linhas:

./db_core \
load_csv_cnae_subclasse CNAE_110_SUBCLASSE \
load_csv_dados DADOS_VITORIA_SUB_110 \
create_filtered_dictionary DICIONARIO_STOP_STEMM_ACCENT 1 "STOP + STEMM + ACCENT" 2 CNAE_110_SUBCLASSE-DESCRICAO_SUB DADOS_VITORIA_SUB_110-OBJETO_SOCIAL

DICIONARIO_STOP_STEMM_ACCENT é o nome do dicionário a ser criado. Este diconário será automaticamente inserido na Known_tables. O número 1 especifica que o filtro utilizará o stemmizador da Maria Abadia Lacerda Dias (mald@univates.br) (2 especifica que o filtro utilzará o stemmizador do Patraick Marques Cirelli). O texto entre aspas especifica as filtragens a serem adotadas (STOP = sem stop-words, STEMM = realiza stemming e ACCENTE = retira acento). O número 2, no exemplo, especifica a quantidade de tabelas que serão utilizadas para constrir o dicionário filtrado.

Criando um dicionário a partir de outro dicionário

O script abaixo usa o db_core para criar um dicionário filtrado a partir de: um filtro especificado, opções de filtragem e um dicionário preexistente.

./build_filtered_dictionary_from_dictionary.bat

Este script contém as seguintes linhas:

./db_core \
load_dictionary DICIONARIO \
create_filtered_dictionary_from_dictionary DICIONARIO_FILTERED_VERSION 1 "STEMM + STOP + ACCENT" DICIONARIO

DICIONARIO_FILTERED_VERSION é o nome do dicionário a ser criado. Este diconário será automaticamente inserido na Known_tables. O número 1 especifica que o filtro utilizará o stemmizador da Maria Abadia Lacerda Dias (mald@univates.br) (2 especifica que o filtro utilzará o stemmizador do Patraick Marques Cirelli). O texto entre aspas especifica as filtragens a serem adotadas (STOP = sem stop-words, STEMM = realiza stemming e ACCENTE = retira acento). O último parâmetro, DICIONARIO, especifica o nome do dicionário que servirá de base para a construção do novo.

Execuntando o DB_CORE SERVER

Após ter criado todas as tabelas de interesse, você pode colocar o daemon db_core em operação com o comando:

nohup ./db_core init_server ports.cfg&

Mensagens de erro geradas pelo db_core serão gravadas no arquivo nohup.out, conforme mensagem mostrada após a execução do comando acima (nohup: ignoring input and appending output to nohup.out). Com a execução deste comando, o BD da Figura 1 estará em operação. As tabelas mantidas por este banco de dados são necessárias para a operação do SCAE serão carregadas conforme demandadas pelo SCAE. Para interromper o db_core, descubra o seu PID com o comando:

ps -A | grep db_core

e kill o db_core com o comando

kill -9 PID (onde PID é o número do processo informado pelo comando ps)

Compilando a Biblioteca Compartilhada de Comunicação (shared)

Antes de compilar e executar um CORE, é necessário garantir que a biblioteca compartilhada de comunicação esteja compilada e que sua variável de ambiente esteja setada. Para isto, siga os passos a seguir:

cd code/CORES/shared
make clean
make

Em seguida, insira as seguintes linhas ao seu .bashrc (localizado no seu diretório home):

# SHARED 
export SHAREDHOME=$HOME/code/CORES/shared

Compilando a Biblioteca Compartilhada MAE

Antes de compilar a MAE e os CORES WNN_CORE e WNN_COR_CORE, são necessárias algumas bibliotecas, que podem ser instaladas com os comandos abaixo (você precisa ser root para executar o yum):

yum install xforms xforms-devel freeglut freeglut-devel libnet-devel byacc

Para compilar a MAE vá para o seu diretório raiz e digite os comandos:

make clean
make –f Makefile.no_interface

Em seguida, insira as seguintes linhas ao seu .bashrc (localizado no seu diretório home):

# MAE 
export MAEHOME=$HOME/PATH/MAE
PATH=$PATH:$MAEHOME/bin

Compilando e Executando o VS_CORE

O Core da Figura 1, na verdade, pode ser composto por um ou mais classificadores. Na versão atual do SCAE, três classificadores estão disponíveis: VS_CORE WNN_CORE e WNN_COR_CORE. O Vector Space (VS)_Core emprega a técnica de mesmo nome para classificar (na verdade, categorizar) texto, enquanto que o Weightless Neural Network (WNN)_Core e o Weightless Neural Network Correlate (WNN_COR)_Core empregam redes neurais sem peso (do tipo Virtual Generalizing Ramdon Access Memory - VG-RAM) para o mesmo fim. Mais detalhes sobre como estas técnicas podem ser usadas para categorizar objetos sociais de empresas (atividades econômicas) segunda a tabela de Classificação Nacional de Atividades Econômicas (CNAE) podem ser encontrados no trabalho De Souza, A. F.; Pedroni, F.; OLIVEIRA, E.; Ciarelli, P. M.; Henrique, W. F.; Veronese, L. . Automated Free Text Classification of Economic Activities using VG-RAM Weightless Neural Networks. International Conference on Intelligent Systems Design and Applications (ISDA), 2007, Rio de Janeiro. Proceedings of ISDA, 2007..

Para compilar o VS_CORE, volte para o seu diretório raiz e digite os comandos:

cd code/CORES/VS_CORE
make clean
make

Estes comandos vão criar o executável vs_core no diretório code/CORES/VS_CORE. Este executável é um daemon que implementa o Core que classifica segundo a técnica VS. Para colocá-lo em operação, digite:

nohup ./vs_core&

Com o comando acima, parte do Core da Figura 1 estará em operação. Para interromper o vs_core, descubra o seu PID com o comando:

ps -A | grep vs_core

e kill o vs_core com o comando

kill -9 PID (onde PID é o número do processo informado pelo comando ps)

Compilando e Executando o WNN_CORE

Antes de compilar o WNN_CORE você já deveria ter compilado a biblioteca MAE

Para compilar o WNN_CORE volte para o seu diretório raiz e digite os comandos:

cd code/CORES/WNN_CORE
make clean
make

Estes comandos vão criar o executável wnn_core no diretório code/CORES/WNN_CORE. Este executável é um daemon que implementa o Core que classifica texto usando VG-RAM WNN. Para colocá-lo em operação, digite:

nohup ./wnn_core&

Com o comando acima, uma segunda parte do Core da Figura 1 estará em operação. Para interromper o wnn_core descubra o seu PID com o comando:

ps -A | grep wnn_core

e kill o wnn_core com o comando

kill -9 PID (onde PID é o número do processo informado pelo comando ps)

Compilando e Executando o WNN_COR_CORE

Antes de compilar o WNN_COR_CORE você já deveria ter compilado a biblioteca MAE

Para compilar o WNN_COR_CORE volte para o seu diretório raiz e digite os comandos:

cd code/CORES/WNN_COR_CORE
make clean
make

Estes comandos vão criar o executável wnn_cor_core no diretório code/CORES/WNN_COR_CORE. Este executável é um daemon que implementa o Core que classifica texto usando VG-RAM WNN. Para colocá-lo em operação, digite:

nohup ./wnn_cor_core&

Com o comando acima, uma segunda parte do Core da Figura 1 estará em operação. Para interromper o wnn_cor_core descubra o seu PID com o comando:

ps -A | grep wnn_cor_core

e kill o wnn_cor_core com o comando

kill -9 PID (onde PID é o número do processo informado pelo comando ps)

Compilando e Executando o BOOSTEXTER_CORE

O BOOSTEXTR_CORE utiliza o executável boostexter para realizar o treinamento e o teste.

Para compilar o BOOSTEXTR_CORE, vá ao seu diretório raíz e digite os comandos:

cd code/CORES/BOOSTEXTR_CORE
make clean
make clean_knowledge (caso deseje apagar o treinamento já realizados pelo CORE)
make

Estes comandos vão criar o executável boostexter_core no diretório code/CORES/BOOSTEXTR_CORE.

Antes de colocá-lo em operação, deve-se configurar o arquivo boostexter.cfg localizado no diretório code/CORES/BOOSTEXTR_CORE. O arquivo indica dois parâmetros para o CORE: o primeiro, se o boostexter realizará um novo treinamento (o valor deve ser 1) ou se utilizará um treinamento já existente (o valor deve ser 0), e o segundo, o número de rounds que será utilizado para treinar o CORE (esse valor deve ser inteiro). A seguir um exemplo do arquivo de configuração:

new_training = 1
rounds = 50

Após configurar o arquivo boostexter.cfg, para colocá-lo em operação, digite:

nohup ./boostexter_core&

Com o comando acima, uma segunda parte do Core da Figura 1 estará em operação. Para interromper o boostexter_core descubra o seu PID com o comando:

ps -A | grep boostexter_core

e kill o boostexter_core com o comando

kill -9 PID (onde PID é o número do processo informado pelo comando ps)

O BOOSTEXTER_CORE guarda os arquivos de treinamento no diretório code/CORES/BOOSTEXTR_CORE/KNOWLEDGE.

Compilando e Executando o PNN_CORE

Para compilar o PNN_CORE, vá ao seu diretório raíz e digite os comandos:

cd code/CORES/PNN_CORE
make clean
make clean_memories (caso deseje apagar os treinamentos já realizados pelo CORE)
make

Estes comandos vão criar o executável pnn_core no diretório code/CORES/PNN_CORE.

para colocá-lo em operação, digite a linha abaixo, onde <sigma> corresponde a um parâmetro da rede (normalmente na faixa entre 0.2 a 10):

nohup ./pnn_core <sigma> &

Com o comando acima, uma segunda parte do Core da Figura 1 estará em operação. Para interromper o pnn_core descubra o seu PID com o comando:

ps -A | grep pnn_core

e kill o pnn_core com o comando

kill -9 PID (onde PID é o número do processo informado pelo comando ps)

O PNN_CORE guarda os arquivos de treinamento no diretório code/CORES/PNN_CORE/PNN_NETWORKS.

Configurando o SA

Com os deamons db_core, vs_core e class_cnae em operação, é possível examinar todas as funcionalidades do SCAE por meio de um browser, graças ao seu Servidor de Aplicação (SA) (ver Figura 1). O SA foi implementado em PHP e seu código fica no diretório code/scaeweb. Para acessá-lo através de um browser, ele precisa ser "servido" por um servidor http, como o Apache, por exemplo. Se você está instalando o SCAE em uma máquina stand alone, você pode instalar o apache e o php com o comando (você precisa ser root para usar o yum):

yum install apache php

Para que o apache sirva o SA, coloque um link simbólico do diretório scaeweb para o diretório raiz de páginas http do Apache (você precisa ser root para escrever no diretório raiz do Apache):

ln -s code/scaeweb /var/www/html/scaeweb

Além disso, vc precisa garantir que o caminho até o diretório code/scaeweb tenha permissão de leitura. Para isto basta adicionar essas permissões com o comando chmod. Por exemplo, caso seu diretório seja /home/usuario:

cd /home
chmod +r+x usuario

Você pode então acessar o SCAE com um browser em sua máquina na URL: http://127.0.0.1/scaeweb

Seu browser deve mostrar a imagem da Figura 2. Caso ela não apareça, você tem problemas de configuração no Apache ou PHP. Neste caso, se a mensagem do browser indicar que você não tem permissão de acesso ao diretório scaeweb, experimente copiar todo o conteúdo do diretório code/scaeweb para /var/www/html/:

rm /var/www/html/scaeweb
cp -r code/scaeweb /var/www/html

Caso o Apache funcione exibindo o conteúdo da página mas não consiga interpretar o php, experiemnte reiniciá-lo:

/etc/init.d/httpd restart

Figura 2: SCAE

Se funcionar, experimente voltar à solução com o link simbólico e reduzir o nível de segurança do SELinux (Security-Enhanced Linux) com a ferramenta Sistema->SELinux Management. Mude System Default Enforcing Mode e Current Enforcing Mode para Permissive. Se funcionar, o SELinux não permite que o Apache (httpd) acesse diretórios de usuário via links simbólicos (e possivelmente muitos outros diretórios). Neste caso, fique com a cópia de scaeweb no /var/www/http, ou deixe o SELinux como indicado acima, ou configure o SELinux para permitir que o Apache acesse links simbólicos.

Se a redução do nível de segurança do SELinux funcionar, o Apache pode não estar configurado para permitir o seu próprio acesso a links simbólicos. Neste caso, consulte a documentação do Apache sobre o assunto na Internet. O problema pode estar, também, no PHP.

Se você conseguir ver a Figura 2 no seu browser, o SCAE está pronto para operar (desde que também estejam rodando o DB_CORE e ao menos um core categorizador). Neste ponto, já é possível utilizar a interface para administrar o Sistema. Siga pelo link de Administração para treinar o categorizador desejado e ter a possibilidade de efetuar categorizações. Para maiores detalhes, remeta-se a seção Utilizando a Interface Web.

As demais funcionalidade do SCAE (inclusive sua interface via linha de comando) são apresentadas na próxima seção.

Usando o SCAE

Esta seção visa explicar como utilizar o DB_CORE para criar as tabelas a serem utilizá-las e também como executá-lo, como utilizar as interfaces de linha de comando e web para realizar treinamentos, testes e categorização.

Criando Tabelas no DB_CORE

O DB_CORE interpreta diretivas da linha de comando e executa tarefas de carregamento de tabelas e criação de lexicon entre outras. A seguir são detalhados os possíveis comandos ao DB_CORE:

create_filtered_dictionary NOME_DO_DICIONARIO FILTRO_ID "filtragem1 filtragem2 ... filtragemN" NUMERO_DE_TABELAS TABELA-COLUNA

NOME_DO_DICIONARIO : um nome sem espaços;
FILTRO_ID: um inteiro informando o filtro a ser utilizado;
"filtragem1 filtragem2 ... filtragemN" : as filtragens que serão empregadas (remoção de stop words, acentos e stemming) separadas por espaços e entre aspas duplas obrigatoriamente;
NUMERO_DE_TABELAS : um inteiro informando o número de tabelas que serão utilizadas;
TABELA-COLUNA : informar cada TABELA-COLUNA de acordo com o número de tabelas informado, dizendo o nome da tabela e da coluna;

load_dictionary NOME_DO_DICIONARIO

NOME_DO_DICIONARIO : um nome sem espaços;

load_csv_cnae_subclasse XXXXXXXXXX

Carrega a tabela subclasse de nome XXXXXXXXXX;

load_csv_dados_vitoria XXXXXXXXXX

Carrega a tabela de dados de Vitória de nome XXXXXXXXXX;

create_word_vectors_table XXXXXXXXXX-YYYYYYYYYY'

Cria a tabela de vetores para cada linha da coluna YYYYYYYYYY da tabela XXXXXXXXXX;

create_lexicon NOME_DO_LEXICON "Descrição do lexicon." NUMERO_DE_TABELAS TABELA-COLUNA:MIN:MAX ... TABELA-COLUNA:MIN:MAX 
"classe1 classe2 ... classeN" PFS

Cria um lexicon com os parâmetros fornecidos, onde:

NOME_DO_LEXICON : um nome sem espaços;
"Descrição do lexicon." : uma descrição obrigatoriamente entre aspas duplas;
NUMERO_DE_TABELAS : um inteiro informando o número de tabelas que serão utilizadas;
TABELA-COLUNA:MIN:MAX : informar cada TABELA-COLUNA:MIN:MAX de acordo com o número de tabelas informado, dizendo o nome da tabela, da coluna, limite inferior e superior;
"classe1 classe2 ... classeN" : as classes gramaticais a serem removidas separadas por espaços e entre aspas duplas obrigatoriamente;
PFS : um inteiro informando a frequencia maxima para inclusao de palavras no lexicon;

create_training_and_testing_vectors_table LEXICON QTDE TABELA-COLUNA ... TABELA-COLUNA CONSTRUÇÃO

Cria os vetores individuais de treinamento e teste com os parâmetros fornecidos, onde:

LEXICON : nome do lexicon;
QTDE : quantidade de TABELA-COLUNAs que serão informadas;
TABELA-COLUNA : par com o nome da tabela e da coluna;
CONSTRUÇÃO : método de construção do vetor final;

create_cnae_codes_vectors_table TABELA CONSTRUÇÃO

Constrói a tabela de códigos cnae:

TABELA : nome da tabela;
CONSTRUÇÃO : método de construção do vetor final;

create_ttv TTV LEXICON TABELA QTDE COLUNA ... COLUNA CONSTRUÇÃO

Cria uma tabela de vetores de treinamento e teste:

TTV : nome dado à tabela de ttv;
LEXICON : nome do lexicon a utilizar;
TABELA : nome da tabela (cnae ou dados) a utilizar;
QTDE : quantidade de colunas que serão informadas;
COLUNA : cada nome de coluna de acordo com a quantidade informada;
CONSTRUÇÃO : método de construção do vetor final;

save_tables_in_binary_format

Salva as tabelas carregadas e construídas em formato binário para posterior carregamento (mais rápido);

init_server ports.cfg

Inicializa o servidor com a configuração do arquivo ports.cfg

A seguir, temos um exemplo completo retirado do arquivo build_tables_subclasse_110_tf.bat

./db_core \
load_dictionary DICIONARIO \
load_csv_cnae_subclasse CNAE_110_SUBCLASSE \
load_csv_dados DADOS_VITORIA_SUB_110 \
load_csv_dados DADOS_BH_SUB_110 \
create_word_vectors_table CNAE_110_SUBCLASSE-DESCRICAO_SUB \
create_word_vectors_table DADOS_VITORIA_SUB_110-OBJETO_SOCIAL \
create_word_vectors_table DADOS_BH_SUB_110-OBJETO_SOCIAL \
create_lexicon LEXICON_LESS_ART_PREP_SUB_110 "Tudo menos artigos e preposicoes da tabela CNAE 1.1" 1
CNAE_110_SUBCLASSE-DESCRICAO_SUB:0:1182 "art. prep." 20000 \
create_ttv TTV_C1S_DESC LEXICON_LESS_ART_PREP_SUB_110 CNAE_110_SUBCLASSE 1 DESCRICAO_SUB DEFAULT TF \
create_ttv TTV_DVS1_OBJS LEXICON_LESS_ART_PREP_SUB_110 DADOS_VITORIA_SUB_110 1 OBJETO_SOCIAL DEFAULT TF \
create_ttv TTV_DBS1_OBJS LEXICON_LESS_ART_PREP_SUB_110 DADOS_BH_SUB_110 1 OBJETO_SOCIAL DEFAULT TF \
save_tables_in_binary_format

Criando Benchmarking a partir da base do IBGE

Basicamente, o processo de criação do benchmarking é constituído pelos seguintes passos:

1. execução do script convert_base.bat: este script é responsável por converter a estrura da base original do IBGE na estrutura de Dados que o SCAE espera receber. O conteúdo do mesmo é apresentado abaixo, observe a existência de 3 bases do IBGE, as quais diferem entre si no que diz respeito à correção ortográfica. Note, também, que a base do IBGE está classificada segundo à CNAE 2.0, por isso temos que carregar a tabela CNAE_200_SUBCLASSE_CONCLA. Por fim, note que as bases convertidas apresentam o prefixo DADOS_. Após a execução deste script, basta adicionar os nomes das bases geradas no arquivo known_tables.csv, localizado no diretório DB_CORE/CSV_FILES/.

load_csv_cnae_subclasse CNAE_200_SUBCLASSE_CONCLA \
load_csv_dados_ibge IBGE_SEM_CORR \
load_csv_dados_ibge IBGE_COM_CORR_AUTO \
load_csv_dados_ibge IBGE_COM_CORR_MANUAL_MERGE \
convert_format IBGE_SEM_CORR DADOS_IBGE_SEM_CORR \
convert_format IBGE_COM_CORR_AUTO DADOS_IBGE_COM_CORR_AUTO \
convert_format IBGE_COM_CORR_MANUAL_MERGE DADOS_IBGE_COM_CORR_MANUAL_MERGE \
save_tables_in_binary_format

2. execução do script generate_base.bat: este script é responsável por gerar uma base (bechmarking desejado) na qual os códigos possuem uma mesma frequência de ocorrência (o conteúdo do script é apresentado abaixo). Observe que estamos gerando a base a partir de DADOS_IBGE_COM_CORR_MANUAL_MERGE apenas por simplicidade. O comando remove_duplicate remove documentos replicados entre a própria base ou entre a tabela CNAE utilizada (no caso, CNAE_200_SUBCLASSE_CONCLA). Ao final deste comando, tem-se uma base intermediária (DADOS_IBGE_INTERMEDIARIA). Em seguida aplica-se o comando generate_base o qual eliminará os documentos que possuem códigos com frequência inferioir a 120 e escolherá, aleatoriamente, 120 documentos para cada código remanescente. Ao final da execução deste script teremos uma nova base (DADOS_IBGE_COM_CORR_MANUAL_MERGE_PISO_120), cujo nome deve ser adicionado no arquivo known_tables.csv.

load_dictionary DICIONARIO_COMPLETO \
load_csv_cnae_subclasse CNAE_200_SUBCLASSE_CONCLA \
load_csv_dados DADOS_IBGE_COM_CORR_MANUAL_MERGE \
create_word_vectors_table CNAE_200_SUBCLASSE_CONCL-DESCRICAO_SUB \
create_word_vectors_table DADOS_IBGE_COM_CORR_MANUAL_MERGE-OBJETO_SOCIAL \
remove_duplicate DADOS_IBGE_INTERMEDIARIA DADOS_IBGE_COM_CORR_MANUAL_MERGE-OBJETO_SOCIAL 1 CNAE_200_SUBCLASSE_CONCL-DESCRICAO_SUB \
generate_base DADOS_IBGE_COM_CORR_MANUAL_MERGE_PISO_12O 120 1 DADOS_IBGE_INTERMEDIARIA

3. execução do script balance.bat: este script (conteúdo apresentado a seguir) é responsável por distribuir, uniformemente, os códigos ao longo da base . Após a execução deste script teremos, finalmente, um benchmarking (DADOS_IBGE_COM_CORR_MANUAL_MERGE_PISO_120_BALANCED) com 1080 documentos e 9 códigos distintos (120 documentos por código), cujo nome deve ser inserido no arquivo known_tables.csv.

load_csv_cnae_subclasse CNAE_200_SUBCLASSE_CONCLA \
load_csv_dados DADOS_IBGE_COM_CORR_MANUAL_MERGE_PISO_120 \
balance_table DADOS_IBGE_COM_CORR_MANUAL_MERGE_PISO_120  DADOS_IBGE_COM_CORR_MANUAL_MERGE_PISO_120_BALANCED \
save_tables_in_binary_format

Gerando Medidas de Certeza a Serem Exibidas como Saída dos Categorizadores

1) Compilar o código para gerar medidas de certeza, executando o comando abaixo dentro do diretório shared:

cd shared
make clean
make -f Makefile.certainty_measure

2) Realizar experimentos de calibração usando a abordagem 10-fold cross-validation para obter os parâmetros da regra de Bayes usada para calcular as medidas de certeza. Maiores detalhes sobre experimentos de 10-fold cross-validation podem ser encontrados em [[ http://www.lcad.inf.ufes.br/wiki/index.php/Como_realizar_experimentos_de_N-Fold_Cross_Validation ]].

A seguir, descreveremos a metodologia adotada por Caribe Zampirolli de Souza em sua dissertação de mestrado para realizar esses experimentos de calibração.

2.1) Particionar a base em 10 subconjuntos de documentos.

2.2) Considerar os primeiros 9 dos 10 subconjuntos mencionamos no item anterior. Dividir esses 9 subconjuntos novamente em 10 subconjuntos.

2.3) Usar os primeiros nove subconjuntos mencionados no item anterior para a fase de treinamento e o último para a fase de calibração. Nesta etapa, a função persist_result_core_and_classes_pertinent() adicionada no arquivo metrics.c gera o arquivo rankings.csv.

2.4) Repetir esse experimento de calibração 10 vezes com subconjuntos para treinamento e calibração diferentes.

2.5) Renomear os arquivos rankings.csv gerados em cada um dos 10 experimentos. O arquivo rankings*.csv gerado no primeiro experimento deve ser renomeado para rankings1.csv, o arquivo rankings.csv gerado no segundo experimento deve ser renomeado para rankings2.csv, e assim por diante.

2.6) Mover todos os arquivos rankings*.csv para o diretório DB_CORE/certainty_measure/validation_data/

2.7) Definir os parâmetros dos arquivos de configuração ranking_position.con e number_bins.con no diretório DB_CORE/certainty_measure/parameters.

O arquivo ranking_position.con possui o seguinte parâmetro de configuração:

[RANKING_POSITION]=<quantidade de posições do topo do ranking>

que especifica a quantidade de posições do topo do ranking que serão usadas para calcular os parâmetros da regra de Bayes. Esse parâmetro é necessário porque nossa abordagem gera uma medida de certeza baseada na regra de Bayes que difere para cada uma das posições do ranking.

O arquivo number_bins.con possui o seguinte parâmetro de configuração:

[COUNT]=<quantidade de bins>

que especifica em quantas partições os graus de crenças estarão distribuídos para cada posição do ranking.

2.8) Dentro do diretório certainty_measure/, executar a seguinte sequência de comandos:

*$ make clean
*$ make
*$ ./build_bins
*$ ./compute_bayes_rule

Neste ponto, temos todos os parâmetros para calcular a regra de Bayes.

3) Calcular as medidas de certeza baseadas na regra de Bayes manualmente com o auxílio de uma planilha (por exemplo Excel) para cada uma das posições do ranking k = 0,1,2, ..., (RANKING_POSITION-1), onde o valor do parâmetro RANKING_POSITION é definido no arquivo DB_CORE/certainty_measure/parameters/ranking_position.con.

As medidas de certeza são as probabilidades p(x|y_m,k) de um categorizador automático predizer corretamente uma categoria c_i para o documento de teste d_j, considerando que ele (i) predisse c_i com grau de crença f(d_j, c_i) dentro de um intervalo y_m, m=1,2,...,n, onde n é o número de intervalos não sobrepostos e adjacentes dos valores retornados pela função f(d_j, c_i); e (ii) posicionou c_i na posição k = r(d_j, c_i) do ranking de categorias. Pela Regra de Bayes, a probabilidade p(x|y_m,k) é dada por:

p(x|y_m,k) = p(y_m| x,k) * p(x|k) / p(y_m|k)

Para calcular as medidas de certeza para a posição k do ranking, são necessários os dados armazenados dentro dos seguintes arquivos no diretório resultados:

prob_y_e_x_k.con: a linha m deste arquivo contém a probabilidade p(y_m|x,k) do categorizador predizer qualquer categoria (para qualquer documento de teste) com grau de crença dentro de um intervalo y_m , dentre os casos em que o categorizador predisse uma categoria corretamente na posição k do ranking; ou seja, o percentual dos documentos de teste preditos com grau de crença dentro de um intervalo y_m dentre todos os documentos que foram preditos corretamente na posição k do ranking.

prob_x_k.con: a única linha deste arquivo contém a probabilidade p(x|k) do categorizador predizer corretamente qualquer categoria para qualquer documento de teste na posição k do ranking.

prob_y_k.con: a linha m deste arquivo contém a probabilidade p(y_m|k) do categorizador predizer qualquer categoria com grau de crença dentro de um intervalo y_m na posição k do ranking.

As medidas de certeza para a posição k do ranking são calculadas como:

p(x|y_1,k) = p(y_1| x,k) * p(x|k) / p(y_1|k)
p(x|y_2,k) = p(y_2| x,k) * p(x|k) / p(y_2|k)
...
p(x|y_n,k) = p(y_n| x,k) * p(x|k) / p(y_n|k)

Note que p(y_1| x,k) está armazenada na linha 1 do arquivo prob_y_e_x_k.con, p(y_2| x,k) na linha 2 do arquivo prob_y_e_x_k.con, e assim por diante; p(x|k) na única linha do arquivo prob_x_k.con; e p(y_1|k) na linha 1 do arquivo prob_y_k.con, p(y_2|k) na linha 2 do arquivo prob_y_k.con, e assim por diante.

4) As medidas de certeza geradas pela regra de Bayes para cada posição do ranking devem ser inseridas na Interface-Web do projeto SCAE.

Configuração/Validação/Teste das Estratégias de Poda de Ranking dos Categorizadores

1) Adicionar a linha abaixo no specific_core_rpcs_handling_functions.c do categorizador:

#include "threshold.h"

2) Adicionar as três funções abaixo no arquivo fonte specific_core_rpcs_handling_functions.c do categorizador:

 
void 
begin_validation (int n_tables, char **tables_names, int *min_lines_vec, int*max_lines_vec)
{
	/* nothing to do*/
 	return;
}

void
end_validation (void)
{
	/* nothing to do*/
 	return;
}

int
validation_line (float *ttv_vector, int ttv_length, int *cnae_codes_vector, int cnae_codes_length, PREDICTED_CLASS_AND_BELIEF* predicted_classes_and_beliefs, int predicted_classes_and_beliefs_size)
{
	int validation;
	char buf_validation[256];
	int corrects_old = g_nCorrect;

	classify_flag = 0;

	sprintf(buf_validation,"%s%s",CMLS_PATH, "test.cml");

	build_training_testing_images (ttv_vector, ttv_length, cnae_codes_vector, cnae_codes_length);

	g_predicted_classes_and_beliefs = predicted_classes_and_beliefs;

	g_predicted_classes_and_beliefs_size = predicted_classes_and_beliefs_size;

	execute_script (buf_validation);

	validation = g_nCorrect - corrects_old;

	return (validation);
}

3) Construir uma estrutura de diretórios no diretório raiz do categorizador para armazenar os arquivos de configuração:

 mkdir base_calibrate 
 mkdir base_calibrate/calibrate_parameters
 mkdir base_calibrate/threshold
 mkdir base_calibrate/table

4) Criar os seguintes arquivos de configuração

4.1) Arquivo calibrate_pcut.con (dentro do diretório base_calibrate/calibrate_parameters):

variation_pcut=<número inteiro>  begin_pcut=<número inteiro>   limite_pcut=<número inteiro>

4.2) Arquivo calibrate_rcut.con (dentro do diretório base_calibrate/calibrate_parameters) :

variation_rcut=<número inteiro>   begin_rcut=<número inteiro>   limite_rcut=<número inteiro>

4.3) Arquivo calibrate_rtcut.con (dentro do diretório base_calibrate/calibrate_parameters) :

variation_rtcut=<número real>  begin_rtcut=<número real> limite_rtcut=<número real>

4.4) Arquivo calibrate_scut.con (dentro do diretório base_calibrate/calibrate_parameters) :

variation_scut=<número real>   begin_scut=<número real> limite_scut=<número real>

4.5) Arquivo calibrate_probability.con (dentro do diretório base_calibrate/calibrate_parameters) :

variation_prob=<número real> begin_prob=<número real> limite_prob=<número real> size_ranking=<número inteiro>

Obs.: Os parâmetros dos arquivos de configuração calibrate_* são separadas por tabulação ou espaço.

5) Arquivo threshold.con (dentro do diretório base_calibrate):

[THRESHOLD] threshold=<número inteiro>
[METRIC_THRESHOLD] metric=<número inteiro>

O parâmetro threshold identifica a estratégia de poda que será calibrada ou testada e o parâmetro metric a métrica de avaliação usada na calibração das estratégias de poda.

Por exemplo:

[THRESHOLD] threshold=1
[METRIC_THRESHOLD] metric=11


# RCUT..............................0
# PCUT..............................1
# PCUT_ONLINE.......................2
# RTCUT.............................3
# SCUT..............................4
# SCUT_C............................5
# ASSCUT............................6
# RINSCUT...........................7
# RINSCUT...........................8
# MEASURE_CERTAINLYCUT..............9
# MEASURE_CERTAINLYCUT_POSITION ...10
# ALL..............................11

# EXACT_MATCH...................0
# R_PRECISION...................1
# H_LOSS........................2
# MICAVG_PRECISION..............3
# MICAVG_RECALL.................4
# MACAVG_PRECISION_PER_DOCUMENT.5
# MACAVG_RECALL_PER_DOCUMENT....6
# MACAVG_PRECISION_PER_CLASS....7
# MACAVG_RECALL_PER_CLASS.......8
# MICAVG_F1.....................9
# MACAVG_F1_PER_DOCUMENT........10
# MACAVG_F1_PER_CLASS...........11
# MACAVG_F1_PER_CLASS_K.........12

O arquivo de configuração threshold.con é utilizado tanto no processo de calibração das estratégias de poda de ranking, indicando a estratégia de poda e a métrica de avaliação, quanto no processo de teste, indicando apenas a estratégia de poda. Note que as linhas que possuem o caracter # não são parâmetros do sistema. Estas linhas foram adicionadas ao arquivo de configuração threshold.con apenas para exibição das estratégias implementadas no sistema.

5) Indicar a estratégia de poda que será calibrada e a métrica de avaliação. Para isso, editar o arquivo de configuração threshold.con, alterando os seguintes parâmetros :

[THRESHOLD] threshold=<número inteiro>
[METRIC_THRESHOLD] metric=<número inteiro>

6) Definir o intervalo dos valores de calibração, indicando o valor inicial, incremental e final para a estratégia de poda que será calibrada. Para isso, editar o arquivo de configuração dentro do diretório calibrate_parameters correspondente a estratégia de poda que será calibrada.

Por exemplo, para definir o intervalo dos valores de calibração para a estratégia de poda pcut, editar o arquivo base_calibrate/calibrate_parameters/calibrate_pcut.con, alterando os seguintes parâmetros:

variation_pcut=<número inteiro>       
begin_pcut=<número inteiro>        
limite_pcut=<número inteiro>

7) Executar experimentos de treinamento e calibração. Maiores detalhes sobre scripts para realização de experimentos podem ser encontrados em http://www.lcad.inf.ufes.br/wiki/index.php/Resultados_de_Pesquisa#Como_Realizar_os_Experimentos

8) Após a execução dos experimentos de treinamento e calibração, o sistema estará pronto para ser testado. Na fase de teste, o sistema irá exibir os resultados referentes às métricas de avaliação para os rankings: ordinal, modificado e ordinal com poda.

Obs 1: Os passos 1 a 6 mencionados acima já foram executados para os cores WNN_COR_CORE e ML_KNN_CORE.

Obs 2: Antes de testar os categorizadores, verificar se a estrutura de diretórios do passo 3 foi criada e se a estratégia de poda indicada no arquivo threshold.con foi calibrada. O processo de calibração encontra o ponto de corte que maximiza o desempenho do categorizador e guarda este ponto em um arquivo dentro do diretório threshold. O ponto de corte é um número inteiro que indica uma posição no ranking, no caso da estratégia de poda rcut; um número real que indica um grau de crença, no caso das estratégias pcut, rtcut, e scut; ou um número real que indica uma medida de certeza, no caso das estratégias bcut, e pbcut.

Utilizando a USER_INTERFACE

A USER_INTERFACE interpreta diretivas da linha comando e executa tarefas de treinamento e teste entre outras. A seguir são detalhados os possíveis comandos à USER_INTERFACE:

read_ports CONFIG_FILE

Carrega o arquivo de configuração de nome CONFIG_FILE, o qual contém os nomes dos CORES e suas respectivas portas de escuta;

train NOME_DO_CORE NOME_DO_TREINAMENTO DESCRIÇÃO_DO_TREINAMENTO NUMERO_DE_TABELAS TABELA_TTV MIN MAX ... TABELA_TTV MIN  MAX

Realiza um treinamento com os parâmetros fornecidos, onde:

NOME_DO_CORE : um nome sem espaços;
NOME_DO_TREINAMENTO : um nome sem espaços;
DESCRIÇÃO_DO_TREINAMENTO : uma descrição obrigatoriamente entre aspas duplas;
NUMERO_DE_TABLES : um inteiro informando o número de tabelas que serão utilizadas no treino;
TABELA_TTV: um nome, sem espaços, informando o nome da table de TTVs a ser utilizada;
MIN: um inteiro informando limite inferior da TABLE_TTV a ser utilizado;
MAX : um inteiro informando limite superior da TABLE_TTV a ser utilizado;

save NOME_DO_CORE NOME_DO_TREINAMENTO

Salva o treinamento NOME_DO_TREINAMENTO no CORE NOME_DO_CORE. Os parâmetros fornecidos são:

NOME_DO_CORE : um nome sem espaços;
NOME_DO_TREINAMENTO : um nome sem espaços;

reload NOME_DO_CORE NOME_DO_TREINAMENTO

Recarrega o treinamento NOME_DO_TREINAMENTO para o CORE NOME_DO_CORE. Os parâmetros fornecidos são:

NOME_DO_CORE : um nome sem espaços;
NOME_DO_TREINAMENTO : um nome sem espaços;

test NOME_DO_CORE NOME_DO_TESTE DESCRIÇÃO_DO_TESTE NUMERO_DE_TABELAS TABELA_TTV MIN MAX ... TABELA_TTV MIN  MAX

Realiza um teste. Os parâmetros fornecidos, onde:

NOME_DO_CORE : um nome sem espaços;
NOME_DO_TREINAMENTO : um nome sem espaços;
DESCRIÇÃO_DO_TESTE : uma descrição obrigatoriamente entre aspas duplas;
NUMERO_DE_TABLES : um inteiro informando o número de tabelas que serão utilizadas no teste;
TABELA_TTV: um nome, sem espaços, informando o nome da table de TTVs a ser utilizada;
MIN: um inteiro informando limite inferior da TABLE_TTV a ser utilizado;
MAX : um inteiro informando limite superior da TABLE_TTV a ser utilizado;

Realiza uma validação da estratégias de poda de ranking. Os parâmetros fornecidos, onde:

NOME_DO_CORE : um nome sem espaços;
NOME_DO_TREINAMENTO : um nome sem espaços;
DESCRIÇÃO_DO_TESTE : uma descrição obrigatoriamente entre aspas duplas;
NUMERO_DE_TABLES : um inteiro informando o número de tabelas que serão utilizadas no teste;
TABELA_TTV: um nome, sem espaços, informando o nome da table de TTVs a ser utilizada;
MIN: um inteiro informando limite inferior da TABLE_TTV a ser utilizado;
MAX : um inteiro informando limite superior da TABLE_TTV a ser utilizado;

A seguir, temos um exemplo completo de treino retirado do arquivo experimento_1.1.1_train.bat

./user_interface \
read_ports ports.cfg \
train VS TREINAMENTO_EXPERIMENTO_1.1.1 "Treinamento com a TTV_C1S_DESC completa." 1 TTV_C1S_DESC 0 1182 \
save VS "TREINAMENTO_EXPERIMENTO_1.1.1"

Agora um exemplo completo de teste retirado do arquivo experimento_1.1.1_test.bat

./user_interface \
read_ports ports.cfg \
reload VS TREINAMENTO_EXPERIMENTO_1.1.1 \
test VS TESTE_EXPERIMENTO_1.1.1 "Teste com a TTV_C1S_DESC completa." 1 TTV_C1S_DESC 0 1182

Agora um exemplo completo de validação para estratégias de poda: ./user_interface \

read_ports ports.cfg \
reload VS TREINAMENTO_EXPERIMENTO_1.1.1 \
validation VS TESTE_EXPERIMENTO_1.1.1 "Teste com a TTV_C1S_DESC completa." 1 TTV_C1S_DESC 0 1182

Utilizando a Interface Web

A interface Web permite que o usuário do SCAE realize todos os passos necessários para a categorização de atividades econômicas. A interface Web dispoinibiliza as seguintes funcionalidades:

Codificação de colunas das tabelas do BD;
Criação de um lexicon;
Criação de vetores de treinamento e teste;
Treinamento dos cores;
Teste dos cores;
Classifição de atividades econômicas;

Codificação de Colunas das Tabelas do BD Segundo o Dicionário Eletrônico do SCAE

Figura 3: Codificação de colunas.

O objetivo desta interface é realizar a codificação de colunas das tabelas do BD segundo o dicionário eletrônico utilizado no SCAE. As colunas codificadas serão utilizadas para a criação de um Lexicon e de vetores de treinamento e teste (TTV).

Para realizar a codificação das colunas, o usuário precisa digitar os nomes das tabelas e a respestivas colunas da tabela nos campos apresentadados na interface, sendo que o primeiro campo de cada linha corresponde ao nome da tabela e os demais campos aos nomes das colunas. Ao clicar no campo referente ao nome da tabela, é mostrado no item Sugestão os possíveis nomes de tabelas existentes atualmente no banco de dados. O mesmo vale para os campos referentes aos nomes das colunas. Ao digitar o nome da tabela ou da coluna nos campos, o item Sugestão exibe os nomes das tabelas ou colunas que iniciam com os caracteres digitados.

Os campos referentes aos nomes das colunas estão desabilitados e são habilitados a partir do momento que o nome da tabela digitado é validado.

Após digitar os nomes das colunas das tabelas desejáveis para a codificação, o usuário deve clicar no botão Codificar para realizar a codificação das colunas. Para apagar os nomes da tabela e das colunas, o usário pode clicar no botão Limpar ou pressionar a tecla F5. Ao clicar no botão Codificar, uma caixa de texto em vermelho é mostrada no canto superior direito da tela informando o status da codificação.

O resultado da codificação é mostrado no item O resultado será mostrado aqui. Esse item, também, é utilizado para informar os possíveis erros decorrentes de comunicação com os cores, mensagens XML erradas e campos preenchidos incorretamente, etc...

Criação de um Lexicon no SCAE

Figura 4: Criação de um lexicon.

O objetivo desta interface é realizar a criação de um lexicon. O lexicon compreende um conjunto de palavras de interesse as quais são representadas na sua forma canônica. O lexicon é formado a partir de um texto, de um dicionário contendo o mapeamento das palavras nas suas respectivas palavras canônicas e é construído, também, a partir de um conjunto de classes gramáticais a serem removidas. O lexicon será utilizado para a criação dos vetores de treino e teste (TTV).

Para criar um lexicon, o usuário precisa digitar:

o nome do lexicon;
o pfs (máxima frequência da palavra na coleção);
os nomes das tabelas, as respestivas colunas da tabela e os limites inferiores e superiores nos campos apresentadados na interface, sendo que o primeiro campo de cada linha corresponde ao nome da tabela, os quatros campos seguintes corresponde aos nomes das colunas e os dois últimos campos corresponde aos limites;
a descrição do lexicon;

Caso deseje selecionar alguma classe gramatical, basta o usuário selecionar as classes desejáveis. Ao clicar no botão Marcar todas todas as classes gramaticais são selecionadas. O botão Desmarcar desmarcar alguma classe gramatical selecionada.

Ao clicar no campo referente ao nome do lexicon, caso exista algum lexicon criado, é mostrado no item Sugestão os possíveis nomes de lexicons existentes no banco de dados. Ao digitar o nome do lexicon no campo, o item Sugestão exibe os nomes dos lexicons que iniciam com os caracteres digitados. Ao verficar que o nome do lexicon digitado já existe, a interface preenche os demais campos com as informações que o lexicon foi criado.

Ao clicar no campo referente ao nome da tabela, é mostrado no item Sugestão os possíveis nomes de tabelas existentes atualmente no banco de dados. O mesmo vale para os campos referentes aos nomes das colunas. Ao digitar o nome da tabela ou da coluna nos campos, o item Sugestão exibe os nomes das tabelas ou colunas que iniciam com os caracteres digitados.

Os campos referentes aos nomes das colunas estão desabilitados e são habilitados a partir do momento que o nome da tabela digitado é validado.

Após preencher todas as informações necessárias para a criação de um lexicon, o usuário deve clicar no botão Criar lexicon para criar um lexicon. Para apagar as informações digitais na interface, o usário pode clicar no botão Limpar ou pressionar a tecla F5. Ao clicar no botão Criar lexicon, uma caixa de texto em vermelho é mostrada no canto superior direito da tela informando o status da criação do lexicon.

O resultado da codificação é mostrado no item O resultado será mostrado aqui. Esse item, também, é utilizado para informar os possíveis erros decorrentes de comunicação com os cores, mensagens XML erradas e campos preenchidos incorretamente, etc...

Criação de Vetores de Treinamento e Teste

Figura 5: Criação dos vetores de treinamento e teste

O objetivo desta interface é realizar a criação dos vetores de treinamento e teste. Os vetores de treinamento e teste são utilizados para treinar e testar os cores classificadores.

Para criar um vetor de treinamento e teste, o usuário precisa digitar:

o nome do lexicon;
o nome da tabela de treino e teste;
os nomes das tabelas, as respectivas colunas da tabela e a construção do treino e teste nos campos apresentadados na interface, sendo que o primeiro campo de cada linha corresponde ao nome do treino e teste, o segundo ao nome da tabela, os quatros campos seguintes corresponde aos nomes das colunas e o último corresponde a construção do treino e teste;

Ao clicar no campo referente ao nome do lexicon, caso exista algum lexicon criado, é mostrado no item Sugestão os possíveis nomes de lexicons existentes no banco de dados. Ao digitar o nome do lexicon no campo, o item Sugestão exibe os nomes dos lexicons que iniciam com os caracteres digitados.

Ao clicar no campo referente ao nome da tabela, é mostrado no item Sugestão os possíveis nomes de tabelas existentes atualmente no banco de dados. O mesmo vale para os campos referentes aos nomes das colunas. Ao digitar o nome da tabela ou da coluna nos campos, o item Sugestão exibe os nomes das tabelas ou colunas que iniciam com os caracteres digitados.

Os campos referentes aos nomes das colunas estão desabilitados e são habilitados a partir do momento que o nome da tabela digitado é validado.

Após preencher todas as informações necessárias para a criação de um vetor de treino e teste, o usuário deve clicar no botão Criar vetor para criar um o vetor de treino e teste. Para apagar as informações digitais na interface, o usário pode clicar no botão Limpar ou pressionar a tecla F5. Ao clicar no botão Criar vetor, uma caixa de texto em vermelho é mostrada no canto superior direito da tela informando o status da criação do lexicon.

O resultado da codificação é mostrado no item O resultado será mostrado aqui. Esse item, também, é utilizado para informar os possíveis erros decorrentes de comunicação com os cores, mensagens XML erradas e campos preenchidos incorretamente, etc...

Treinamento dos Cores Classificadores do SCAE

Figura 6: Treinamento dos cores classificadores do SCAE.

O objetivo desta interface é realizar o treinamento dos cores classificadores do SCAE.

Para realizar o treinamento, o usuário precisa:

selecionar o core classificador;
nome do treinanento;
os nomes das tabelas de treino e teste e os limites inferiores e superiores nos campos apresentadados na interface, sendo que o primeiro campo de cada linha corresponde ao nome das tabelas de treino e tese, os dois campos seguintes correspondem aos limites;
a descrição do treinamento;

Ao selecionar o core classificador, as informações dos campos da interfaces são apagados.

Ao clicar no campo referente ao nome do treinamento, caso exista algum treimamento criado, é mostrado no item Sugestão os possíveis nomes de treinamento existentes no banco de dados. Ao digitar o nome do treinamento no campo, o item Sugestão exibe os nomes dos treinamentos que iniciam com os caracteres digitados. Ao verficar que o nome do treinamento digitado já existe, a interface preenche os demais campos com as informações que o treinamento foi criado.

Ao clicar no campo referente ao nome da tabela de treino e teste, é mostrado no item Sugestão os possíveis nomes de tabelas existentes atualmente no banco de dados. Ao digitar o nome da tabela ou da coluna nos campos, o item Sugestão exibe os nomes das tabelas ou colunas que iniciam com os caracteres digitados.

Os campos referentes aos nomes das colunas estão desabilitados e são habilitados a partir do momento que o nome da tabela digitado é validado.

Os campos correspondentes ao nome do lexicon estão desabilitados e apenas mostram qual lexicon foi utilizado para a criação da tabela de treino e teste. Não é permitido a edição desse campo.

Após preencher todas as informações necessárias para um treino, o usuário deve clicar no botão Treinar para treinar os cores classificadores. Para apagar as informações digitais na interface, o usário pode clicar no botão Limpar ou pressionar a tecla F5. Ao clicar no botão Treinar, uma caixa de texto em vermelho é mostrada no canto superior direito da tela informando o status da criação do lexicon.

O resultado da codificação é mostrado no item O resultado será mostrado aqui. Esse item, também, é utilizado para informar os possíveis erros decorrentes de comunicação com os cores, mensagens XML erradas e campos preenchidos incorretamente, etc...

Teste dos Cores Classificadores do SCAE

Figura 7: Teste dos cores classificadores do SCAE.

O objetivo desta interface é realizar o teste dos cores classificadores do SCAE.

Para realizar o teste, o usuário precisa:

selecionar o core classificador;
digitar o nome do teste;
digitar o nome do treinanento;
digitar os nomes das tabelas de treino e teste e os limites inferiores e superiores nos campos apresentadados na interface, sendo que o primeiro campo de cada linha corresponde ao nome das tabelas de treino e tese, os dois campos seguintes correspondem aos limites;
a descrição do teste;

Ao selecionar o core classificador, as informações dos campos da interface são apagados.

Ao clicar no campo referente ao nome do teste, caso exista algum teste criado, é mostrado no item Sugestão os possíveis nomes de teste existentes no banco de dados. Ao digitar o nome do teste no campo, o item Sugestão exibe os nomes dos teste que iniciam com os caracteres digitados. Ao verficar que o nome do teste digitado já existe, a interface preenche os demais campos com as informações que o treinamento foi criado.

Ao clicar no campo referente ao nome do treinamento, caso exista algum treinamento criado, é mostrado no item Sugestão os possíveis nomes de treinamento existentes no banco de dados. Ao digitar o nome do treinamento no campo, o item Sugestão exibe os nomes dos treinamentos que iniciam com os caracteres digitados.

Ao clicar no campo referente ao nome da tabela de treino e teste, é mostrado no item Sugestão os possíveis nomes de tabelas existentes atualmente no banco de dados. Ao digitar o nome da tabela ou da coluna nos campos, o item Sugestão exibe os nomes das tabelas ou colunas que iniciam com os caracteres digitados.

Os campos referentes aos nomes das colunas estão desabilitados e são habilitados a partir do momento que o nome da tabela digitado é validado.

Os campos correspondentes ao nome do lexicon estão desabilitados e apenas mostram qual lexicon foi utilizado para a criação da tabela de treino e teste. Não é permitido a edição desse campo.

Após preencher todas as informações necessárias para um teste, o usuário deve clicar no botão Testar para testar os cores classificadores. Para apagar as informações digitais na interface, o usário pode clicar no botão Limpar ou pressionar a tecla F5. Ao clicar no botão Testar, uma caixa de texto em vermelho é mostrada no canto superior direito da tela informando o status da criação do lexicon.

O resultado da codificação é mostrado no item O resultado será mostrado aqui. Esse item, também, é utilizado para informar os possíveis erros decorrentes de comunicação com os cores, mensagens XML erradas e campos preenchidos incorretamente, etc...

Classificação de Atividades Econômicas com o SCAE

Figura 8: Classificação de Atividades Econômicas.

O objetivo desta interface é realizar a classificação de atividades econômicas de acordo com a descrição da atividade.

Para realizar o teste, o usuário precisa:

digitar a descrição da atividade no campo Descrição das Atividades;
selecionar qual o core que realizará a classificação;

Após preencher todas as informações necessárias, o usuário deve clicar no botão Classificar para classificar a atividade descrita anteriormente. Para apagar as informações digitadas na interface, o usário pode clicar no botão Limpar ou pressionar a tecla F5. Ao clicar no botão Classificar, uma caixa de texto em vermelho é mostrada no canto superior direito da tela informando o status da classificação da atividade.

O resultado da classificação é mostrado no item O resultado será mostrado aqui. Esse item, também, é utilizado para informar os possíveis erros decorrentes de comunicação com os cores, mensagens XML erradas e campos preenchidos incorretamente, etc...

O resultado da classificação mostra os possívies códigos da tabela CNAE para a atividade descrita.

Organização do SCAE

Esta seção visa explicar como está organizado o SCAE.

As Partes do SCAE

O Sistema foi projetado para funcionar em módulos que se comunicam entre si através de xmlrpc. Os módulos são divididos basicamente em 3 categorias:

Interface (WEB e linha de comando)
Categorizadores (Redes Neurais, Espaço Vetorial, ..)
Banco de Dados (DB_CORE)

Comunicação entre os COREs (xmlrpc)

O SCAE usa o protocolo XML-RPC (Extensible Markup Language Remote Process Call) para comunicação entre módulos. Trata-se de um protocolo muito simples que usa http como transporte e XML como codificação, e que permite a comunicação entre aplicações escritas em linguagens diferentes, rodando em computadores diferentes e mesmo em sistemas operacionais diferentes.

Toda a comunicação entre os módulos do SCAE é feita por meio de XML-RPC, o que permite que módulos sejam executados em computadores diferentes. Em sistemas que empregam XML-RPC, clientes XML-RPC enviam requisições de execução de procedimentos remotos (RPCs) para servidores XML-RPC, os quais, por sua vez, devolvem aos clientes o resultado da execução destas RPCs.

No SCAE, alguns módulos se comportam somente como clientes, outros somente como servidores. Existem ainda módulos que se comportam ora como clientes ora como servidores.

Comunicando com o DB_CORE

O DB_CORE é o único CORE que faz o papel de servidor puro, ou seja, ele não realiza nenhuma requisição. Neste CORE encontramos o módulo db_core_rpcs.c, o qual contém as seguintes rpcs:

get_num_table_lines_rpc
input: nome da tabela.
output: número de linhas da tabela.

get_table_column_rpc
input: nome da tabela, nome da coluna e número da linha.
output: campo da tabela.

get_table_column_and_codes_rpc
input: nome da tabela, nome da coluna e número da linha.
output: vetor de códigos de palavras.

get_lexicon_rpc
input: nome do lexicon.
output: vetor de frequências de palavras, vetor de palavras e um vetor de códigos de palavras canônicas.

create_lexicon_rpc
input: nome do lexicon, pfs, classes gramáticias, vetor de strings onde cada string é formada como 'TABELA-COLUNA:MIN:MAX e descrição do lexicon.
output: 0 se sucesso e 3 caso contrário.

get_train_test_vector_words_rpc
input: nome da tabela, nome da coluna, número da linha, nome do lexico e o tipo de construção (ADD, OR, COMMON).
output: vetor de índices, vetor de frequências, vetor de palavras e um vetor de códigos de palavras canônicas.

get_cnae_codes_rpc
input: nome da tabela, a linha e o tipo de construção.
output: vetor de códigos CNAE.

get_train_and_test_vector_rpc
input: nome da tabela, nome da coluna, a linha, nome do lexicon e o tipo de construção.
output: vetor de treino e teste com tamanho igual ao do lexicon.

encode_column_of_some_lines_according_to_dictionary_rpc
input: nome da tabela e nome da coluna.
output: 0 se sucesso e 1 caso contrário.

build_user_vector_rpc
input: texto a ser classificado e o nome do lexicon.
output: vetor de inteiros a ser classificado.

get_table_list_by_type_rpc
- input: String com o tipo de tabelas desejadas.
  - string: TIPO (CNAE, DADOS, LEXICON, TTV).
- output: Vetor com a lista de tabelas do tipo requerido.
  - array strings: TABLE_NAME

get_encodable_column_list_rpc
- input: String com o nome da tabela.
  - string: TABLE_NAME
- output: Vetor com as colunas codificáveis da tabela.
  - array strings: TABLE_COLUMN_NAME

get_lexicon_info_rpc
- input: String com o nome do Lexicon.
  - string: LEXICON_NAME
- output: Vetor de strings onde cada string é formada como 'TABELA-COLUNA:MIN:MAX', string contendo as classes gramaticais removidas separadas por espaço, um inteiro com a freqüência acima da qual a palavra não será incluída e um base64 contendo a descrição do lexicon.
  - array strings: "TABLE_NAME-TABLE_COLUMN_NAME:MIN:MAX"
  - string: "GRAM_CLASS1 GRAM_CLASS2 ... GRAM_CLASSN"
  - integer: PFS
  - base64: LEXICON_DESCRIPTION

create_ttv_table_rpc
- input: String com o nome da Tabela TTV, string contendo o nome do lexicon, string contendo o nome da tabela, array de strings contendo as COLUNAS e, string contendo o método de criação dos vetores.
  - string: TTV_TABLE_NAME
  - string: LEXICON_NAME
  - string: TABLE_NAME
  - array strings: TABLE_COLUMN_NAME
  - string: BUILD_TYPE
- output: Inteiro com o código do erro/sucesso e string com a mensagem de erro/sucesso.
  - integer: ERROR_CODE
  - string: MESSAGE

get_ttv_line_rpc
- input: String com o nome da Tabela TTV e um inteiro com o número da linha.
  - string: TTV_TABLE_NAME
  - integer: LINE
- output: Vetor de floats com as freqencias e um vetor de inteiros de índice de código cnae.
  - array floats: FREQUENCES
  - array integers: CNAE_CODE

get_ttv_info_rpc
- input: String com o nome da Tabela TTV.
  - string: TTV_TABLE_NAME
- output: String contendo o nome do lexicon utilizado, string contendo o nome da tabela, array de strings contendo as COLUNAS e, string contendo o método de criação dos vetores.
  - string: LEXICON_NAME
  - string: TABLE_NAME
  - array strings: TABLE_COLUMN_NAME
  - string: BUILD_TYPE

get_training_list_rpc
- input: nenhum.
  - -
- output: Vetor de strings dos nomes dos treinamentos e vetor de strings dos nomes dos cores correspondentes.
  - array strings: CORE_NAME
  - array strings: TRAINING_NAME

get_training_info_rpc
- input: String com o nome do treinamento e string com o nome do CORE.
  - string: TRAINING_NAME
  - string: CORE_NAME
- output: String com o nome do lexicon utilizado no treinamento, vetor de strings contendo nome da tabela ttv, limites inferior e superior separados por ":" e, um base64 com a descrição do treinamento.
  - string: LEXICON_NAME
  - array strings: "TTV_TABLE_NAME:MIN:MAX"
  - base64: TRAINING_DESCRIPTION

add_training_info_rpc
- input: String com o nome do treinamento, string com o nome do core, string com o nome do lexicon, vetor de strings contendo nome da tabela ttv, limites inferior e superior separados por ":" e, base64 com a descrição do treinamento.
  - string: TRAINING_NAME
  - string: CORE_NAME
  - string: LEXICON_NAME
  - array strings: "TTV_TABLE_NAME:MIN:MAX"
  - base64: TRAINING_DESCRIPTION
- output: nenhum.
  - -

get_test_list_rpc
- input: nenhum.
  - -
- output: Vetor de strings dos nomes dos testes e vetor de strings dos nomes dos cores correspondentes.
  - array strings: TEST_NAME
  - array strings: CORE_NAME

get_test_info_rpc
- input: String com o nome do teste e string com o nome do CORE.
  - string: TEST_NAME
  - string: CORE_NAME
- output: String com o nome do lexicon utilizado no teste, vetor de strings contendo nome da tabela ttv, limites inferior e superior separados por ":" e, um base64 com a descrição do treinamento.
  - array strings: "TABLE_NAME:MIN:MAX"
  - integer: NUMBER_OF_TESTS
  - integer: CORRECT_GUESSES
  - string: TRAINING_NAME
  - base64: TEST_DESCRIPTION

add_test_info_rpc
- input: String com o nome do teste e string com o nome do CORE, string com o nome do lexicon utilizado no teste, vetor de strings contendo nome da tabela ttv, limites inferior e superior separados por ":" e, um base64 com a descrição do treinamento.
  - string: TEST_NAME
  - string: CORE_NAME
  - string: TRAINING_NAME
  - array strings: "TABLE_NAME:MIN:MAX"
  - integer: NUMBER_OF_TESTS
  - integer: CORRECT_GUESSES
  - base64: TEST_DESCRIPTION
- output: nenhum.
  - -

Comunicando com os COREs Categorizadores

Atualmente, já estão embutidos no SCAE, os seguintes CORES categorizadores:

VS_CORE;
WNN_CORE;
WNN_COR_CORE;
WISARD_CORE.

Cada CORE acima desempenha tanto o papel de cliente, quanto o de servidor. Para que seja possível utilizar um CORE classificador, as seguintes rpc foram implementadas no módulo core_rpcs.c, existente no diretório SHARED (shared/src/):

train_rpc
- input: Vetor de xmls contendo nome da tabela ttv, limites inferior e superior separados por ":".
  - array xmls: "TABLE_NAME:MIN:MAX"
- output: Inteiro especificando se a chamada transcorreu com sucesso (SUCCESS = 0) ou se houve alguma falha (FAIL = 0).
  - integer: 0 ou 1

save_rpc
- input: String com o nome do treinamento, vetor de xmls contendo nome da tabela ttv, limites inferior e superior separados por ":" e, base64 com a descrição do treinamento.
  - string: TRAINING_NAME
  - array xmls: "TTV_TABLE_NAME:MIN:MAX"
  - base64: TRAINING_DESCRIPTION
- output: Inteiro especificando se a chamada transcorreu com sucesso (SUCCESS = 0) ou se houve alguma falha (FAIL = 0).
  - integer: 0 ou 1

reload_rpc
- input: String com o nome do treinamento.
  - string: TRAINING_NAME
- output: Inteiro especificando se a chamada transcorreu com sucesso (SUCCESS = 0) ou se houve alguma falha (FAIL = 0).
  - integer: 0 ou 1

test_rpc
- input: String com o nome do teste, vetor de xmls contendo nome da tabela ttv, limites inferior e superior separados por ":" e, base64 com a descrição do teste.
  - string: TEST_NAME
  - array xmls: "TTV_TABLE_NAME:MIN:MAX"
  - base64: TEST_DESCRIPTION
- output: Dois inteiros, um especificando a quantidade de testes realizados e o outro o número de acertos obtidos.
  - integer: NUMBER_OF_TESTS
  - integer: CORRECT_GUESSES

classify_rpc
- input: Texto a ser classificado.
  - string: TEXT
- output: Dois vetores, um de códigos sequencias e o outro de probabilidades.
  - array integer: SEQ_CODE_VECTOR
  - array float: PROBABILITIES_VECTOR

Módulos do SCAE (COREs)

O SCAE possuirá vários módulos de classficação. Os já implementados são descritos a seguir.

DB_CORE

Trata-se de um Banco de Dados implementado na linguagem C que, entre outras coisas, é responsável por:

carregar tabelas em formato .csv;
construir e armazenar novas tabelas;
atender às requisições dos demais CORES.

Tabelas Existentes

Abaixo, esboçamos as tabelas em .csv que são utilizadas como ponto de partida para a criaçào das demais tabelas.

Tabela: DICIONARIO
Coluna	Comentários
PALAVRA	a própria palavra
CLASSE	classe gramatical
PALAVRA_CANONICA	palavra canônica
GENERO	gênero
GRAU	grau
LISTA_ELEMENTOS	lista de elementos
LISTA_PREPOSICOES	lista de preposições
LISTA_REGENCIAS	lista de regências
MODO_TEMPO_FORMANOMINAL	modo e/ou tempo e/ou forma nominal
NUMERO	número
LISTA_PAPEIS	lista de papéis
PESSOA	pessoa
CODIGO_PALAVRA_CANONICA	código da palavra canônica
CODIGO_PALAVRA	código da palavra

Tabela: CNAE_110_SUBCLASSE
Coluna	Comentários
CODIGO_SUB_SEC	Código Sequencial da subclasse
CODIGO_SEC
CODIGO_DIV
CODIGO_GRP
CODIGO_CLA
CODIGO_SUB
DV_SUB
DESCRICAO_SUB
CCOMPRE_SUB
TCOMPRE_SUB
NCOMPRE_SUB
NOTAS_SUB
CODIGO_CNAE_SUBCLASSE
VETOR_CODIGOS_CNAE

Tabela: CNAE_200_SUBCLASSE
Coluna	Comentários
CODIGO_SUB_SEC	Código Sequencial da subclasse
CODIGO_SEC
CODIGO_DIV
CODIGO_GRP
CODIGO_CLA
CODIGO_SUB
DV_SUB
DESCRICAO_SUB
CCOMPRE_SUB
TCOMPRE_SUB
NCOMPRE_SUB
NOTAS_SUB
CODIGO_CNAE_SUBCLASSE
VETOR_CODIGOS_CNAE

Tabela: DADOS_VITORIA_110
Coluna	Comentários
NO_IDENTIFICADOR	Um número de identificação que veio junto aos dados que recebemos
OBJETO_SOCIAL	Texto descritivo do objeto em questão
CNAE_FISCAL	Um código CNAE para o qual esta atividade foi classificada; Formato direto de 7 dígitos, sem '-' ou '/'
VETOR_CODIGOS_CNAE	Neste campo, sempre o valor zero, ele é preenchido pelo DB_CORE com os sequenciais que representam as classificações

Tabela: DADOS_VITORIA_200
Coluna	Comentários
NO_IDENTIFICADOR	Um número de identificação que veio junto aos dados que recebemos
OBJETO_SOCIAL	Texto descritivo do objeto em questão
CNAE_FISCAL	Um código CNAE para o qual esta atividade foi classificada; Formato direto de 7 dígitos, sem '-' ou '/'
VETOR_CODIGOS_CNAE	Neste campo, sempre o valor zero, ele é preenchido pelo DB_CORE com os sequenciais que representam as classificações

Manipulando o Dicionário

Para criar um novo dicionário ou apenas adicionar novas palavras a um dicionário já existente foi criado um script que torna essa tarefa bem simples. O script adiciona_palavras_dicionario.sh se encontra dentro do diretório DB_CORE/Diadorim e para utilizá-lo basta seguir os seguintes passos:

Escreva as palavras a serem adiconadas ao dicionário em um arquivo texto, uma palavra por linha. Atenção! Escreva as palavras sempre em letras minúsculas e certifique-se de que a codificação do arquivo é unicode (utf8).

Digite o comando ./adiciona_palavras_dicionario.sh entrada.txt saida.csv para rodar o script e adicionar as palavras. No comando anterior, substitua entrada.txt pelo nome do arquivo texto com as palavras a serem adicionadas e saida.csv pelo nome do dicionário onde você deseja inserir as palavras. Para criar um novo dicionário, basta substituir saida.csv pelo nome de um dicionário que ainda não exista e responder s à pergunta sobre começar um novo dicionário.

Para fazer a adição das novas palavras ao dicionário, este script faz uso de um aplicativo fornecido pelo NILC - USP, chamado Diadorim. Este aplicativo é responsável por encontrar palavras relacionadas a uma dada palavra (todas as conjugações de um verbo por exemplo) e as informações de classe, gênero, número, tempo, grau, pessoa, etc, das palavras a serem adiconadas.

O script executa os seguintes passos:

Passa possíveis letras maiúsculas para minúsculas nas palavras de entrada;
Usa o Diadorim para preencher um arquivo com as informações de classe, gênero, tempo, etc;
Cria um dicionário no formato .csv apartir das informações do passo anterior;
Insere as novas palavras no dicionário fornecido;
Reordena o dicinário;
Retira possíveis palavras duplicadas (repetidas) do dicionário;
Mostra as informações de saída.

Vários arquivos de back up são gerados e apagados durante a execução dos passos acima. Se você quiser mantê-los para posterior verificação, use a opção -b como úlltimo parâmetro na chamada do script: ./adiciona_palavras_dicionario.sh entrada.txt saida.csv -b

O script apresenta como saída quatro informações:

Total de linhas lidas é o número de palavras que já existia no dicionário fornecido mais o número de palavras geradas pelo Diadorim;
Total de linhas repetidas é o número de palavras encontrads repetidas e que foram excluídas;
Total de linhas diferentes é o número de palavras que seu novo dicionário realmente possui;
Total de linhas complementares é o número de linhas complementares encontradas. Duas linhas são complementares quando uma possui pelo menos um campo que a outra linha não tem e a primeira não possui pelo menos um campo que a segunda linha tem.

adiciona_palavras_dicionario.sh gera ainda um arquivo com o nome de nao_consta.txt que contém todas as palavras que o Diadorim não conhece, e por tanto, não foram adicionadas ao dicionário. Este arquivo se encontra no mesmo diretório do script adiciona_palavras_dicionario.sh.

WNN_CORE

Implementação do categorizador que utiliza Redes Neurais Sem Peso VG-RAM.

WNN_COR_CORE

Implementação do categorizador que utiliza Redes Neurais Sem Peso VG-RAM com correlação de dados de saída.

VS_CORE

Implementação do categorizador que utiliza Espaço Vetorial.

VSC_CORE

É o Novo VS_CORE. Esse core está implemantado na linguagem C-CUDA da Nvidia.

Antes de usar o core, verifique se sua placa de video é CUDA enable. usando o link abaixo:

 http://www.nvidia.com/object/cuda_learn_products.html

Se a máquina não tiver os driver para usar CUDA, então use este link para aprender como instalar.

 http://www.lcad.inf.ufes.br/wiki/index.php/Instala%C3%A7%C3%A3o_do_Driver_da_Placa_de_Video_GeForce_GTX_280

Para instalar o compilador entre nesse link:

  http://www.lcad.inf.ufes.br/wiki/index.php/Instala%C3%A7%C3%A3o_do_CUDA_Toolkit_%28compilador_e_bibliotecas%29_para_Fedora_core_8

Para mais informação, mande um e-mail para a equipe LCAD. Se a duvida for sobre C-CUDA procure no SITE da Nvidia

 http://www.nvidia.com/object/cuda_home.html

Para compilar, o .bashrc deve conter os seguites comandos:

 #CUDA
 PATH=$PATH:/usr/local/cuda/bin
 LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda/lib
 export PATH
 export LD_LIBRARY_PATH

Para compilar:

 make gpu

Para executar o CORE:

 ./vsc_core

Se for acessar uma máquina remotamente que tenha CUDA, todos os driver já estão instalados e o CORE não compilar, execute o sequinte comando como root:

 chmod 666 /dev/nvidia* && chown root /dev/nvidia*

WISARD_CORE

Implementação do categorizador que utiliza Redes Neurais Sem Peso WISARD. Treinamento da Wisard :

  O discriminador da RAM:

Um discriminador é uma rede de RAM's que é capaz de generalizar. Supondo que tenhamos K RAM's, cada uma com N entradas binárias do decodificador e que cada RAM aloque 2N palavras de 1 bit. Sendo assim, o padrão binário a ser treinado é formado por KN bits, ou seja, uma cobertura completa do “padrão de entrada” (treinamento e teste) é possível. O primeiro passo do treinamento da WISARD é preencher todas as células de memória das RAM's com o valor 0. O treinamento consiste em aplicar o padrão de entrada, composto por 0's e 1's, nos terminais de entrada, como na Figura 1.

Figura 1 – Um neurônio com uma RAM de N entradas e uma saída

Para gravar esse padrão, o valor 1 é alocado no local de memória de cada RAM que é endereçada por esse padrão de entrada. Então, cada RAM é responsável por gravar uma parte do padrão de entrada. As RAM's funcionam em dois modos, a saber: o de escrita, que é utilizado na fase de treinamento, e o de leitura, que é usado na fase de teste. Na fase de leitura, quando ocorre um padrão totalmente novo na entrada, o somatório produz um número que equivale ao número de RAM's que obtiveram 1 como saída. Esse somatório é a resposta do discriminador e é chamado de r, na Figura 2. O r representa a similaridade de um padrão desconhecido com os padrões de treinamento.

Exemplo de teste da WISARD:

Um padrão de entrada qualquer é fornecido. Então, procedemos da mesma maneira do treinamento, conectando aleatoriamente cada neurônio de entrada à uma RAM e setando os bits como já explicado. Depois, fazemos o somatório como antes. A parte diferente é a seguinte: após o somatório, compara-se o número de um's do somatório obtido com o número de um's do somatório de todas as letras treinadas. A letra cujo somatório mais se aproximar do somatório do padrão de entrada será a escolhida como resposta do reconhecimento de padrões. No nosso exemplo, a resposta será T ou H, o que significa que o padrão de entrada parece mais com um T ou um H.

MULTI-DISCRIMINADOR

Um sistema de multi-discriminadores tem cada um de seus discriminadores treinados para uma diferente classe de objeto. Sendo assim, cada discriminador é independente dos demais. No caso da WISARD, haverá 26 classes, uma para cada letra do alfabeto. A WISARD faz reconhecimento de imagens, embora esse reconhecimento possa ser aplicado à qualquer dado binário. Assumamos que cada um dos 26 discriminadores citados cubra uma imagem binária formada por K RAM's de N endereços de entrada cada, como no padrão de treinamento. Cada uma das entradas das K RAM's são então randomicamente conectadas à alguma diferente entrada da imagem, como na Figura 2.

                  Figura 2 - Um discriminador WISARD de KN entradas e uma saída

Após a fase de treinamento, uma resposta Rj (porcentagem das K RAM's que computaram 1 como resposta) ocorrerá no j-ésimo discriminador, considerando um padrão totalmente novo. O sistema então escolherá a classe que corresponder ao discriminador que gerar o maior Rj. Quanto maior for o valor de Rj, mais confiável é a resposta do sistema. Outra medida de confiabilidade é o C. C expressa a diferença entre o maior Rj e o segundo maior Rj dividido pelo maior Rj. Ou seja: C = D/Rj, como na Figura 4.

Figura 3 - Um perceptron WISARD, onde as entradas estão conectadas aleatoriamente a K RAM`s

Exemplo de treinamento da WISARD:

Ao reconhecer as letras T e H, por exemplo, podemos representar a letra T com nove neurônios, nas matrizes que seguem:

Conectamos randômicamente cada um dos neurônios a uma das RAM's do discriminador. Então, escolhemos uma codificação binária para cada RAM e setamos os 1's na RAM de acordo com a posição na RAM correspondente à codificação binária.

Para ficar mais claro, eis um exemplo dos 1's a serem setados nas RAM's:

Exemplo de codificação binária:

(o 1 aparece nessa posição porque ela corresponde ao 0010 da codificação binária)

Após preenchermos com o valor 1 as respectivas posições, devemos somar esses 1's, e a soma deles é representada pelo somatório da Figura . Esse somatório corresponderá à quantos um's uma letra deverá ter no conjunto de teste para ser considerada um T ou para ser considerada um H.

Com o H, o exemplo é semelhante.

BAYESIAN_CORE

Implementação do categorizador que utiliza Redes Bayesianas.

CAN_CORE

O Causal Association Network (CAN - nome preliminar oriundo de técnica similar usada em sistemas especialistas na década de 70) CORE armazena conhecimento na forma de um grafo <math>G(N,V)</math> onde os nós, <math>N</math>, são palávras ou nós terminais, e os arcos orientados, <math>V</math>, representam seqüências de palavras observadas no conjunto de treinamento. A Figura 6 mostra um exemplo de um grafo <math>G</math> gerado a partir do conjunto de treinamento:

**Conjunto de Treinamento**
Objeto Social	Código CNAE
Cultivo de Arroz	1
Cultivo de Feijão	2
Cultivo de Milho	3

Figura 6: CAN

Cada nó de G pode armazenar um conjunto <math>Cn</math> de códigos CNAE e cada arco um conjunto <math>Cv</math> de códigos CNAE. O treinamento de uma CAN consiste em construir o grafo G a partir de uma base de dados de exemplos de codificação (objetos sociais e seus códigos CNAE associados ou a denominação de uma subclasse CNAE e seu respectivo código, por exemplo).

O teste é feito percorrendo o grafo de acordo com as palavras no objeto social de teste. Durante este percurso, pesos são atribuídos a cada código CNAE em cada nó ou arco encontrado segundo duas funções:

<math>Fn: Cn \Rightarrow (Cn, \mathbb{R})</math> (para nó) e 
<math>Fv: Cv \Rightarrow (Cv, \mathbb{R})</math> (para arco)

Os códigos CNAE observados no teste são ordenados segundo a função:

<math>F: (Cn, \mathbb{R}) \cup (Cv, \mathbb{R}) \Rightarrow (Cn \cup Cv, \mathbb{R}) </math>

O ranking produzido por <math>F</math> é a saída do categorizador CAN para o objeto social sendo testado.

Diversas funções <math>Fn</math>, <math>Fv</math> e <math>F</math> podem ser usadas e experimentos devem ser realizados para identificar candidatas que viabilizem bom desempenho de categorização. Outros aspectos, como o pré-processamento dos dados de entrada (remoção de acentos, conversão para palara canônica, stemming, etc), por exemplo, devem também ser examinados.

Em um exemplo de implementação de um categorizador CAN, poderíamos ter funções <math>Fn</math> e <math>Fv</math> que simplesmente contam o número de ocorrências de cada código CNAE observado na travessia do grafo, e uma função <math>F</math> que une as listas de pares (código CNAE, ocorrências) produzidas por <math>Fn</math> e <math>Fv</math> e ordena a lista resultante segundo o número de ocorrências dos códigos CNAE. Para um objeto social de entrada igual a "plantio de arroz", a função <math>Fn</math> deste categorizador produziria os pares (1, 1), (2, 1) e (3, 1) para a palavra "de" (a palavra "plantio" seria ignorada neste caso por não fazer parte de <math>G</math>), e o par (1, 1) para a palavra "arroz". A função <math>Fv</math> produziria o par (1, 1) para o arco orientado (de, arroz) e (1, 1) para o arco orientado (arroz, terminal). Finalmente, a função <math>F</math> produziria os pares ordenados (código CNAE, ocorrências) (1, 3), (2, 1) e (3, 1).

MLKNN_CORE

Implementação do categorizador para problemas multilabels utilizando o kNN.

PNN_CORE

Implementação do categorizador que utiliza Redes Neurais Probabilísticas.

Adicionando um CORE ao SCAE

A tarefa de adicionar um novo CORE ao SCAE foi bastante simplificada e é resumida nos passos abaixo:

1) Edite o seu arquivo .bashrc

Insira as seguintes linhas ao seu .bashrc a fim de que a compilação seja possível compilar o novo CORE:

# SHARED 
export SHAREDHOME=$HOME/code/CORES/shared;

Execute o comando abaixo:

source .bashrc

2) Configure a porta de escuta do seu CORE

Abra o arquivo ports.cfg existente no diretório config (code/CORES/config/);
Adicione a seguinte linha ao arquivo:

NEW_CORE_NAME = 127.0.0.1 PORT_NUMBER

Assegure que a palavra NEW_CORE_NAME e o número PORT_NUMBER não estejam em uso por outros CORES;

3) Adicionando o novo CORE

A inclusão de um novo CORE será mais rápida se ela partir de um já existente;
Copie o VS_CORE (code/CORES/VS_CORE), o qual é o CORE mais simples, para o CORE que deseja incluir;

cp -r VS_CORE NEW_CORE_NAME_CORE

Dentro do diretório NEW_CORE_NAME_CORE, execute os seguintes procedimentos:
- remova os arquivos vector_space.c, vector_space.h, vs_core.out e vs_core.ok;
- renomeie o diretório VECTORS_SPACES (neste diretório ficarão armazenadas as memórias deste novo CORE);
- Copie para o diretório NEW_CORE_NAME_CORE os arquvos e/ou diretórios pertencentes ao novo CORE;

Obs.: Para uma melhor padronização do CORE, coloque os nomes de todos os arquivos em caixa baixa e os nomes dos diretório em caixa alta.

- Modifique o módulo specific_core_rpcs_handling_functions.c de acordo com o seu CORE (declare variáveis globais e defines no início do módulo). Neste arquivo existem 9 (nove) funções:

begin_training
- input: um inteiro espcificando o número de tabelas, um array de strings com os nomes das tabelas, um vetor de inteiros espcificando os mínimos dos ranges e um vetor de inteiros espcificando os máximos.
- int: "N_TABLES"
- char **: "TABLES_NAMES"
- int *: "MIN_LINES_VEC"
- int *: "MAX_LINES_VEC"
- output: nenhum.
train_line
- input: um vetor de floats a ser utilizado como padrão de treino (e o seu respectivo tamanho) e um vetor de targets (e o seu respectivo tamanho).
- float : "TTV_VECTOR"
- int : "TTV_LENGTH"
- int *: "CNAE_CODES_VECTOR"
- int : "CNAE_CODES_LENGTH"
- output: nenhum.
end_training
- input: nenhum.
- output: nenhum.
reload
- input: o nome da memória a ser carregada.
- char *: "NAME"
- output: Inteiro especificando se a chamada transcorreu com sucesso (SUCCESS = 0) ou se houve alguma falha (FAIL = 1).
- int: 0 ou 1
save
- input: o nome da memória a ser salva.
- char *: "NAME"
- output: Inteiro especificando se a chamada transcorreu com sucesso (SUCCESS = 0) ou se houve alguma falha (FAIL = 1).
- int: 0 ou 1
classify
- input: um vetor de floats representando o texto do usuária a ser classificado (e o seu respectivo tamanho)
- float : "USER_VECTOR"
- int : "VEC_LENGTH"
- output: um vetor de inteiros contendo códigos sequenciais da tabela CNAE, um vetor de floats contendo as respectivas probabilidades e um inteiro contendo o tamanho deste vetores:
- int : "SEQ_CODE_VEC"
- float : "PROBABILITIES_VEC"
- int : "VEC_SIZE"
begin_test
- input: um inteiro espcificando o número de tabelas, um array de strings com os nomes das tabelas, um vetor de inteiros espcificando os mínimos dos ranges e um vetor de inteiros espcificando os máximos.
- int: "N_TABLES"
- char **: "TABLES_NAMES"
- int *: "MIN_LINES_VEC"
- int *: "MAX_LINES_VEC"
- output: nenhum.
test_line
- input: o nível da tabela CNAE em que o teste será realizado, um vetor de floats a ser utiluizado como padrão de teste (e o seu respectivo tamanho), um vetor de targets (e o seu respectivo tamanho) e o tamanho do vetor de beliefs (igual a quantidade de códigos existente no nível de teste).
- int : level
- float : "TTV_VECTOR"
- int : "TTV_LENGTH"
- int *: "CNAE_CODES_VECTOR"
- int : "CNAE_CODES_LENGTH"
- int : "PREDICTED_CLASSES_AND_BELIEFS_size"
- output: um vetor de estruturas a ser preenchido. Cada estrutura contém três campos, mas o CORE deverá preencher apenas 2: classe e belief.
- PREDICTED_CLASS_AND_BELIEF *: "PREDICTED_CLASSES_AND_BELIEFS"
end_test
- input: nenhum.
- output: nenhum.

O novo CORE deverá fazer uma chamada de função que inicializará o servidor (a partir desta chamada, o CORE entrará em um estado de espera por requisições). A função que inicializa o servidor é a initialize_core_server (NEW_CORE_NAME), em que NEW_CORE_NAME é a mesma string que foi inserida no arquivo ports.cfg. Atenção: a função initialize_core_server(NEW_CORE_NAME) só deverá ser chamada após o CORE ter inicializado suas variáves, estruturas. Veja o exemplo a seguir:

int
main (int argc, char *argv[])
{
	/* Inicializações pertinentes ao seu CORE */

	initialize_core_server ("NEW_CORE_NAME");

	return (0);
}

Alterar o arquivo Makefile.
- Altere o nome do executável;
- Remova o arquivo .objeto vector_space.o e adicione outros (caso existam);
- Atualize as linhas de dependências do Makefile:

vector_space.o	: vector_space.h $(INCPATH)/specific_core_rpcs_handling_functions.h
specific_core_rpcs_handling_functions.o	: $(INCPATH)/specific_core_rpcs_handling_functions.h vector_space.h

4) Criação de scripts para realização de experimentos

Os scripts de experimentos são aqueles construídos de forma que seus resultados sejam os postados na página de Resultados de Pesquisa.

Caso queira realizar experimentos com o novo CORE, será necessário criar scripts de treino e teste. Para isto:
- Entre no diretório USER_INTERFACE (code/CORES/USER_INTERFACE);
- No diretório USER_INTERFACE crie arquivos seguindo o mesmo modelo dos arquivos experiment_1.a.x.b.train.bat experiment_N.a.x.b.train.bat, onde a varia de 1 a 8 (até o momento) e b de 1 a 8 (número de experimentos existentes em um tabela). N representá o N-ésimo CORE inserido no scae;
- No diretório USER_INTERFACE crie arquivos seguindo o mesmo modelo dos arquivos experiment_1.a.x.b.test.bat experiment_N.a.x.b.test.bat, onde a varia de 1 a 8 (até o momento) e b de 1 a 8 (número de experimentos existentes em um tabela). N representá o N-ésimo CORE inserido no scae;
- Abra todos os arquivo criados:

kdevelop experiment_N*&

e altere o nome do CORE (troque VS por NEW_CORE_NAME).

5) Subindo o novo CORE para svn

Antes de adicionar o novo CORE ao svn, assegure que não existem arquivos .svn e executáveis nos diretório NEW_CORE_NAME_CORE e nos seus subdiretórios;
Agora, no diretório code, execute os seguintes comandos:

svn add NEW_CORE_NAME_CORE
svn ci NEW_CORE_NAME_CORE -m "Adicionado o CORE NEW_CORE_NAME ao repositório do SCAE. Este CORE ..."

Pronto, você acabou de inserir um novo CORE!

Manual do SCAE

Índice

Introdução

Tutorial sobre o SCAE

Introdução

Download

Como Acessar o Repositório do SCAE

Organização do Repositório

Navegando no Repositório

Baixando o SCAE para sua Máquina

Como Acessar o Repositório MAE

Organização do Repositório

Navegando no Repositório

Baixando a MAE para sua Máquina

Instalação

Instalação do corretor ortográfico

A partir da Versão do SVN 490

Antes da Versão do SVN 490

Compilando e Executando o BD

CRIAÇÃO DE TABELAS

CRIAÇÃO DE DICIONÁRIOS A PARTIR DE FILTROS

Criando um dicionário a partir de tabelas

Criando um dicionário a partir de outro dicionário

Execuntando o DB_CORE SERVER

Compilando a Biblioteca Compartilhada de Comunicação (shared)

Compilando a Biblioteca Compartilhada MAE

Compilando e Executando o VS_CORE

Compilando e Executando o WNN_CORE

Compilando e Executando o WNN_COR_CORE

Compilando e Executando o BOOSTEXTER_CORE

Compilando e Executando o PNN_CORE

Configurando o SA

Usando o SCAE

Criando Tabelas no DB_CORE

Criando Benchmarking a partir da base do IBGE

Gerando Medidas de Certeza a Serem Exibidas como Saída dos Categorizadores

Configuração/Validação/Teste das Estratégias de Poda de Ranking dos Categorizadores

Utilizando a USER_INTERFACE

Utilizando a Interface Web

Codificação de Colunas das Tabelas do BD Segundo o Dicionário Eletrônico do SCAE

Criação de um Lexicon no SCAE

Criação de Vetores de Treinamento e Teste

Treinamento dos Cores Classificadores do SCAE

Teste dos Cores Classificadores do SCAE

Classificação de Atividades Econômicas com o SCAE

Organização do SCAE

As Partes do SCAE

Comunicação entre os COREs (xmlrpc)

Comunicando com o DB_CORE

Comunicando com os COREs Categorizadores

Módulos do SCAE (COREs)

DB_CORE

Tabelas Existentes

Manipulando o Dicionário

WNN_CORE

WNN_COR_CORE

VS_CORE

VSC_CORE

WISARD_CORE

BAYESIAN_CORE

CAN_CORE

MLKNN_CORE

PNN_CORE

Adicionando um CORE ao SCAE

Menu de navegação

Pesquisa