M.Sc Engenheiro

Bom dia a todos, eu gostaria de compartilhar da minha felicidade com os leitores do MultiSign.

Eu apresentei minha dissertação de mestrado na última semana e o meu trabalho foi aprovado, então, para todos os efeitos, eu sou engenheiro e mestre em engenharia.

Por estes dias eu estarei fazendo as correções no texto da minha dissertação, mas estarei sempre respondendo às questões que forem apresentadas e comentários nos posts.


Gostaria de agradecer a atenção de todos e que Deus nos abençoe.

Projeto SIRENE chega ao fim, por enquanto

Eu acredito que meus leitores saibem que eu estou fazendo mestrado.

Pois bem, finalmente eu o estou concluindo.

Para os que não conhecem o meu trabalho de mestrado, este trata-se de um sistema de reconhecimento de gestos por visão computacional.

A sigla do sistema é SIRENE (Sistema de Reconhecimento de Gestos por Redes Neurais e Visão Computacional), o nome é auto-esplicativo.

Durante o desenvolvimento do projeto, eu desenvolvi algumas coisas, como um protótipo, cujo vídeo é apresentado a seguir:



E dois artigos publicados em congresso, podem ser vistos aqui.

Espero que aqueles que conheceram meus trabalhos tenham apreciado e se motivado a também contribuir para a sociedade com o desenvolvimento tecnológico.


Obs.: A defesa da minha dissertação será nesta sexta-feira (23/04).

Novo dia, novo ano

Novo dia, novo ano, novas oportunidades.

Com a graça de Deus e o trabalho diário vou conseguir fechar as pendências do ano passado e começar novas atividades.

Espero sempre manter o MultiSign atualizado e sempre mais interessante, conto neste ano, mais que nos anteriores, com a ajuda e compreensão de todos.

Protótipo do SIRENE em funcionamento

Como todos sabem, estou em São Paulo - SP participando do Interaction South-America'09.

Eu tive dois artigos aceitos, sendo que um deles consiste no resumo do meu mestrado.

Para este artigo, eu preparei um protótipo do SIRENE e gerei este vídeo.



Apesar do vídeo ser curto, ele demorou alguns minutos para ser gerado, quem tiver interesse em saber como está o protótipo é só entrar em contato.

Fazendo vídeos e fotos com webcam

Nos últimos dias eu estava precisando fazer uns vídeos para dar continuidade ao meu projeto de mestrado. Então eu procurei algum software que capturasse frames da webcam e fizesse o vídeo, nessa procura eu encontrei o Cheese.

O Cheese é um software simples de usar e que dá bons resultados.

Segue um vídeo da utilização do sistema:



Pena que a tela de exibição dos frames não foi capturada corretamente.

Tutorial Scilab - 8 [Usando arquivos]

[English version here.]

Quanto tempo hein? Mas finalmente estou retomando os meus compromissos (dentre eles, o MultiSign).

Pois bem, vamos ver algo sobre manipulação de arquivos com o Scilab agora.

No Scilab, existem diversas funções para manipular arquivos tanto arquivos ASCII quanto binários.

Os aquivos são importantes para melhor gerenciar dados de entrada e resultados obtidos (óbvio não acham?).

Como a maioria deve saber o que é um arquivo, vamos dar continuidade ao post.

Uma boa forma de conhecer as formas de manipulação de arquivos no Scilab é com o help, olhe como acessar o help na figura abaixo:


Na tela de ajuda, digite: file manage e selecione a primeira opção file(.).

Esta função é semelhante à função fopen(.) da linguagem C.

No help, é possível ver várias informações sobre a função file(.).

Algumas das outras funções funções de manipulação de arquivos no Scilab são:

• save;
• load;
• mopen;
• mclose;
• writeb;
• readb.

No momento, vamos nos limitar as funções:

• read;
• write.
  

A função write(.) cria arquivos ASCII e a função read(.) carrega os arquivos em variáveis.

As variáveis envolvidas nestas funções geralmente são matrizes e/ou vetores. Vamos aos exemplos agora:


-->x = rand(5,5)
x =

0.2113249 0.6283918 0.5608486 0.2320748 0.3076091
0.7560439 0.8497452 0.6623569 0.2312237 0.9329616
0.0002211 0.6857310 0.7263507 0.2164633 0.2146008
0.3303271 0.8782165 0.1985144 0.8833888 0.312642
0.6653811 0.0683740 0.5442573 0.6525135 0.3616361

-->write("test_data.dat", x);

-->y1 = read("test_data.dat", 1, 2) // 1 linnha e 2 colunas
y1 =

0.2113249 0.6283918

-->y2 = read("test_data.dat", 2, 2) // 2 linhas and 2 colunas
y2 =

0.2113249 0.6283918
0.7560439 0.8497452

-->y3 = read("test_data.dat", -1, 1) // -1 indica que se deve ler todas as linhas
y3 =

0.2113249
0.7560439
0.0002211
0.3303271
0.6653811

-->>y4 = read("test_data.dat", -1, 5) // lê o arquivo inteiro
y4 =

0.2113249 0.6283918 0.5608486 0.2320748 0.3076091
0.7560439 0.8497452 0.6623569 0.2312237 0.9329616
0.0002211 0.6857310 0.7263507 0.2164633 0.2146008
0.3303271 0.8782165 0.1985144 0.8833888 0.312642
0.6653811 0.0683740 0.5442573 0.6525135 0.3616361


O arquivo test_data.dat é apresentado na figura a seguir (clique na figura para vê-la em tamanho real).

Nota aos leitores

Acredito que os leitores do MultiSign devem ter percebido que as postagens estão "meio atrasadas".

Eu estou com algumas atividades no momento que estão tomando muito tempo e eu também tenho outros blogs (Using Scilab, Engenheiro Católico e Catholic Engineer) os quais têm me dado muita satisfação, pois os leitores estão sempre interagindo com comentários e e-mails.

Espero estar renormalizando o MultiSign na próxima semana.

Abraços a todos e que Deus os abençoe.

Tutorial Scilab - 6 [Vetores e Matrizes - 4]

[English version here.]

Primeiro gostaria de me explicar com os leitores do MultiSign. Eu passei estes dias (quase 3 semanas) sem fazer nenhuma postagem porque estava envolvido com as atividades da Semana Santa, festas pascais e um artigo que espero finalizar hoje.

Voltando ao assunto. Vamos ver agora como fazer operações lógicas com vetores e matrizes.

Um exemplo:

Vamos supor que o vetor a seguir corresponde a altura, em metros, de um conjunto de pesoas.

v = [1.55 1.82 1.48 1.71 1.62 1.94 2.00]'

Precisamos então identificar as pessoas que têm mais de 1,80m.

Uma solução direta é analizar elemento por elemento:

v(1) > 1.80
v(2) > 1.80
v(3) > 1.80
v(4) > 1.80
v(5) > 1.80
v(6) > 1.80
v(7) > 1.80

Mas o Scilab tem uma forma mais prática de fazer isso:

v > 1.8 // esta operação não depende da dimensionalidade ou tamanho do vetor

Vamos fazer um script.

-->v = [1.55 1.82 1.48 1.71 1.62 1.94 2.00]'
v =

1.55
1.82
1.48
1.71
1.62
1.94
2.

-->v > 1.8
ans =

F
T
F
F
F
T
T

Mas, se o que desejamos é saber a posição dos elementos (pessoas) com mais de 1,80m:

-->pos = find(v > 1.8)
pos =

2. 6. 7.

Os elementos em v que são maiores que 1,80 são o segundo (1,82), sexto (1,94) e sétimo (2,00).

Podemos fazer a mesma coisa com matrizes.

Um exemplo muito útil é criar uma matriz binária em que a probabilidade de um elemento ser 0 (zero) é a mesma dele ser 1 (um).

Olhem o script e me dêem um feedback.

-->x = rand(3, 3)
x =

0.5667211 0.0568928 0.7279222
0.5711639 0.5595937 0.2677766
0.8160110 0.1249340 0.5465335

-->y = x > 0.5
y =

T F T
T T F
T F T

Para instigá-los, eu pergunto por que tem tantos T's a mais que F's?

Mais uma etapa chegando ao fim...

Como os leitores já devem ter percebido, estou postando com baixa frequência.

O motivo é o meu mestrado que está chegando ao fim, e como todo final de curso que se preze estou com muito o que fazer.

Minha previsão é terminar o mestrado em julho (com a defesa da minha dissertação).

Enquanto estou ocultado com as atividades do mestrado, não poderei dar a devida atenção aos meus blogs.

Espero contar com a compreensão de todos e que Deus esteja conosco hoje e sempre.

Técnicas clássicas de segmentação de pele humana

Enfim algum tempo livre... Vou aproveitar e fazer um post sobre uma das etapas do meu mestrado a segmentação da pele.

Vou apenas apresentar 3 formas de segmentação de pele e alguns resultados obtidos.

A imagem de teste é apresentada a seguir.



Espaço de cores RGB:

Um pixel pertence a pele se satisfizer as condições abaixo:

R > 95
G > 40
B > 20
max {R, G, B} − min {R, G, B} > 15
|R − G| > 15
R>G
R>B

Resultado da segmentação:



Espaço de cores YCbCr:

Um pixel pertence a pele se satisfizer as condições abaixo:

77 ≤ Cb ≤ 127
133 ≤ Cr ≤ 173

Resultado da segmentação:



Espaço de cores HSV:

Um pixel pertence a pele se satisfizer as condições abaixo:

0° ≤ H ≤ 50°
0, 23 ≤ S ≤ 0, 68

Resultado da segmentação:


Antes que alguém saia por aí dizendo que um método é melhor que outro, eu digo que depende da imagem a ser segmentada.

Os algoritmos apresentados são muito dependentes da iluminação do ambiente.

Para fechar, seguem os códigos do Scilab para segmentar imagens conforme apresentado.

/////////////////////////////////////////////////////////////////////////////////////////
// Algoritmos de segmentacao de pele em imagens baseados em limiarizacao
// Universidade Federal do Ceara
// Eng. Alex
//*//*//*//*//*//*//*//*//*//*//*//*//*//*//*//*//*//*//*//*//*//*//

//// parametros das imagens

Y = 2;
Cb = 1;
Cr = 3;

H = 1;
S = 2;
V = 3;

nL = 480; // numero de linhas da imagem
nC = 640; // numero de colunas da imagem


img = im2double(imread("imagem.jpg"));

////////////////////////////////////////
//parametros em RGB //
//////////////////////////////////////

img_s = zeros(nL, nC);

for l = 1:nL,
for c = 1:nC,
p = img(l,c,:);

ps = (p(1)>95/255).*(p(2)>40/255).*(p(3)>20/255).*(max(p) - min(p)>15/255).*(abs(p(1) - p(2))>15/255).*(p(1)==max(p));
img_s(l,c) = ps;
end;
end;

imwrite(img_s, "rgb-imagem.jpg");

///////////////////////////////////
//limiares em CbCr //
/////////////////////////////////

imgYCbCr = rgb2ycbcr(img);

img_s = double(((imgYCbCr(:,:,Cb)>76/255) .* (imgYCbCr(:,:,Cb)<128/255)).*((imgycbcr(:,:,cr)>132/255) .* (imgYCbCr(:,:,Cr)<174/255)));

imwrite(img_s, "cbcr-imagem.jpg");

///////////////////////////////
//limiares em HS //
/////////////////////////////

imgHSV = rgb2hsv(img);

img_s = double((imgHSV(:,:,H)<50/360).*((imghsv(:,:,s)>0.23) .* (imgHSV(:,:,S)<0.68)));

imwrite(img_s, "hs-imagem.jpg");

Chegando na reta final da qualificação

Aos leitores do MultiSign que percebem minha ausência nos posts, informo que a previsão é que na próxima semana eu volte a atualizar o blog com mais frequência.

Se bem que poucas pessoas interagem com comentários e a enquete.

Vejo no mapa um monte de pontos enormes sobre o Brasil (o que indica centenas de leitores), mas poucos são os que comentam (não tenho nenhum post nem com 5 comentários) e eu vejo blogs por aí que todos os posts têm dezenas de comentários.

Mas enfim, não deixarei de fazer os posts porque meus leitores não comentam, porém se comentassem, ajudaria bastante.

E só para adiantar, os resultados que estou tendo nos testes preliminares são motivadores.

Esperem e verão.

Vogais em Libras

Eu fiz mais uns vídeos para a minha qualificação de mestrado.

Como eu estou com problemas com o Scilab (que decidiu não abrir mais arquivos de vídeo) eu extrai os frames de cada vídeo (com o mplayer), basta dar o comando:

>> mplayer -vo jpeg nome_do_arquivo.avi

Atualmente, estou avaliando algoritmos de segmentação da pele, testei alguns de limiarização e outros baseados em clustering. Nenhum deles funciona bem em todas as imagens que tenho, caso alguém se disponha a ajudar, ficarei muito grato.

Seguem algumas imagens que gerei.

Letra 'A'


Letra 'E'

Letra 'I'

Letra 'O'

Letra 'U'

Qualificação

Esta semana eu descobri que tenho 1 mês para preparar toda a minha qualificação de mestrado.

Por isto eu não poderei manter o MultiSign atualizado com frequência.

Eu agradeço aos leitores que lêem o blog com frequência (ontem mesmo tive 37 visitas, olhem aqui) e algo que me deixou muito satisfeito foi o primeiro ponto com mais de 10 visitas fora do Brasil e Portugual, conforme a figura abaixo.


Olhem o oeste (lado esquerdo) dos Estados Unidos.

Enfim, é só isso mesmo.

Momentos centrados

Este é o primeiro post que faço sobre minhas pesquisas acerca do meu mestrado.

Para refrescar a memória dos que já sabem do que se trata o meu mestrado e para informar os leitores que vieram depois que parei de escrever sobre estas pesquisas:

Meu projeto de mestrado consiste em desenvolver um sistema de reconhecimento automático da Libras (Língua de Sinais Brasileira).

Este projeto tem as seguintes etapas:

1. Aquisição da(s) imagem(ns) por uma webcam;
2. Segmentação do objeto de interesse (mão);
3. Extração de atributos da imagem;
4. Classificação da imagem de acordo com os atributos.

Pois bem, como já coloquei em posts anteriores, a parte da segmentação está funcionando bem e eu já tenho os classificadores implementados (fiz-os na disciplina de reconhecimento de padrões).

Agora faltava apenas a parte de extração de atributos, mas eu estava estudando o livro de reconhecimento de padrões adotado na disciplina (quem quiser saber qual é o livro, pode pedir em comentário(s)) e vi algo sobre momentos centrados, e vi também que estes momentos são atributos extraídos dos objetos presentes em imagens para classificá-los.

Por fim, achei que seria interessante falar sobre os momentos centrados.

Os momentos centrados são provenientes da mecância clássica, pois consistem em momentos baseados no centro de massa dos corpos (objetos).

A equação abaixo mostra como são calculados os momentos centrados:
Em que f(x,y) é a imagem. Os termos p e q são ordens do momento, como fazemos em estatística nos momentos de 1ª (média), 2ª (variância), 3ª (curtosis), 4ª, etc.... ordem; podemos observar que estes momentos podem ser escritos até como termos de esperança matemática (olhe aqui).

Os centros de massa dos objetos (corpos) são dados pela equação abaixo:
Estes momentos centrados são descritores muito úteis, pois são invariantes a translação dos objetos, porém, observa-se que estes momentos são dependentes à rotação.

Para tornar obter descritores indendentes tanto a translação e a rotação, um pesquisador chamado M. Hu propôs as seguintes combinações dos momentos, gerando novas grandezas:


Com isto fecho o que espero ser pelo menos o material para minha qualificação de mestrado.

Conversa sobre redes neurais

Tenho um professor aqui na UFC que lenciona a disciplina de ICA (Inteligência Computacional Aplicada), dentre outras.

Este professor é especialista em redes neurais e sempre procura transmitir o possível de sua experiência aos alunos.

Aqui, neste post, pretendo fazer o mesmo: compartilhar um pouco das minhas experiências com redes neurais, em especial a MLP (Multi-Layer Perceptron).

Começando, digo que redes neurais são aproximadores de funções de um espaço n-dimensional em um espaço m-dimensional.

O espaço n-dimensional (domínio da função) é o espaço de entrada da rede e o m-dimensional (contra-domínio da função) é a saída da rede.

Por exemplo, para a identificação de um sistema elétrico, vamos supor que a entrada da rede seja tensão, corrente e impedância e a saída é uma de 3 classes de sistemas (predominantemente resistivo, capacitivo ou indutivo). Neste caso para cada elemento (V, I, Z) de entrada temos uma saída (S1, S2, S3) associada. A saída pode ser discreta ou contínua, no exemplo apresentado a saída pode ser a que classe pertence o sistema ou o grau de presença de cada tipo de elemento.

Uma aplicação interessante é a previsão de séries temporais, em que a rede neural "prevê o futuro" com base no passado. Neste caso, a entrada da rede podem ser n valores assumidos pela função no passado e a saída os m valores futuros. Para se prever o próximo elemento de uma função, pode-se por exemplo tomar 10 elementos anteriores e extimar o próximo a partir deles.

Limitando-nos as redes supervisionadas, dentre as quais está a MLP, a questão de aplicar a rede neural é o seguinte:

1. Definir o problema e seus parâmetros (entrada(s) e saída(s));
2. Projetar a arquitetura da rede neural, no caso da MLP consiste em definir os parâmetros da rede (taxa de aprendizagem), quantidade de camadas e número de neurônios por camada;
3. Tomar dados conhecidos do problema, ou seja montar um conjunto de dados conhecido para o treinamento da rede neural, com as entradas e saídas respectivas;
4. Realizar o treinamento da rede, em que para cada entrada é apresentada a saída desejada e assim a rede vai se adaptando ao problema;
5. Tomar novos dados para testar (validar) a rede neural, os dados de treinamento não podem estar presentes na validação da rede neural.

Algumas dicas para o treinamento da rede neural:

• Usar funções de ativação suaves;
• Gerar valores de erro grandes, isto acelera a aprendizagem;
• Usar taxas de aprendizagem baixas (da ordem de 0,001) para que a rede neural possa ajustar-se com maior precisão à função que está sendo mapeada;
• Explorar a solução das redes neurais mais simples, começando sem camada oculta, depois com 1 camada oculta e por fim 2 camadas ocultas.
  

Acho que isto é tudo por enquanto. Depois faço novas postagens sobre redes neurais, se possível mais técnicas

E para fechar, o Scilab tem toolboxes de várias ferramentas que podem ser de grande ajuda no projeto de redes neurais.

Novidades

Eu passei num curso de inglês aqui em Fortaleza, então achei que seria interessante treinar algo do inglês aqui no MultiSign.

Os post's em inglês serão traduções de post's anteriores.

Espero que esta nova filosofia (de traduzir os post's antigos) possa mostrar à mais pessoas no mundo que aqui no Brasil (em particular no nordeste brasileiro) existe pesquisa e desenvolvimento de tecnologias avançadas.

Como já aconteceu, espero que outras pessoas entrem em contato, agora abrindo possibilidade de pessoas de outros países conhecerem os trabalhos desenvolvidos aqui.

Por fim, espero agora ter mais leitores e, quem sabe, leitores que colaborem votando nas enquetes e comentando os post's.

Algoritmos Genéticos - Dicas de implementação

Para falar um pouco mais de algoritmos genéticos, agora citarei algumas dicas para a implementação.

1. Criar uma grande população inicial de indivíduos;
2. Descartar indivíduos pouco "adaptados", em alguns casos cada nova geração substitui a anterior;
3. Buscar soluções na forma de vetores de números binários, isto facilita muito a manipulação dos "genes";
4. Fazer com que os indivíduos "cruzem" da forma mais aleatória possível, para que o algoritmo apresente sempre bastante variabilidade;
   
5. Quando o algoritmo encontra um "mínimo local", que representa uma condição da qual o algoritmo chega e não consegue sair, porém sabe-se que é possível chegar a um resultado melhor, usa-se o recurso da mutação que consiste em alterar aleatoriamente alguns genes dos indivíduos (todos ou alguns).

Como citei no post anterior, Algoritmos Genéticos são baseados na Teoria da Evolução, então é interessante que o desenvolvedor realmente imagine o problema com esta visão, que existem os indivíduos que resolvem o problema e estes indivíduos se reproduzem gerando novos indivíduos que podem resolver melhor ou não o problema, se nenhum dos indivíduos estiver adaptado ao problema ocorrem mutações para que eles possam ficar mais capazes de "perseverar".

Para fechar, o vídeo a seguir foi um trabalho que desenvolvi na disciplina de ICA (Inteligência Computacional Aplicada) usando algoritmos genéticos.



Adianto que o vídeo é curto, porém interessante.

Feed-back

Gostaria de agradecer aos leitores que têm visitado o MultiSign regularmente, as vezes quando faço pesquisas no Gooooooogle vejo o MultiSign nas primeiras páginas para vários assuntos o que confirma que o blog é bem frequentado.

Gostaria de agradecer aos que já votaram na enquete "O que você busca (ou gosta de ver) no MultiSign?" e refazer o pedido de votarem na enquete e comentarem os post's para assim direcionar os post's ao público.

Por fim, gostaria de informar que a enquete aceita várias escolhas simultaneamente e também aceita mudança de escolhas.

Fico grato pela atenção e vamos colaborar que o meu desejo é fortalecer o conhecimento dos leitores.

Retorno

Depois de 1 mês, é hora de voltar as aulas e demais atividades acadêmicas.

Um ponto positivo é que irei, provavelmente, aumentar a frequência e a qualidade dos post's.

Descobri que o MultiSign tem sido bem visitado, até por pessoas de fora do Brasil (em Portugal). Só não entendo por quê tenho dezenas de visitas diárias e ninguém vota na enquete ou comenta os post's (sem querer desagradar ninguém).

Acredito que meu blog não é dos melhores, mas procuro sempre mantê-lo atualizado (fazendo algumas postagens semanais) e com assuntos que considero interessantes.

Enfim, não pretendo desabafar nada aqui, apenas peço que os leitores votem nas enquetes e comentem os post's para enriquecer o conteúdo do blog.

Robótica Open Source

Hoje vi um artigo sobre um kit de robótica (aqui) bem interessante.

O Bioloid Control é um projeto de sistema (hardware e software) destinado principalmente a fins educativos.



O software disponível é livre, se não fosse eu não estaria falando sobre este projeto aqui, e compatível com as plataformas GNU/Linux e M$ Ruindow$.

Algo que fiquei "insatisfeito" foi o fato do Bioloid comunicar o robô com o PC via RS 232 (quase extinta porta serial), porém existem conversores USB-serial que talvez resolvam o problema e como o é software livre em pouco tempo poderemos ter um Bioloid controlado pela USB ou alguma interface wireless, tipo bluetooth.

Não cheguei a ler todo o artigo, mas pelo que li fiquei bem motivado em saber como o sistema trabalha pois vi vários sensores e atuadores e seria interessante conhecer mais a fundo este projeto e se possível contribuir com o mesmo.

Aos curiosos de plantão, assim como eu, vi que o sistema dispõe de interfaces ZigBee o que abre milhares de opções de sensoriamento e controle.

Segue um vídeo do Bioloid (simulação no PC).



Mais em: http://www.revistas.unifacs.br/index.php/sepa/article/viewFile/306/254