anÁlise de quantizaÇÃo vetorial … · 2 joÃo leiles torma kopps anÁlise de quantizaÇÃo...
TRANSCRIPT
Curso de Bacharelado em Ciência da Computação
JOÃO LEILES TORMA KOPPS
ANÁLISE DE QUANTIZAÇÃO VETORIAL UTILIZANDO REDE NEU RAL
ARTIFICIAL PARA COMPRESSÃO DE IMAGEM DIGITAL
Canoas, 2007
2
JOÃO LEILES TORMA KOPPS
ANÁLISE DE QUANTIZAÇÃO VETORIAL UTILIZANDO REDE NEU RAL
ARTIFICIAL PARA COMPRESSÃO DE IMAGEM DIGITAL
Trabalho de conclusão de curso apresentado para a banca examinadora do curso de Ciência da Computação do Centro Universitário La Salle – Unilasalle, como exigência parcial para obtenção do grau de Bacharel em Ciência da Computação, sob orientação do Prof. Me. Gaspare Giuliano Elias Bruno.
Canoas, 2007
3
TERMO DE APROVAÇÃO
JOÃO LEILES TORMA KOPPS
ANÁLISE DE QUANTIZAÇÃO VETORIAL UTILIZANDO REDE NEU RAL
ARTIFICIAL PARA COMPRESSÃO DE IMAGEM DIGITAL
Trabalho de conclusão aprovado como requisito parcial para obtenção do grau de Bacharel do curso de Ciência da Computação do Centro Universitário La Salle -
Unilasalle, pela seguinte banca examinadora:
__________________________________
Prof. Me. Javier García López
Unilasalle
__________________________________
Prof. Me. Mozart Lemos de Siqueira
Unilasalle
Canoas, 05 de novembro de 2007.
4
DEDICATÓRIA
Dedico este Trabalho de Conclusão:
À minha mãe Elda, pelo seu carinho, otimismo, incentivo e dedicação.
Ao meu pai Américo “in memoriam”, pelo exemplo de coragem e persistência em suas
metas.
À minha irmã Lourdes, pelo apoio incondicional.
Às minhas filhas Amanda e Jéssica, que muitas vezes estiveram privadas da minha
atenção, mas nunca do meu amor, para que possa servir de incentivo para elas.
À minha esposa Andreza, pela paciência durante todo o período da minha graduação.
5
AGRADECIMENTOS
Agradeço à minha mãe Elda, minha irmã Lourdes, minhas filhas Amanda e
Jéssica e minha esposa Andreza pelo apoio.
Agradeço ao meu professor orientador Me. Gaspare Giuliano Elias Bruno, pela
atenção, paciência e incentivo, com quem muito aprendi.
Agradeço ao professor coordenador Dr. Marcos Ennes Barreto, por toda a
atenção que teve comigo.
Agradeço a todos os meus professores do La Salle - Unilasalle, pela atenção e
disposição para me atenderem.
Agradeço aos meus colegas de graduação pela parceria, em especial à Andréa
Krob, Cinara Zambelli, Daniel Amorim, Juliana Bilhão e Régis Model.
Enfim, agradeço a todos que direta ou indiretamente contribuíram para a
realização deste trabalho.
6
“A mente que se abre para uma nova idéia
nunca volta ao seu tamanho original”
Albert Einstein
7
RESUMO
Diversos trabalhos relacionados à quantização vetorial, que é uma técnica que consegue alta taxa de compressão de dados, têm buscado reduzir o tempo de compressão de imagens, mas os resultados mostram algum prejuízo de qualidade em relação à imagem original quando é realizada a decodificação. Neste trabalho foi proposta a utilização de redes neurais artificiais auxiliando a técnica de quantização vetorial, como alternativa para a escolha do melhor vetor de imagem em uma biblioteca de vetores. O objetivo desta pesquisa foi investigar a possibilidade de se conseguir uma qualidade de imagem decodificada próxima à qualidade alcançada pelo algoritmo Full Search (que é o método que consegue a melhor qualidade de imagem em quantização vetorial), mas com um tempo de compressão menor, pelo fato de não ser necessária uma comparação de cada vetor de imagem de entrada com todos os vetores dessa biblioteca. Os resultados alcançados nesta pesquisa mostraram que a aplicação de redes neurais artificiais, juntamente com quantização vetorial, pode ser considerada uma opção para se conseguir uma alta taxa de compressão de imagens, com qualidade próxima à alcançada pelo algoritmo FS, mas com grande diminuição do tempo de codificação em relação a esse algoritmo. PALAVRAS-CHAVE: Quantização vetorial. Rede neural artificial. Compressão. Imagem.
ABSTRACT
Several studies related to vector quantization, a technique that gets a high data compression, try to reduce the image compression time, but the results present some harm in the quality of the decodified image. This work had used artificial neural networks in the vector quantization process as an alternative to aid the choice of the best codeword within a codebook. The objective this research was to investigate the possibility to achieve a decodified image with a similar quality which is provided by the Full Search algorithm (it is the method that obtains the best quality of image in vector quantization), but in a minor time, because is not necessary to compare all the codewords available in the codebook. The results reached in this inquiry showed that the application of artificial neural networks, bonded with vector quantization, can be considered an option in order that to get a high rate of images compression, with a quality close to the one reached by the algorithm FS, but with great decrease of time codification compared to this algorithm. KEYWORDS: Vector quantization. Artificial neural network. Compression. Image.
8
LISTA DE ABREVIATURAS E SIGLAS
ANSI – American National Standards Institute
DCT – Discrete Cosine Transform
DHSS3 – Dynamical Hyperplanes Shrinking Search with three axes
DPCM – Differential Pulse Code Modulation
DVQ – Differential Vector Quantization
ENNS – Equal-average Nearest-Neighbor Search
ESVQ – Exhaustive Searching Vector Quantization
FANN – Fast Artificial Neural Network
FS – Full Search
HH – High - High
HL – High-low
JPEG – Join Photographic Experts Group
JPG – Join Photographic Group
LBG – Linde Buzo Gray
LH – Low-high
LL – Low-low
MATLAB – Matrix Laboratory
MSE – Mean Square Error
NTSC – National Television System Committee
PSNR – Peak Signal-to-Noise Ratio
RAM – Random Access Memory
RNA – Rede Neural Artificial
RNAs – Redes Neurais Artificiais
RGB – Red Green Blue
SOM – Self Organization Maps
VBTSVQ – Variable-Branch Tree-Structured Vector Quantization
YUV – Luminância, intensidade de vermelho, intensidade de azul
9
LISTA DE FIGURAS
Figura 1 – Distribuição de freqüências em uma matriz de 8x8 pixels.............................18
Figura 2 – Diferença visual entre os coeficientes das freqüências de imagem. .............19
Figura 3 – Scan Zig-Zag em matriz de 8x8 pixels. .........................................................20
Figura 4 – Segmentação em quantização escalar. ........................................................22
Figura 5 – Exemplo de entradas e saídas para compressão de imagens......................24
Figura 6 - Exemplo de conexões entre neurônios. .........................................................27
Figura 7 - Semelhanças entre Subbandas. ....................................................................31
Figura 8 - CplX versus Bit Rate. .....................................................................................32
Figura 9 – Fluxo do experimento....................................................................................38
Figura 10 – Blocos iniciais da imagem Lena. .................................................................40
Figura 11 – Parâmetros iniciais da RNA. .......................................................................52
Figura 12 – Arquitetura da RNA. ....................................................................................54
Figura 13 – Pesos da RNA após treinamento. ...............................................................54
Figura 14 – Imagem Lena utilizada no teste...................................................................55
Figura 15 – Imagem Lena restaurada pelo algoritmo FS: 33,74 dB. ..............................55
Figura 16 – Imagem Lena restaurada pela RNA: 25,66 dB............................................56
Figura 17 – Diferença de PSNR entre o algoritmo FS e a RNA. ....................................56
Figura 18 – Gráfico PSNR versus quantidade de treinos. ..............................................57
Figura 19 – Gráfico PSNR versus erro de convergência................................................58
Figura 20 – Imagem Lena restaurada por RNA: 26,85 dB. ............................................60
Figura 21 – Imagem Lena restaurada por RNA: 27,70 dB. ............................................62
Figura 22 – Diferença de PSNR entre o algoritmo FS e 4 RNAs especialistas. .............64
10
LISTA DE TABELAS
Tabela 1: Algumas combinações de RGB......................................................................16
Tabela 2: Resumo dos testes realizados. ......................................................................49
Tabela 3: Tempo de execução para codebook com 10000 vetores. ..............................50
Tabela 4: Tempo de execução para codebook com 20000 vetores. ..............................51
Tabela 5: Variação da quantidade de treinos. ................................................................57
Tabela 6: Erro de convergência de cada RNA. ..............................................................62
Tabela 7: Discriminação dos tempos de codificação......................................................63
11
SUMÁRIO
1 INTRODUÇÃO................................................................................................. 12
2 PROCESSAMENTO DIGITAL DE IMAGEM .................... ............................... 15
2.1 Sistema de cor RGB................................. ................................................... 16
2.2 Sistema de cor YUV ................................. ................................................... 17
2.3 Transformada discreta do cosseno................... ........................................ 18
3 QUANTIZAÇÃO ........................................ ...................................................... 21
3.1 Quantização escalar................................ .................................................... 21
3.2 Quantização vetorial ............................... .................................................... 23
4 REDES NEURAIS ARTIFICIAIS .......................... ........................................... 27
5 TRABALHOS RELACIONADOS ............................. ....................................... 30
5.1 Quantização vetorial ............................... .................................................... 30
5.2 Rede neural artificial ............................. ...................................................... 33
6 METODOLOGIA........................................ ...................................................... 37
6.1 Programa de criação do c odebook............................................................ 39
6.2 Algoritmo FS....................................... ......................................................... 42
6.3 Programa de restauração de imagem .................. ..................................... 45
6.4 Programa para teste do PSNR ........................ ........................................... 46
7 TESTES E RESULTADOS................................ .............................................. 49
7.1 Teste de tempo de processamento .................... ....................................... 50
7.2 Treino da RNA, testes e resultados ................. .......................................... 52
7.2.1 Teste – 1200 vetores de treino e codebook com 10000 vetores ...............................54
7.2.2 Teste – variação de imagens de treino para um codebook com 10000 vetores........56
7.2.3 Teste – codebook com 1000 vetores e uma imagem de treino .................................59
7.2.4 Teste – 4 RNAs treinadas, cada uma com 1/4 da imagem de treino ........................60
8 CONCLUSÃO.......................................... ........................................................ 65
8.1 Limitações......................................... ........................................................... 66
8.2 Trabalhos futuros.................................. ...................................................... 66
12
1 INTRODUÇÃO
Quantização vetorial (LINDE, 1980) é uma técnica que pode ser utilizada na área
de codificação de imagem e vídeo e tem sido muito estudada por pesquisadores do
meio científico. Ela é conhecida como a técnica que utiliza vetores ao invés de
escalares com o objetivo de conseguir um melhor desempenho na compressão de um
determinado sinal (KIM, 1995), (CAO, 2000).
A compressão de um conjunto de dados busca diminuir a quantidade de
informação, tanto para transmissão quanto para armazenamento (GERSHO, 1991). Na
Internet, a compressão de dados permite reduzir a banda ocupada.
A Internet a cada ano tem recebido mais usuários e com isso tem ocorrido um
aumento em transmissões de imagens, vídeos e conferências. Isso pode causar futuros
congestionamentos e até mesmo comprometer a estabilidade dessa rede. Portanto, é
de suma importância avaliar as opções disponíveis em termos de novas técnicas que
possam conseguir maior compressão de dados, porém com baixo custo computacional
e boa qualidade de decodificação.
No processo de codificação de uma imagem, a quantização é a etapa que
responde pela maior compressão de dados e pela degradação de qualidade da imagem
original, quando da sua decodificação (FERRAZ, 1998).
Na codificação de um vídeo, na qual, dependendo do padrão utilizado, podem-se
ter trinta imagens codificadas por segundo, um dos principais desafios é a redução do
tempo em que os dados são comprimidos. Da mesma forma, a taxa de compactação e
a qualidade da imagem descompactada também são focos de pesquisa nessa área.
Existem várias técnicas para se comprimir dados através da quantização e que
podem ser divididas em duas categorias: quantização escalar e quantização vetorial
(BRUNO, 2003).
13
A idéia da quantização escalar é, por meio da utilização de índices, estabelecer
que um determinado índice represente um determinado conjunto de valores para
conseguir compressão de dados. A quantidade de valores que esse índice representa
está diretamente relacionada à taxa de compressão.
Diferentemente, o objetivo de um quantizador vetorial é criar um codebookI que
contenha um número finito de vetores, também chamados de codewords ou
codevectors, que serão comparados com os vetores extraídos das imagens de entrada
do codificador. O vetor do codebook escolhido para ter seu índice enviado ao
decodificador é aquele que tiver o menor erro médio quadrático (MSE - Mean Square
Error) (NASRABADI, 1988), (JUNIOR 1993), (TAI, 1996), (MAKUR, 1997), (FERRAZ;
GRAY; ZHU, 1998), (KLAUTAU, 1999), (BRUNO, 2003), em relação a um vetor de
entrada.
O algoritmo que consegue a menor distorção de imagem decodificada em
relação à codificada é o Full Search (FS), pois para cada vetor de entrada, ele executa
uma pesquisa em todo o codebook para encontrar o codeword com menor MSE. Essa
pesquisa resulta um custo computacional muito elevado devido à quantidade de
comparações e aos cálculos envolvidos em cada comparação (CAO, 2000), (LAI, 2004).
Algumas propostas tais como as de Lin (1994), Yang (2004) e Lai (2004)
conseguem diminuir o tempo de processamento da busca do codeword mais compatível
com o vetor de entrada, mas acabam tendo uma qualidade de imagem inferior ao FS
após a decodificação.
A utilização de redes neurais artificiais (RNAs) em quantização vetorial
(CARBONARA, 1992), (KIM, 1995), (CHU, 1998) e a sua complexidade O(n log n)II
(MARTINETZ, 1993) inferior em relação à complexidade O(2kr)III (BAYAZIT, 1999) do
algoritmo FS, foram os dois pontos-chave que inspiraram esta pesquisa a verificar o
comportamento de uma rede neural artificial (RNA) empregada em quantização vetorial
para escolha de codewords. Dessa forma, de acordo com a informação citada
I Conjunto de vetores para representação dos blocos de imagem de entrada no codificador. II Para essa complexidade, n representa o número de vetores do codebook. III Para essa complexidade, k representa a dimensão do vetor e r a taxa de bits por amostra de entrada.
14
anteriormente, este autor considera que em termos de complexidade computacional,
uma RNA apresenta melhor desempenho que o algoritmo FS.
A questão de pesquisa explorada nesta monografia é verificar qual a distorção
que uma RNA aplicaria na codificação de uma determinada imagem em relação a essa
mesma imagem codificada pelo algoritmo FS.
O objetivo deste trabalho é apresentar uma proposta de aplicação de
quantização vetorial, utilizando RNAs e, posteriormente, realizar uma análise
comparativa com o algoritmo FS em relação à distorção resultante da escolha dos
codewords do codebook. Essa comparação de distorção será realizada utilizando-se
como referência a medida de pico da relação sinal-ruído (PSNR - Peak Signal-to-Noise
Ratio) (COSMAN; JUNIOR, 1993), (LIN; SETIONO, 1994), (ALPCAN; SHEPPARD;
ZHU, 1998), (SUDHIR, 1999), (FOWLER; TSAI, 2000), (KARAYIANNIS; KHALIL, 2001),
(PINAGÉ, 2005).
A área de processamento digital de imagem, bem como RNAs e compressão de
imagem, são muito amplas, por essa razão, para não fugir do escopo desta pesquisa,
as informações contidas neste texto são destinadas apenas ao entendimento do leitor
sobre o que foi realizado neste trabalho. Para informações mais aprofundadas sobre
esses assuntos sugeri-se verificar as referências indicadas ao longo desta monografia.
O presente trabalho está dividido em oito capítulos: o capítulo 2 apresenta
algumas características de processamento digital de imagem. No capítulo 3 são
abordadas a quantização escalar e a quantização vetorial. É apresentada no capítulo 4
uma introdução à RNA juntamente com algumas de suas características. Alguns
trabalhos relacionados a esta pesquisa são descritos no capítulo 5. A metodologia
utilizada é descrita no capítulo 6. No capítulo 7 aparecem os testes realizados e os
resultados obtidos. Por fim, no capítulo 8 são apresentadas a conclusão deste trabalho,
as limitações encontradas e as indicações para trabalhos futuros neste assunto.
15
2 PROCESSAMENTO DIGITAL DE IMAGEM
A base deste trabalho está muito ligada à manipulação de informações extraídas
de imagens que são digitalizadas, então é interessante que seja mencionado uma das
maneiras de se tratar com esse tipo de informação.
Para se processar digitalmente uma imagem, o primeiro passo a ser dado é
capturar essa imagem do mundo real e transportá-la para o mundo digital, ou seja, para
dentro de um computador. Esse processo pode ser conseguido, por exemplo,
utilizando-se uma câmera digital.
A imagem digitalizada necessita ser representada de maneira apropriada para
que um computador possa processá-la. Nesse caso, uma solução comumente utilizada,
é a representação da imagem na forma matricial, onde cada célula dessa matriz irá
conter a menor informação dessa imagem.
Geralmente, um equipamento de captura de imagem fornece em sua saída a
imagem capturada no padrão RGB, onde as letras R, G e B significam do idioma inglês
red, green e blue, respectivamente.
Em uma imagem colorida, essa imagem pode ser subdividida em pixels, onde
cada pixel representa a menor informação da imagem. Nesse padrão, cada pixel teria
as informações de luminosidade das cores vermelha, verde e azul de uma imagem.
Para a representação de uma imagem colorida no padrão RGB, seriam
necessárias três matrizes, sendo que cada uma guardaria as informações de
luminosidade de cada uma das três cores que compõem um pixel de imagem. O
tamanho dessas matrizes é definido de acordo com a resolução da imagem quando
essa é capturada. Por exemplo, para se capturar uma imagem colorida com resolução
de 320x240 pixels, poderiam ser utilizadas 3 matrizes, cada uma tendo 320 colunas por
240 linhas.
16
2.1 Sistema de cor RGB
A sigla RGB corresponde respectivamente do idioma inglês à red, green e blue,
ou seja, às cores vermelha, verde e azul. Essas três cores primárias são misturadas e,
de acordo com a quantidade e combinação entre elas, é possível se conseguir muitas
outras cores. A Tabela 1 mostra um exemplo de combinação entre essas três cores
utilizando-se apenas os valores máximo e mínimo de amplitude.
Tabela 1: Algumas combinações de RGB.
Esc
ala
Bra
nco
Am
arel
o
Cya
n
Ver
de
Mag
enta
Ver
mel
ho
Azu
l
Pre
to
R 0 até 255 255 255 0 0 255 255 0 0
G 0 até 255 255 255 255 255 0 0 0 0
B 0 até 255 255 0 255 0 255 0 255 0
Fonte: Jack, 2005, p. 16.
O sistema de cor RGB é muito utilizado computacionalmente porque monitores
de vídeo trabalham com esse padrão de cores ao gerarem as imagens que são
aplicadas em suas entradas.
Uma desvantagem desse sistema é que a cor de um determinado pixel da
imagem é formada pelas três informações de R, G e B, ou seja, para determinadas
cores é necessário alterar as três informações, causando nesses casos, um prejuízo de
desempenho na construção e/ou modificação de algumas cores. Então, em alguns
casos, é utilizado um outro sistema de cores: o YUV, onde as letras Y, U e V
correspondem respectivamente à luminância, intensidade de vermelho e intensidade de
azul de uma imagem.
17
2.2 Sistema de cor YUV
O sistema de cor YUV, que é também utilizado no padrão National Television
System Committee (NTSC), é uma combinação do sistema de cor RGB e é
demonstrado através da fórmula (1) (JACK, 2005):
Y = 0,229*R + 0,587*G + 0,114*B
U = -0,147*R – 0,289*G + 0,436*B
= 0,492*(B – Y) (1)
V = 0,615*R – 0,515*G – 0,100*B
= 0,877*(R – Y)
A fórmula (2) (JACK, 2005) demonstra o caminho inverso para se obter RGB
através de YUV:
R = Y + 1,141*V
G = Y – 0,395*U – 0,581*V (2)
B = Y + 2,032*U
No sistema de cor YUV, o componente Y representa a informação de
luminosidade da imagem e os outros dois componentes representam somente a
informação de intensidade das cores vermelha e azul, com o propósito de economia de
informação. Essa economia ocorre porque no espaço de cor RGB, a informação de
luminosidade de um pixel é repetida três vezes, e no espaço de cor YUV, ela está
presente somente uma vez. Para o sistema de cor RGB, uma imagem que seja
mostrada em tons de cinza, necessita da informação dos três componentes; no sistema
YUV, necessita apenas do componente Y. Com isso, a representação numérica dessa
imagem no sistema de cor YUV é menor do que no sistema de cor RGB.
18
2.3 Transformada discreta do cosseno
A transformada Discreta do Cosseno (DCT – Discrete Cosine Transform)
(AHMED, 1974) é uma operação matemática que não insere perda de dados na sua
aplicação. Sua aplicação no processamento digital de imagens é justificada por
conseguir identificar matematicamente a freqüência espacial de uma imagem, ou seja, a
taxa de variação de mudança de intensidade de cada pixel.
Partes da imagem que contenham concentração na variação da intensidade dos
pixels indicam um ponto com freqüências altas e áreas que apresentem valores
constantes ou muito próximos na intensidade dos pixels indicam a localização de
freqüências baixas.
A DCT constrói matematicamente uma matriz com os valores representantes das
intensidades de cada pixel e separa dentro dessa matriz as freqüências baixas, médias
e altas da imagem. A Figura 1 mostra a distribuição das freqüências em uma matriz
gerada pela DCT.
Figura 1 – Distribuição de freqüências em uma matriz de 8x8 pixels. Fonte: Autoria própria, 2007.
O olho humano percebe melhor as variações suaves nas mudanças das
intensidades dos pixels, ou seja, nas informações que fazem parte das freqüências
baixas (BRUNO, 2003).
19
A Figura 2 (a) mostra a imagem original Lena; a Figura 2 (b) exibe a cópia
restaurada da imagem Lena utilizando-se apenas o componente DC juntamente com os
9 primeiros coeficientes que fazem parte das baixas freqüências; a Figura 2 (c)
apresenta uma cópia restaurada da imagem Lena utilizando-se os 54 coeficientes
restantes que compõem as médias e altas freqüências da imagem, com os dez
primeiros estando zerados.
(a) (b)
(c)
Figura 2 – Diferença visual entre os coeficientes das freqüências de imagem. Fonte: Autoria própria, 2007. A vantagem de se utilizar a DCT é que ela consegue transformar um sinal no
domínio espaço, que nesse caso é uma imagem, para o domínio freqüência, onde
podemos encontrar a concentração da informação mais perceptível a nossa visão.
20
A primeira informação dessa matriz contém a média de todas as freqüências que
nela estão contidas. Esse valor é chamado de coeficiente DC. Os demais valores da
matriz são chamados de coeficientes AC.
A idéia é criar um vetor que contenha nas suas primeiras posições os valores
das freqüências mais baixas da imagem e nas últimas posições os valores das
freqüências mais altas. Para isso, é utilizado um método chamado Scan Zig-Zag (JACK,
2005) conforme mostra a Figura 3.
Figura 3 – Scan Zig-Zag em matriz de 8x8 pixels. Fonte: Adaptado de Salomon, 2004, p. 28.
O vetor gerado utilizando-se o Scan Zig-Zag, tem na sua primeira posição o
coeficiente DC da imagem na qual foi aplicada a DCT. Nas posições seguintes os
valores correspondentes às freqüências baixas, na seqüência os valores das
freqüências médias e nas últimas posições, os valores correspondentes às freqüências
altas. Dessa forma, apenas as primeiras posições desse vetor foram utilizadas, ou seja,
as informações mais significantes das imagens, tanto para o treino das RNAs, que será
abordado no capítulo 4, quanto para os testes realizados neste trabalho, que serão
descritos no capítulo 7.
21
3 QUANTIZAÇÃO
A quantização é a etapa, em um codificador de imagem, que responde pela
maior compressão de dados e pela degradação de qualidade da imagem original,
quando da sua decodificação (FERRAZ, 1998).
De acordo com (BRUNO, 2003), existem várias técnicas para se comprimir
dados através da quantização e que podem se divididas em duas categorias:
quantização escalar e quantização vetorial.
Nas duas seções deste capítulo, serão abordadas as técnicas de quantização
escalar e quantização vetorial respectivamente, onde serão descritas as suas principais
características.
3.1 Quantização escalar
Antes de ser apresentada a técnica de quantização vetorial, será abordada a sua
antecessora, a quantização escalar, que apesar de obter uma taxa de compressão
muito inferior, ainda é muito utilizada em função de ter um melhor desempenho em
termos de processamento computacional.
Na quantização escalar, os dados de entrada são tratados de forma
independente, gerando para cada informação de entrada uma informação de saída com
precisão menor (BRUNO, 2003).
A idéia básica de um quantizador escalar é substituir um determinado grupo de
valores de entrada por um índice. Cada índice representa uma aproximação dentro de
uma determinada escala.
22
No caso de quantizadores escalares uniformes, consegue-se gerar uma escala
de índices segmentando o valor máximo de entrada em faixas de tamanho fixo.
Para exemplificar, pode-se supor que a faixa de entrada de um quantizador
escalar esteja entre 0 - 255, então os dados de entrada poderiam ser representados por
8 bits (28=256). Se cada segmento de uma escala de aproximação comportar 4 valores,
então um valor de entrada igual a 2 será substituído pelo índice 1, pois o valor 2 faz
parte do primeiro segmento e o valor 122 que pertence ao trigésimo segmento,
receberá o índice de número 30. Como os 256 valores de entrada estão sendo
representados por 64 segmentos, então serão necessários apenas 6 bits (26=64) para
representar os valores de saída, conseguindo-se assim nesse caso, uma compressão
de 25% (SOBREIRO, 1998). A Figura 4 mostra um exemplo de segmentação em
quantização escalar.
Figura 4 – Segmentação em quantização escalar. Fonte: Adaptado de Bruno, 2003, p. 31.
Um outro exemplo poderia ser um termômetro digital que mostra em seu visor
temperaturas de -40° até 100° Celsius com um interv alo de 1° em 1°. É possível
imaginar que o termômetro será exposto a temperaturas que vão variar dentro de uma
escala bem menor, por exemplo: 12,16°, 21,57°, 32,9 8° Celsius, etc., mas sua saída
mostrará um valor aproximado dentro da escala do quantizador, por exemplo: 12°, 21° e
32° respectivamente.
23
Esta seção apresentou a quantização escalar mostrando como esse método
pode ser utilizado para se comprimir uma determinada informação. Na próxima seção,
será abordada a quantização vetorial, onde poderá ser percebida a grande vantagem
de sua utilização em relação à técnica de quantização escalar.
3.2 Quantização vetorial
A quantização vetorial pode ser considerada uma extensão da quantização
escalar, mas que ao invés de considerar cada elemento separadamente, esses são
agrupados em vetores (FLEURY, 2005).
Conforme Gersho
Um quantizador vetorial Q de dimensão k e tamanho N é um mapeamento de
de um vetor (ou um “ponto”) em um k - dimensional espaço Euclidiano, kR , dentro de um finito conjunto C contendo N saídas ou pontos de reprodução, chamados de codevectors ou codewords. Dessa forma CRQ k →: ,
onde C = (y1, y2, ..., yN) e yi ∈ kR para cada i ∈ ≡τ {1, 2, ..., N }. O conjunto C é chamado de codebook ou código e tem tamanho N , significando que tem
N elementos distintos, estando cada um desses vetores contidos em kR . (1991, p. 310).
A busca por baixas taxas de bits por pixel na codificação de imagens, levou ao
surgimento da quantização vetorial como uma nova técnica de compressão de dados.
Na compressão de imagem, utilizando-se quantização vetorial, essa é dividida
em várias partes ou células e o conteúdo de cada célula é atribuído às posições de um
vetor.
A idéia básica de um quantizador vetorial é criar um codebook que contenha um
número finito de vetores que irão representar todos os vetores das imagens de entrada
de um codificador. Cada vetor desse codebook, além de já terem seus valores
quantizados, ou seja, já sofreram uma DCT, também possuem um índice de
identificação.
24
Um codificador de imagem que utiliza a técnica de quantização vetorial para
compressão de dados tem a tarefa de identificar, para cada vetor de imagem de
entrada, o índice que endereça o vetor mais adequado para representar esse vetor de
entrada. Dessa forma, para cada vetor de entrada é identificado um índice
correspondente no codebook.
A escolha do codeword que vai representar o vetor de entrada é feita através do
cálculo do MSE entre o vetor de entrada e os vetores do codebook. O vetor do
codebook que apresentar o menor MSE será o escolhido pelo quantizador vetorial para
ter seu índice enviado ao decodificador.
A tarefa do decodificador é bem mais simples. Esse, que possui um codebook
idêntico ao codificador, ao receber os índices enviados pelo bloco de codificação, os
utiliza para endereçar seu codebook e acessar diretamente os vetores previamente
escolhidos pela etapa codificadora e, através deles, conseguir construir a imagem
original novamente, mesmo com alguma perda de qualidade.
A Figura 5 apresenta uma visualização das entradas e saídas dos blocos de
codificação e decodificação que utilizam a técnica de quantização vetorial para
compressão de imagem.
Figura 5 – Exemplo de entradas e saídas para compressão de imagens. Fonte: Adaptado de Gersho, 1991, p. 313.
A codificação, em relação à decodificação, é a etapa que responde pela maior
ocupação de processamento computacional, devido a quantidade de comparações e
cálculos matemáticos que necessitam ser realizados para se encontrar os índices dos
vetores do codebook que irão formar a imagem decodificada.
Em um codificador, uma das etapas comumente utilizada antes da quantização,
é a DCT, que entrega para a etapa posterior uma matriz formada por coeficientes,
25
resultantes da transformação das informações do domínio espaço para o domínio
freqüência da imagem que está sendo tratada.
Em vários codificadores a DCT é aplicada em blocos de 8x8 pixels, do início até
o fim da imagem. O quantizador vetorial gera para cada matriz de 8x8 um vetor de 64
posições (8x8=64). O codebook utilizado com a técnica de quantização vetorial, já
mencionado anteriormente, é formado por um conjunto de vetores de imagens, cada
um possuindo um índice de identificação. Esses vetores terão 64 posições se estiverem
sendo utilizados blocos de 8x8.
A quantização vetorial consegue uma alta taxa de compactação devido ao fato
de fornecer ao decodificador apenas os índices dos vetores do codebook que forem
escolhidos, ao invés de todas as 64 posições de cada vetor selecionado nesse banco
de vetores, pois o decodificador possui um codebook idêntico ao codificador.
Supondo que cada uma das informações das 64 posições de um determinado
vetor de entrada seja representada por um byte e cada índice do codebook seja
representado por 2 bytes, então nesse caso, para cada vetor de entrada serão enviados
ao decodificador apenas 2 bytes ao invés de 64 bytes. Isso representa uma
compressão de aproximadamente 97%.
Com um índice composto por 2 bytes, ou seja, 16 bits, pode-se ter um codebook
com 65536 vetores.
É importante salientar que o tamanho do codebook também influencia na
qualidade da imagem decodificada, pois seus vetores são utilizados para representar
todas as matrizes de 8x8 das imagens originais. Quanto maior a quantidade de vetores
em um codebook, maior a chance de um vetor de entrada encontrar um vetor mais
compatível, mas também será maior o custo computacional para realizar a pesquisa
nesse codebook.
Em quantização vetorial, o algoritmo mais eficiente em relação à qualidade da
imagem decodificada é o Full Search (GRAY, 1982). Isso se dá pelo fato de que para
um determinado vetor de entrada, ele executa uma pesquisa em todo o codebook para
encontrar o codeword com menor MSE. Sua desvantagem está no alto custo
computacional para realizar toda essa pesquisa.
26
O próximo capítulo apresenta uma visão geral sobre as RNAs, pois essa
tecnologia será utilizada em conjunto com a quantização vetorial para integrar a etapa
de compressão de dados em um codificador de imagem.
27
4 REDES NEURAIS ARTIFICIAIS
Baseadas no funcionamento dos neurônios do cérebro humano, as RNAs são
formadas por neurônios artificiais que podem ser conectados de várias maneiras e
formar uma ou várias camadas, dependendo do objetivo definido para uma determinada
rede (LUGER, 2004).
Um dos primeiros modelos de RNAs que surgiram foi chamado de rede
perceptron. Essa rede era formada por neurônios do tipo discriminadores lineares e
possuía a característica de aprender a responder com verdadeiro/falso ou 1/0. Essa
rede perceptron possuía mais de um neurônio que eram dispostos em camadas
(LUGER, 2004).
Uma RNA pode ser dividida basicamente em três camadas: camada de entrada,
camada oculta (que pode ser constituída por uma ou várias camadas) e camada de
saída. A conexão entre essas camadas se dá através da ligação entre os neurônios
dessas camadas. As conexões entre os neurônios são representadas por valores
numéricos e possuem pesos que são ajustados durante a fase de treinamento da rede
(LUGER, 2004). A Figura 6 mostra um exemplo de conexão entre neurônios.
Figura 6 - Exemplo de conexões entre neurônios. Fonte: Autoria própria, 2007.
28
Cada neurônio possui internamente uma expressão matemática que, juntamente
com os pesos de suas conexões, alteram seus valores de entrada para disponibilizá-los
em sua saída (LUGER, 2004).
Existem basicamente dois tipos de arquiteturas de RNAs: as feedforward e as
backpropagation, sendo a segunda arquitetura a mais utilizada, por ter a capacidade de
aprender complexos mapeamentos multidimensionais (NIELSEN, 1989).
Na arquitetura backpropagation, as unidades de uma camada retornam
informações de erro para as camadas anteriores, para que suas unidades possam se
ajustar na tentativa de minimizá-los. Dessa forma, a retro-propagação fornece uma
solução na tentativa de evitar que os erros se espalhem no interior da rede através das
camadas sucessivas (LUGER, 2004).
Em uma arquitetura feedforward nenhuma informação é retornada para as
camadas anteriores. O fluxo de dados é sempre no sentido da entrada para a saída, ou
seja, segue em uma única direção.
Outra característica de uma RNA, é que ela necessita ser treinada para que ela
aprenda como deve se comportar, ou seja, qual a saída que ela deve gerar de acordo
com as entradas que lhe são aplicadas. Esses ajustes são feitos de acordo com os
pesos que são atribuídos para cada conexão. A rede neural atinge seu aprendizado
quando ela consegue uma solução generalizada para uma classe de problemas. A
quantidade de vezes que se treina uma determinada RNA também é chamada de
época, em outras palavras, uma RNA que foi treinada 10000 vezes, diz-se que foi
treinada com 10000 épocas.
Existem duas formas de aprendizado: o supervisionado e o não-supervisionado.
No aprendizado supervisionado, a rede tenta resolver a ocorrência de um problema
através da observação de resultados que lhe são fornecidos externamente para que ela
modifique seus pesos para reduzir o erro. A repetição desse processo faz com que a
RNA consiga aprender qual o grupo de pesos que minimiza o erro médio sobre todo o
conjunto de treinamento.
Diferentemente, o aprendizado não-supervisionado não possui um agente que
lhe forneça os resultados desejados para os padrões de entrada, dessa forma, os
pesos são alterados como uma função dos valores de entrada e de saída do neurônio.
29
Uma grande vantagem das RNAs é o seu desempenho em termos de
processamento computacional, pois todos os neurônios processam suas entradas
simultânea e independentemente, conseguindo nesse sentido uma solução paralela e
distribuída para um determinado problema.
30
5 TRABALHOS RELACIONADOS
Este capítulo apresenta algumas pesquisas que foram realizadas em
quantização vetorial nos últimos anos, bem como uma amostra de trabalhos que
utilizaram RNAs nessa mesma área.
Neste capítulo também aparecem considerações desta pesquisa em relação a
alguns desses trabalhos relacionados a RNAs, com a intenção de se mostrar diferenças
positivas alcançadas.
5.1 Quantização vetorial
Muitas pesquisas em quantização vetorial foram realizadas na tentativa de se
conseguir maior velocidade na etapa de compressão, mas também buscando uma
qualidade de imagem decodificada próxima ao algoritmo FS (NASRABADI, 1988), (LIN;
SITARAM 1994), (ALPCAN, 1998), (SUDHIR, 1999), (CAO; PALIWAL; TSAI, 2000),
(LAI; YANG, 2004).
Nesta seção foram selecionados apenas alguns desses trabalhos para que se
possa ter uma idéia do que já foi desenvolvido, como por exemplo, o algoritmo de
Alpcan (1998) que explorou a técnica de decomposição em subbandas para
compressão de uma imagem e a existência da correlação de pixels horizontal e vertical
em cada sub-banda através da correlação dos coeficientes wavelets.
A decomposição inicial gera as subbandas low-low (LL), low-high (LH), high-low
(HL) e high-high (HH). Essa última é praticamente ignorada, pois possui a menor
representação de energia da imagem de entrada.
31
Os vetores de quantização são formados por blocos de imagem de 4x8 para a
sub-banda LH e 8x4 para a sub-banda HL. Para evitar a utilização de dois codebooks,
para uma das dimensões de sub-banda é feita uma transposição. Selecionando-se um
conjunto de codevectors apropriados, é possível utilizar um único codebook com
tamanho reduzido, pois se pode encontrar um codeword apropriado no sentido
horizontal ou vertical da imagem, conforme ilustração da Figura 7.
Para escolher o melhor codeword para cada bloco da imagem de entrada, esse
algoritmo verifica os coeficientes que representam a banda de baixa freqüência.
O PSNR resultante ficou em torno de 26,8 dB em relação aos 28,5 dB do Join
Photographic Experts Group (JPEG). Embora os resultados tenham mostrado uma
qualidade de imagem inferior ao padrão JPEG, a técnica de Alpcan (1998) apresentou
uma melhor distribuição dessa qualidade, com uma diferença média em torno de
0,0000611 dB.
Figura 7 - Semelhanças entre Subbandas. Fonte: Alpcan, 1998, p. 3.
Diferentemente, a idéia do algoritmo de Cao (2000) é armazenar o codebook
como um grafo direcionado ao invés de uma lista ou uma árvore como é feito em outras
técnicas de quantização vetorial. Um exemplo seria criar dois codebooks, um com
menos e outro com mais codewords.
Esses dois codebooks são particionados em duas regiões sobrepostas. Quando
um vetor de entrada chega para ser quantizado vetorialmente, primeiro é pesquisado no
codebook com menos codewords, quando for encontrado o codeword com menor MSE,
32
testam-se os outros codewords da região sobreposta a essa. Uma diferença básica do
grafo direcionado em relação às outras abordagens que utilizam estruturas em árvores,
é que os nodos filhos, que contém o codeword, podem ter mais de um "parente". Essa
idéia serve para um grafo direcionado com n codebooks C0, C1,..., Cm com
(N0<N1<...<Nm) codewords, respectivamente.
Para esse experimento foram utilizadas 16 imagens de 512x512 e um codebook
com 4096 codewords (12 bits). A Figura 8 mostra uma comparação em termos de
complexidade expressa em unidades de operações de pesquisa entre o algoritmo
Exhaustive Searching Vector Quantization (ESVQ) e o Algoritmo de Cao (2000).
O algoritmo de Cao (2000) apresentou uma degradação de 0,06 dB de PSNR
com um vetor de 16 posições e apenas 3% da complexidade do ESVQ.
Figura 8 - CplX versus Bit Rate. Fonte: Adaptado de Cao, 2000, p. 592.
Lai (2004) escolhe um codevector em um codebook avaliando as características
de valor médio, intensidade da borda e intensidade da textura da imagem, extraídas do
vetor de entrada.
Esse algoritmo utilizou blocos de imagem de 4x4 e codewords de 16 posições e
o codebook foi gerado utilizando a imagem Lena com resolução de 512x512 pixels.
Para o experimento, foram utilizados quatro codebooks com tamanhos de 128, 256, 512
e 1024 codewords e três imagens: Lena, Peppers e Baboon; todas com resolução de
512x512 pixels.
33
Os resultados obtidos por Lai (2004) apresentaram um número menor de
cálculos de distorção e um tempo de processamento menor que os algoritmos FS,
Equal-average Nearest-Neighbor Search (ENNS) e Dynamical Hyperplanes Shrinking
Search with three axes (DHSS3).
Yang (2004) desenvolveu um algoritmo que consegue melhorar a escolha do
codeword em relação ao vetor de entrada. O Variable-Branch Tree-Structured Vector
Quantization (VBTSVQ) aplica a técnica de quantização vetorial utilizando uma árvore
estruturada com expansão variável para armazenar o codebook.
Esse algoritmo também prevê um aumento do codebook de acordo com os
vetores de entrada e a procura pelo melhor codeword. Esse codebook é armazenado
em uma estrutura de árvore e seu aumento é maior em profundidade do que em
largura.
Quando um codebook é dividido em cluster, um determinado vetor de entrada
pode estar na região crítica de escolha entre um ou outro. Yang (2004) dividiu os
clusters em sub-regiões e, ao invés de verificar a relação do vetor de entrada com o
centro de cada cluster, o algoritmo avalia o vetor de entrada com o elemento da sub-
região mais próxima. Isso permite uma escolha mais precisa de qual cluster será
utilizado para buscar o codeword correspondente.
O algoritmo FS, por pesquisar todo o codebook, consegue encontrar o melhor
codeword para o decodificador, mas com um tempo de busca elevado. Em termos de
tempo de processamento, o VBTSVQ se mostrou mais eficiente que o algoritmo FS.
5.2 Rede neural artificial
A pesquisa de Sicuranza (1990) abordou a utilização de RNAs utilizando o
algoritmo de treino backprogapgation para a compressão de imagem.
Esse trabalho levou em consideração que se pode obter bom desempenho
utilizando-se RNAs para codificação de diferentes imagens, desde que elas possuam
propriedades estáticas locais semelhantes. Para imagens com essas propriedades
34
diferentes foi registrada perda de qualidade de imagem em torno de 10 dB na medida
PSNR.
A RNA desenvolvida por Sicuranza (1990) é uma perceptron com apenas uma
camada oculta. A quantidade de neurônios dessa camada são inferiores às quantidades
de neurônios das camadas de entrada e saída com a intenção de se conseguir
compressão. Essa RNA é composta por duas partes, sendo que a conexão ente elas se
dá através do meio de transmissão. Dessa forma, a entrada e a camada oculta estão no
codificador e a saída está no decodificador.
Nesse experimento foi utilizada a medida MSE para se verificar o erro entre a
entrada da RNA e sua saída. As imagens de entrada, que tinham resolução de 256x256
em escala de cinza, foram divididas em blocos de 8x8 pixels para que a RNA tivesse
um número pequeno de neurônios de entrada.
Foram utilizadas três RNAs com diferentes dimensões: 36 x 9 x 2, 25 x 6 x 2 e
16 x 4 x 2, onde os primeiros números, os intermediários e os últimos se referem às
quantidades de neurônios na entrada, na camada oculta e saída respectivamente.
Os resultados experimentais mostraram que a RNA com apenas 4 neurônios na
camada oculta apresentou uma medida de PSNR em torno de 20 dB, sendo esse o seu
limite de desempenho.
Os resultados iniciais deste trabalho mostram superioridade em relação à
qualidade da imagem restaurada pela RNA da proposta de Sicuranza (1990). Em seu
artigo, Sicuranza (1990) chegou a um limite de qualidade de imagem de 20,5 dB,
enquanto que nesta pesquisa, os resultados além de serem superiores (o primeiro
resultado que aparece na Figura 16 exibi uma qualidade de 25,66dB e o último
resultado apresentado na Figura 21, mostra uma qualidade de 27,70 dB), demonstram
que ainda é possível de serem melhorados com algumas alterações na RNA, como por
exemplo, utilizar uma RNA com um número maior de neurônios na camada oculta.
Carbonara (1992) utilizou RNAs para conseguir a geração do codebook de um
quantizador vetorial. Explorando o alto paralelismo intrínseco nesse tipo de arquitetura,
desenvolveu um quantizador vetorial adaptativo para ser empregado em aplicações de
tempo real. Um ótimo codebook está sempre sendo buscado e suas alterações são
posteriormente enviadas ao decodificador.
35
Para a compressão dos dados, Carbonara (1992) empregou a arquitetura
Differential Vector Quantization (DVQ) e para os testes foram utilizados codebooks com
tamanhos de 128 e 256 codewords. O algoritmo DVQ, utilizando RNAs, apresentou
25% mais compressão que um decodificador Differential Pulse Code Modulation
(DPCM) e também uma menor sensibilidade em transmissões em canais ruidosos.
A abordagem de Carbonara (1992) também é interessante no sentido de se
estar sempre buscando um codebook mais adequado, mas para isso é necessário o
envio de cada novo codebook ao decodificador. A utilização dessa proposta na internet,
por exemplo, vai acarretar em mais ocupação de banda e, quanto maior for esse
codebook e a freqüência de atualização, maior será essa ocupação.
O tamanho do codebook tem uma ralação diretamente proporcional à
possibilidade de se encontrar um codeword mais adequado para a informação de
entrada. Na abordagem deste trabalho, mesmo utilizando-se um codebook muito maior
que o da proposta de Carbonara (1992), esse já faria parte do decodificador, não sendo
necessário seu envio pelo codificador.
Kim (1995) utilizou um algoritmo de Self Organization Maps (SOM) utilizado em
RNAs não-supervisionadas para desenhar codebooks em quantização vetorial. Através
da alteração desse algoritmo, conseguiu reduzir a degradação das bordas da imagem
codificada. As bordas estão presentes em boa parte do conteúdo de uma imagem e a
redução de sua degradação melhora a qualidade visual da imagem.
Foi empregado um SOM de duas dimensões (32x64) e sub-blocos de imagem de
4x4 de 15 imagens diferentes para gerar o codebook. Para o teste foi utilizada a
imagem monocromática Lena de 512x512 pixels e um codebook com 2560 codewords.
Foi utilizado como medida para identificar as bordas, a variância entre os pixels dos
blocos de 4x4 da imagem.
Essa pesquisa mostrou que a geração do codebook utilizando um algoritmo SOM
chega mais rapidamente ao codebook definitivo em relação ao algoritmo Linde Buzo
Gray (LBG) (Linde, 1980) e também que é possível utilizar blocos de imagens mais
largos tornando a quantização vetorial mais eficiente.
Chu (1998) utilizou uma rede de perceptrons backpropagation para identificar o
codeword com menor distorção em relação à informação de entrada, na quantização
36
vetorial de sinal de áudio. Esse algoritmo identifica os codewords mais utilizados
através de um contador em cada um deles e com isso cria um sub codebook formado
por esses codewords.
A taxa de aprendizado da rede neural foi definida em 0,005, pois com 0,01 ela
apresentou instabilidade. Os resultados esperados foram alcançados em torno de 1000
iterações. Foi verificado também que conforme o codebook foi aumentado de tamanho,
sua distorção média diminuiu.
Através do artigo de Chu (1998), pôde-se avaliar o desempenho de três
esquemas de quantização utilizando RNAs, sendo que o Multistage apresentou
melhores resultados em relação ao Split e ao Tree-Structured Split, tanto em espaço de
armazenamento (tamanho do codebook), quanto em quantidade de operações de
busca pelo melhor codeword.
37
6 METODOLOGIA
Neste capítulo será apresentada a metodologia utilizada neste trabalho, bem
como alguns programas que foram desenvolvidos para auxiliar no desenvolvimento
deste estudo.
Como já comentado no capítulo anterior, existem várias pesquisas na área de
quantização vetorial que procuram diminuir o tempo de busca pelo codeword mais
adequado, mas essas pesquisas em comparação com o algoritmo FS, apresentam uma
qualidade inferior nas imagens decodificadas. Neste trabalho, o algoritmo FS foi
escolhido pela característica de ser o que gera a menor distorção na qualidade de
imagem durante o processo de codificação. Esta pesquisa buscou investigar como uma
RNA treinada se comportaria em comparação ao algoritmo FS em relação à qualidade
da imagem decodificada.
O software Matrix Laboratory (MATLAB), por possuir uma biblioteca para RNAs -
e também por já ter sido utilizado como ferramenta de apoio em outras pesquisas
(MARGRAVE, 1995), (JOST; SANGHAMITRA, 2005) - foi o programa escolhido para
gerar, treinar e analisar o comportamento da RNA, na escolha dos codewords
compatíveis com os vetores de imagem de entrada.
A RNA perceptron, que já foi utilizada em algumas pesquisas tais como
(SICURANZA, 1990), (BOSE, 1993), (CHU, 1998), (MARTINS, 2006) e, também por
adequar-se aos testes propostos, foi a rede escolhida para este trabalho.
Durante a disciplina de Trabalho de Conclusão de Curso, foi desenvolvido um
programa em linguagem C para simulação do algoritmo FS, com o propósito de permitir
observações mais precisas das escolhas dos codewords do codebook por esse
algoritmo. Uma observação exata dos vetores escolhidos pelo algoritmo FS se fez
necessária, pois esses resultados foram utilizados para os treinos das RNAs.
38
Embora tenham sido utilizados dois ambientes para os testes realizados
(MATLAB e Linguagem C), os resultados não sofreram influência por essa razão, pois
as análises foram realizadas fazendo-se uma comparação entre as imagens originais
de entrada e sua resultante decodificada, tanto para a RNA desenvolvida na ferramenta
MATLAB, quanto para o algoritmo FS desenvolvido em linguagem C.
Todos os testes foram realizados em um microcomputador com processador
Pentium 4, dual core, 3,4 GHz e 2GB de memória do tipo Random Access Memory
(RAM). Foram utilizados dois sistemas operacionais: o Windows XP, para rodar o
software MATLAB e o Linux Ubuntu kernel 2.6.15-23-386, para os testes de tempo de
execução entre a RNA e o algoritmo FS. Os testes de tempo de execução foram
realizados no sistema operacional Linux por ter sido utilizado para essa medição uma
RNA construída em linguagem C, a Fast Artificial Neural Network (FANN) (GOOGLE
SUMMER OF CODE, 2007), que possui bibliotecas para Linux. Isso foi feito para não se
medir o tempo de uma RNA que estava executando dentro de uma ferramenta
(MATLAB), pois isso poderia comprometer o resultado.
Para atingir os objetivos apresentados neste trabalho, foi realizado um
experimento, que é descrito a seguir e que trata da realização dos testes entre o
algoritmo FS e uma RNA implementada pela ferramenta MATLAB 7.0. A Figura 9 serve
para apoiar o entendimento deste experimento.
Início
Criar codebookutilizando MATLAB
Treinar RNA
Entrar com as imagens de
teste na RNA
Entrar com as imagens de
teste no algoritmo FS
Calcular PSNR
Comparar PSNR
Fim
Entrar com imagens de
treino na rede neural artificial
Testar RNATestar
algoritmo FS
Entrar com imagens de
treino no algoritmo FS
Verificar os vetores
escolhidos pelo FS
Concluir
Figura 9 – Fluxo do experimento. Fonte: Autoria própria, 2007.
39
Todas as imagens envolvidas neste experimento eram coloridas, do tipo Join
Photographic Group (JPG) e com resolução de 320x240 pixels, de onde foi extraído o
componente Y de cada uma para os testes (FOWLER, 2000); todos os programas
desenvolvidos para este trabalho foram elaborados utilizando-se a linguagem C do
American National Standards Institute (ANSI C); como métrica de avaliação dos
resultados de qualidade de imagem utilizou-se a medida PSNR entre as imagens
originais e as imagens de teste, para se verificar o erro de codificação entre o algoritmo
FS e uma RNA treinada.
6.1 Programa de criação do c odebook
Primeiramente foi gerado um codebook provisório baseado em nove imagens,
conforme ANEXO A, com diferentes tipos de conteúdo, buscando abranger algumas
diferentes possibilidades de informação de entrada como paisagem, imagem humana e
desenho.
Esse codebook provisório foi gerado aproveitando-se a ferramenta MATLAB 7.0
por ela já possuir uma biblioteca que gera o componente Y a partir de uma imagem
formada por RGB e também executa a DCT que gerou os coeficientes que formaram o
conteúdo dos vetores desse codebook.
A DCT disponibiliza no MATLAB um arquivo com os coeficientes das imagens
em blocos de 8x8, onde o primeiro elemento de cada bloco é o seu coeficiente DC.
Esse coeficiente pode ser facilmente identificado por ser a informação com maior valor
numérico. A Figura 10 mostra como ficam organizados os coeficientes das imagens, e é
possível notar a posição do coeficiente DC de cada bloco. Como a resolução utilizada é
de 320x240, acabou resultando em um arquivo com 40 blocos de 8x8 coeficientes na
horizontal e 30 blocos de 8x8 coeficientes na vertical.
40
Figura 10 – Blocos iniciais da imagem Lena. Fonte: Autoria própria, 2007. A Figura 10 mostra os valores originais dos coeficientes de alguns blocos da
imagem Lena. Mas para este trabalho, buscando evitar erros de arredondamento no
momento da leitura dos arquivos-texto dos coeficientes das imagens e posterior
transformação dos caracteres para tipo float dentro dos programas elaborados foi
necessário retirar os pontos decimais dos números, transformando-os em números
inteiros. Também foram utilizadas apenas duas casas decimais para que a RNA
pudesse trabalhar com menos informação.
Como exemplo, o primeiro coeficiente do bloco 1 da Figura 10 ficou com valor de
332 ao invés de 3,324500. Essa estratégia foi utilizada apenas para a manipulação
desses dados dentro dos programas elaborados neste trabalho, porque para o treino da
RNA eles eram novamente retornados para a forma decimal.
Como o formato dos dados entregues pela DCT não foi adequado à formação do
codebook, ou seja, os dados estavam separados em blocos e também não estavam
ordenados, foi elaborado um programa para extrair e organizar as informações de cada
bloco na forma de vetores, para que posteriormente esses vetores pudessem ser
utilizados no codebook.
41
As nove imagens utilizadas para gerar o codebook provisório, cada uma sendo
formada por 1200 vetores, resultou em um primeiro momento num codebook com
10800 vetores (9x1200=10800).
A próxima tarefa realizada identificou os vetores idênticos, ou seja, os vetores
que continham os mesmos valores em todas as suas posições e que não precisavam
estar presentes no codebook.
Esses vetores foram marcados substituindo-se o valor de seus coeficientes DC
por um outro bem superior a 800, que seria o valor máximo nessa posição gerado pela
DCT depois de ser transformado para inteiro. Dessa forma, no passo seguinte onde
organizou-se todos esses vetores do codebook provisório em ordem crescente (essa
ordenação foi realizada comparando-se as primeiras 25 posições de cada vetor), esses
vetores foram deslocados para as últimas posições para serem excluídos
posteriormente, pois seriam aproveitados somente os primeiros 10000.
A razão de se aproveitar os primeiros 10000 vetores foi apenas para se ter um
número redondo nas fórmulas de normalização que são mostradas em (4) e (5) na
seção 7.2; e também porque não faria muita diferença manter os 800 vetores restantes
nesse momento, levando-se em conta que seriam realizados testes com um codebook
com 20000 vetores, conforme mostrado no capítulo 7, seção 7.1.
O próximo passo realizado na seqüência, foi a transferência dos 10000 primeiros
vetores para um novo codebook. Esse novo codebook, formado por apenas 10000
vetores (que depois de todas as alterações necessárias, seria o definitivo), ficou em sua
primeira posição com o vetor correspondente à cor preta, pelo fato dos vetores estarem
ordenados em ordem crescente. Esse vetor possui em todas as suas posições o valor
zero. Isso acontece porque após a aplicação da DCT em uma imagem, as cores são
representadas por valores numéricos, onde a cor preta possui o menor valor e a cor
branca, que seria o outro extremo dessa representação, possui o maior valor.
Para se manter nos dois extremos as representações de mínimo e máximo dos
tons de cinza, na última posição do codebook foi colocado o vetor correspondente à cor
branca. Esse vetor tem na sua primeira posição, ou seja, na posição referente ao
componente DC, o valor 800 e em todas as suas outras posições, o valor zero.
42
Para que esse codebook tivesse valores que variassem mais linearmente entre a
cor preta e a cor branca, ou seja, o coeficiente DC dos vetores variando de 0 a 800, e
também para melhor atender as diferentes imagens que ele iria representar, alguns
vetores tiveram que ser substituídos. Para isso, foram utilizados alguns vetores que
estavam entre as posições 10001 e 10800 e que não iriam ser aproveitados. Essa
substituição foi necessária, pois se verificou após o codebook ter sido criado, que o
último vetor antes do de cor branca que foi inserido manualmente, tinha um coeficiente
DC com valor em torno de 700. Então foram inseridos no codebook alguns vetores com
coeficientes DC entre 701 e 799 e retirado alguns vetores com coeficiente DC com
valores entre 1 e 700.
Para melhor adequar o range da RNA às fórmulas de normalização, que serão
descritas na seção seguinte, o codebook foi carregado, dentro deste programa, em uma
matriz a partir da posição 1, ignorando-se a posição zero.
Esse codebook, já com as alterações, foi o mesmo, tanto para os testes do
algoritmo FS, quanto para os testes da RNA e continha 10000 vetores, cada um com 64
posições.
6.2 Algoritmo FS
A principal função do algoritmo FS desenvolvido para este trabalho, foi a
verificação exata das escolhas dos vetores do codebook para cada vetor de imagem
que era aplicado em sua entrada. Os resultados analisados pelo algoritmo FS foram
armazenados e utilizados na fase de treinamento da RNA.
A tarefa realizada pelo algoritmo FS é a identificação do vetor do codebook com
menor MSE em relação a um vetor de imagem de entrada. Através da fórmula do MSE
definida em (3) (LINDE, 1980), onde ix representa a posição de um determinado vetor
de entrada, ix̂ representa a posição do codeword do codebook que está sendo testado
em um determinado momento e k é o tamanho desses vetores; todas as posições
desses vetores foram calculadas e o valor resultante foi armazenado em uma variável
43
de erro de MSE. Da mesma forma, uma outra variável foi definida para armazenar o
índice do codeword que resultou o menor MSE.
Para cada vetor de entrada, foi executada uma busca em todo o codebook
aplicando-se esse cálculo. Quando algum codeword resultou em um valor de MSE
menor que o armazenado na variável de erro, o valor dessa variável foi substituído e o
índice desse codeword foi salvo. Sendo assim, no final de cada busca, pôde-se
identificar o codeword mais compatível para cada vetor de entrada.
∑−
=
−=1
0
2|ˆ|)ˆ,(k
iii xxxxd
(3)
Através do algoritmo FS foi possível verificar para cada vetor de uma
determinada imagem, qual era o índice correspondente do codebook que continha um
codeword com menor erro. Para armazenar essas informações, foi previsto no próprio
algoritmo FS uma rotina para juntar todos esses resultados em um arquivo, para que
pudessem ser utilizados posteriormente no treino da RNA. Mas antes do efetivo
armazenamento dos índices e vetores do codebook escolhidos pelo algoritmo FS, foi
preciso ser feita uma modificação na representação desses índices, conforme
explicação que segue.
A modificação na representação dos índices escolhidos pelo algoritmo FS
ocorreu devido ao fato de que o range de entrada e saída da RNA utilizada no MATLAB
era de -1 até 1, e o range de endereçamento do codebook era de 1 até 10000. Para
solucionar esse problema, foi necessária a aplicação de uma função de normalização
para se evitar que valores negativos de saída na RNA endereçassem o codebook.
Como mencionado anteriormente, a saída da RNA é o próprio índice para o
codebook e não se pode endereçar uma matriz utilizando números negativos
diretamente. Então, para se transformar os índices escolhidos pelo algoritmo FS, que
podiam variar de 1 até 10000 em uma variação de -1 até 1, foi criada a função de
normalização que está definida em (4), onde eI refere-se ao índice escolhido pelo
algoritmo FS e rI ao índice que será utilizado para o treino supervisionado da RNA.
44
−=5000
5000er
II (4)
Para a operação inversa, ou seja, quando a RNA disponibilizava em sua saída os
índices escolhidos para uma determinada imagem de entrada, também foi necessária a
criação de uma função de normalização que alterasse o range de -1 até 1 da saída da
RNA para o range de endereçamento do codebook que é de 1 até 10000. Essa função
esta definida em (5), onde sI refere-se ao índice escolhido pela RNA e cI ao índice
correspondente que será utilizado para endereçar um vetor no codebook.
50005000+×= sc II (5)
Também foi previsto no algoritmo FS que as posições dos vetores das imagens
que foram aplicadas na RNA, tanto para treino como para os testes, já estivessem no
modo Scan Zig-Zag, para se extrair desses vetores somente as informações de baixa
freqüência, ou seja, as informações mais significantes das imagens. A razão de se
aplicar esse método é que não se utilizou para os treinos e testes todas as 64 posições
dos vetores das imagens, fazendo-se necessário utilizar alguma estratégia que
identificasse essas informações dentro dos vetores das imagens. Dessa forma, o
arquivo disponibilizado pelo algoritmo FS já estava totalmente de acordo com as
condições adequadas para servir de entrada da RNA, tanto para os treinos quanto para
os testes.
Como foi informado anteriormente, o algoritmo FS gera um arquivo no formato
texto com os vetores das imagens, já com a quantidade de posições ajustadas para a
quantidade de entrada da RNA e no modo Scan Zig-Zag. Também foi mencionado que
os valores manipulados dentro dos programas eram do tipo inteiro, com valores de
coeficientes DC podendo variar entre 0 e 800. Para que esses valores se adequassem
à entrada da RNA, em função de seu range estar entre -1 até 1, todos esses valores
contidos nas posições dos vetores de imagens foram divididos por 1000 antes de serem
gravados no arquivo gerado pelo algoritmo FS. Dessa forma, como exemplo, os valores
inteiros dos coeficientes DC que variavam de 0 a 800, passaram a variar de 0 a 0,8.
45
6.3 Programa de restauração de imagem
A idéia básica deste trabalho é definir para cada vetor de uma determinada
imagem de entrada um índice que será disponibilizado ou enviado ao sistema
decodificador para que essa imagem seja restaurada. Uma das tarefas deste sistema
decodificador é receber esse índice, e através dele identificar em seu codebook o vetor
correspondente. Nesse codebook, que é idêntico ao existente na etapa de codificação,
existe um número finito de vetores com a intenção de representar todos os possíveis
vetores das imagens codificadas.
As informações de saída do algoritmo FS, bem como as informações de saída da
RNA, são justamente os índices para endereçar os vetores do codebook da etapa de
decodificação.
No MATLAB, os índices escolhidos pela RNA eram disponibilizados em uma
janela dessa ferramenta. Esses índices eram então copiados para um arquivo texto que
posteriormente era aberto e manipulado pelo algoritmo de restauração de imagem, que
foi construído com a finalidade de restaurar as imagens codificadas.
No algoritmo FS desenvolvido neste trabalho, uma de suas saídas era um
arquivo texto que continha os índices escolhidos. Da mesma forma, para se restaurar
uma imagem utilizando-se os índices escolhidos pelo algoritmo FS, copiavam-se eles
para o mesmo arquivo que seria utilizado no algoritmo de restauração de imagem.
Os índices escolhidos correspondem a vetores de imagens e precisam ser
colocados na forma adequada para se visualizar uma imagem novamente.
Para que a ferramenta MATLAB pudesse aplicar as funções reversas utilizadas
para o processamento das imagens e com isso ser possível visualizá-las novamente, foi
necessário colocar as 64 informações de cada vetor selecionado pelos índices na forma
de blocos de 8x8, pois foi assim que a ferramenta MATLAB, após a aplicação da DCT,
disponibilizou as imagens utilizadas nesta pesquisa.
A saída do algoritmo de restauração de imagem era então um arquivo texto
muito semelhante ao apresentado na Figura 10, mas com os valores correspondendo
às imagens que estavam sendo decodificadas.
46
Os dados desse arquivo eram copiados para dentro de uma variável do
MATLAB, que por meio de uma de suas funções exibia as imagens novamente em sua
forma original (utilizou-se apenas o componente Y) para que pudessem ser
visualizadas.
O arquivo gerado por esse programa, deixando as informações dos vetores do
codebook escolhidos na forma de blocos de 8x8, também serviram para os testes
objetivos com a medida PSNR, pois as imagens originais também sofreram as
alterações da DCT pela ferramenta MATLAB e acabaram se transformando em
arquivos na forma demonstrada na Figura 10.
A medida PSNR compara cada pixel da imagem original com o pixel
correspondente da imagem restaurada, ou seja, o pixel 1 da imagem original com o
pixel 1 da imagem restaurada, o pixel 2 da imagem original com o pixel 2 da imagem
restaurada, etc. Isso acontece sucessivamente até que todos os pixels dessas duas
imagens tenham sido testados. Por essa razão, fez-se necessário a organização das
posições dos vetores escolhidos para a mesma estrutura da imagem original que
também foi tratada pela ferramenta MATLAB.
6.4 Programa para teste do PSNR
Para se realizar os testes objetivos envolvendo as imagens utilizadas nesta
pesquisa, foi escolhida a medida PSNR de acordo com o que já foi mencionado
anteriormente. Essa medida, que é descrita nesta seção, permite se verificar a
qualidade de uma determinada imagem em relação a sua original.
A medida PSNR está definida conforme fórmula (6) (JUNIOR, 1993), onde m
representa o valor de pico da imagem original. Em geral, m tem valor igual a 255, pois
normalmente são utilizados oito bits para representar um pixel de imagem (JUNIOR,
1993).
])(
log[102
MSE
mPSNR= (6)
47
O MSE para essa fórmula é descrito em (7) (JUNIOR, 1993), onde M x N é a
dimensão das imagens que estão sendo testadas, ijµ representa uma determinada
posição de um vetor da imagem original, 'ijµ representa uma determinada posição de
um vetor da imagem decodificada.
( ) ( )∑∑= =
−=N
i
M
jijijMN
MSE1 1
2'
.
1 µµ (7)
Uma comparação objetiva se faz necessária pelo fato de que a visão humana
pode ser susceptível a erros. Por exemplo, pode se imaginar uma foto onde apareça o
rosto de uma pessoa bem de perto e onde o fundo, que representa a maior parte da
informação dessa imagem, esteja todo fora de foco. Essa mesma imagem seria
codificada e decodificada utilizando-se dois sistemas distintos. Um deles poderia
mostrar no resultado uma imagem onde o rosto estaria com uma aparência boa, mas o
resto da imagem, que está fora de foco, bem ruim. O outro sistema poderia mostrar a
imagem desse rosto com uma pequena distorção, mas o restante da imagem estaria
mais fiel à imagem original.
Dessa forma, a imagem restaurada pelo primeiro sistema poderia ter em sua
totalidade uma qualidade inferior à imagem restaurada pelo segundo, mas para a visão
humana, a imagem decodificada pelo primeiro sistema seria melhor. Para evitar esse
tipo de erro, é necessária a utilização de uma ferramenta que verifique, nesse caso,
pixel por pixel da imagem. Dessa maneira, teremos um resultado mais exato para se
avaliar qual é o melhor sistema.
Com a finalidade de se aplicar essa verificação, foi desenvolvido um programa
que permitisse a manipulação de dois arquivos de imagens (uma original e sua cópia
restaurada), realizasse o cálculo PSNR conforme descrito em (6) e devolvesse o
resultado desse cálculo.
Um dos arquivos tratados neste programa era o arquivo original de uma imagem
qualquer de onde se retirou apenas o componente Y, conforme exemplo que pode ser
48
observado na Figura 14. O outro arquivo, com que este programa lidou para o teste
com sua imagem original, era o fornecido pelo algoritmo de restauração de imagem,
conforme descrito na seção 7.3. Como as informações desse arquivo eram dispostas no
mesmo formato das disponibilizadas pela DCT, então o componente Y dessa imagem
original também sofreu uma DCT antes de ser aplicado o teste.
Através da utilização deste programa, foi possível se obter de maneira prática os
valores de PSNR das imagens restauradas em relação as suas originais, e com isso
também os resultados objetivos de qualidade das imagens restauradas, tanto pelo
algoritmo FS, quanto pelas RNAs.
49
7 TESTES E RESULTADOS
Neste capítulo serão apresentados os testes realizados, bem como seus
respectivos resultados. A Tabela 2 exibe uma síntese dos testes realizados e que serão
detalhados nas seções que seguem.
Tabela 2: Resumo dos testes realizados.
Seção e
subseção
do Teste
Tamanho do
codebook
Quantidade
de imagens
de treino
Teste de
processamento
Quantidade
de RNAs
7.1 10000 1 X 1
7.1 20000 1 X 1
7.2.1 10000 1 - 1
7.2.2 10000 2 - 1
7.2.2 10000 3 - 1
7.2.2 10000 4 - 1
7.2.2 10000 5 - 1
7.2.3 1000 1 - 1
7.2.4 10000 4 x 1/4 - 4
Fonte: Autoria própria, 2007.
Todos os treinos das RNAs foram efetuados utilizando-se 10000 épocas, pois acima dessa quantidade não se observou uma diminuição significativa do erro de convergência das RNA.
50
7.1 Teste de tempo de processamento
Para se realizar a comparação de tempo de processamento entre o algoritmo FS
e uma RNA, utilizou-se o sistema operacional Linux, pois como já foi comentado no
início do capítulo 6, para este teste foi aproveitada uma RNA desenvolvida em
linguagem C, a FANN (GOOGLE SUMMER OF CODE, 2007), e que possuía bibliotecas
para esse sistema operacional.
Este teste teve o objetivo de se descobrir qual o tempo necessário para o
algoritmo FS codificar uma determinada imagem e também o tempo de codificação
dessa mesma imagem por uma RNA. A medida do tempo de execução do algoritmo FS
foi realizada 5 vezes (uma após a outra), apresentando sempre o mesmo resultado. A
Tabela 3 apresenta o resultado (em segundos) da comparação entre o tempo de
codificação do algoritmo FS e uma RNA com 10 neurônios de entrada, 10 neurônios na
camada interna e 1 neurônio de saída, para um codebook com 10000 vetores.
Tabela 3: Tempo de execução para codebook com 10000 vetores.
FS RNA
Tempo de
execução 6,79 0,01
Fonte: Autoria própria, 2007.
Como já mencionado anteriormente, um codebook contém codewords que irão
representar os vetores das imagens de entrada na etapa de codificação. Então uma
dedução natural é se pensar que quanto maior esse codebook, maior a quantidade de
vetores que serão representados, mas também, mais comparações terão que ser
realizadas pelo algoritmo FS.
Com a intenção de se investigar o comportamento dessas duas propostas
(algoritmo FS e RNA) em relação ao tamanho de codebook, realizou-se outro teste de
tempo de execução entre o algoritmo FS e uma RNA.
Para essa experiência, utilizou-se uma RNA com as mesmas características da
utilizada no teste anterior. O único parâmetro alterado foi o tamanho do codebook, que
51
continha 20000 vetores, ou seja, o dobro de vetores do codebook utilizado
anteriormente, mas com as mesmas características. Essa medida do tempo de
execução do algoritmo FS também foi realizada 5 vezes (uma após a outra), e também
apresentou sempre o mesmo resultado. Os resultados dessa experiência (expressos
em segundos) são demonstrados na Tabela 4.
Tabela 4: Tempo de execução para codebook com 20000 vetores.
FS RNA
Tempo de
execução 11,35 0,01
Fonte: Autoria própria, 2007.
Pode-se observar que, embora o codebook utilizado para o teste da Tabela 4
tivesse o dobro do tamanho do codebook do teste da Tabela 3, o tempo que essa RNA
necessitou para identificar os índices da imagem de entrada, foi exatamente o mesmo
utilizado pela RNA do teste anterior.
Esse resultado demonstra que o paralelismo intrínseco na arquitetura das RNAs,
é uma característica muito vantajosa na aplicação dessa tecnologia, em termos de
velocidade de processamento, para compressão de dados juntamente com a técnica de
quantização vetorial.
De forma diferente, e até demonstrando perda de desempenho, se comportou o
algoritmo FS, que por ter que efetuar o dobro de comparações, acabou necessitando de
mais tempo para encontrar os índices correspondentes aos vetores da imagem que se
queria codificar.
Mesmo no teste anterior, já foi possível verificar que para um vídeo com 30
quadros por segundo e com resolução de 320x240, o algoritmo FS não poderia ser
utilizado, pois ele precisou de 6,79s para codificar apenas uma imagem.
52
7.2 Treino da RNA, testes e resultados
Os testes e resultados desta seção estão divididos em subseções para permitir
uma melhor visualização do que foi realizado e também para proporcionar um acesso
mais rápido a essas informações.
A imagem Lena (Figura 14) utilizada nos testes não fez parte das imagens
utilizadas para formar o codebook e nem foi utilizada nas etapas de treino das RNAs.
Todos os testes apresentados nas subseções que integram esta seção foram
realizados utilizando-se a função de treinamento TRAINLM, função de adaptação de
aprendizado LEARNGDM e função de transferência TANSIG, conforme mostrado na
Figura 11. Esses parâmetros que foram utilizados para se criar as RNAs, e mesmo os
outros que aparecem na tabela do APÊNDICE A, são explicados na seção de ajuda da
ferramenta MATLAB 7.0.
Figura 11 – Parâmetros iniciais da RNA. Fonte: Autoria própria, 2007.
Esses parâmetros foram utilizados pelo fato de terem apresentado melhores
resultados, principalmente em relação ao erro de convergência, de acordo com os
53
dados disponibilizados na tabela do APÊNDICE A. Um erro de convergência menor
tende a tornar mais homogêneo os resultados para um número maior de imagens de
entrada. A função de desempenho MSE foi escolhida pela razão do algoritmo FS
também utilizar essa métrica para escolha dos vetores do codebook. Os parâmetros
default, disponibilizados pela ferramenta MATLAB para treino das RNAs, foram os
utilizados para se treinar as RNAs desenvolvidas para os testes.
As RNAs utilizadas neste trabalho foram criadas com apenas 10 neurônios na
camada de entrada e não com 64 neurônios, conforme quantidade de posições dos
vetores de imagens. Uma razão da escolha de RNAs com apenas 10 neurônios de
entrada, é porque como pode ser observado na seção 2.3, são nas primeiras posições
dos vetores das imagens que estão os valores mais significativos da imagem, ou seja,
as informações das freqüências mais baixas e que são melhores percebidas pelo olho
humano. Como pôde ser verificado na Figura 2 (b), ela foi mostrada utilizando-se
apenas as 10 primeiras informações dos vetores correspondentes à faixa de
freqüências baixa da imagem e a Figura 2 (c) utilizando-se as outras 54 posições
restantes dos vetores da imagem. A escolha das posições dos vetores buscando-se
apenas as informações desejadas foi realizada utilizando-se o método Scan Zig-Zag.
Uma outra razão para essa definição de quantidade de neurônios de entrada é
que a quantidade de neurônios na RNA tem uma relação exponencial com o tempo de
treinamento. Com 64 neurônios de entrada na RNA, o tempo necessário para cada
treino monopolizaria o microcomputador utilizado, tornando essa prática inviável, mas
com apenas 10 neurônios foi possível diminuir o tempo ocupado com os treinos e, por
estarmos utilizando o método Scan Zig-Zag, foi possível se conseguir valores
expressivos nos resultados.
Para se avaliar objetivamente os resultados, utilizou-se a medida PSNR que
possibilita uma comparação objetiva de qualidade entre duas imagens. Dessa forma, foi
possível ser verificado o erro de quantização entre o algoritmo FS e a RNA.
54
7.2.1 Teste – 1200 vetores de treino e codebook com 10000 vetores
Primeiramente, foi criada no MATLAB uma RNA com 10 neurônios de entrada,
10 neurônios na camada oculta e um neurônio de saída, conforme Figura 12.
Figura 12 – Arquitetura da RNA. Fonte: Adaptado da ferramenta MATLAB.
Essa RNA foi treinada utilizando-se apenas uma imagem (1200 vetores de
treino) conforme mostra o ANEXO B. Também foram utilizadas 10000 épocas para esse
treino e, embora o erro de convergência da RNA pretendido fosse de zero, ou seja, a
RNA escolheria os mesmos índices que o algoritmo FS, com essa quantidade de
épocas e arquitetura, foi alcançado apenas o valor 0,00119839. A Figura 13 apresenta
os pesos das conexões entre os neurônios da RNA após a etapa de treinamento.
Figura 13 – Pesos da RNA após treinamento. Fonte: Adaptado da ferramenta MATLAB.
Após o treinamento, a imagem Lena da Figura 14 foi aplicada à RNA e também
ao algoritmo FS para ser quantizada. As duas imagens quantizadas, uma pelo algoritmo
FS e outra pela RNA, já com seus novos coeficientes, foram reconstruídas pelo
55
MATLAB para que se pudesse ter uma avaliação subjetiva dos resultados. Isso foi feito
aproveitando-se o arquivo gerado pelo programa de restauração de imagem, conforme
descrito na seção 7.3.
As Figuras 15 e 16 mostram respectivamente a imagem restaurada pelo
algoritmo FS e pela RNA com seus respectivos PSNR. O Gráfico da Figura 17 também
mostra a diferença de qualidade entre as imagens restauradas para este teste.
Figura 14 – Imagem Lena utilizada no teste. Fonte: Autoria própria, 2007.
Figura 15 – Imagem Lena restaurada pelo algoritmo FS: 33,74 dB. Fonte: Autoria própria, 2007.
56
Figura 16 – Imagem Lena restaurada pela RNA: 25,66 dB. Fonte: Autoria própria, 2007.
0
5
10
15
20
25
30
35
40
1 2
FS RNA
PS
NR
Figura 17 – Diferença de PSNR entre o algoritmo FS e a RNA. Fonte: Autoria própria, 2007.
7.2.2 Teste – variação de imagens de treino para um codebook com 10000 vetores
Nesta subseção são apresentados os resultados de cinco variações de treinos
de RNAs. Esses testes tiveram o objetivo de verificar se a quantidade de imagens de
treino poderia influenciar no desempenho da RNA.
57
Dependendo do tipo de teste, é necessário se criar uma nova RNA, pois quando
uma RNA é treinada, ela adquire algumas características próprias, como a distribuição
dos pesos de suas conexões internas. Neste caso, para se verificar o comportamento
de uma RNA variando-se a quantidade de imagens em seu treino, criou-se uma nova
RNA para cada um dos testes. A Tabela 5 e a Figura 18 apresentam os resultados dos
testes realizados variando-se a quantidade de imagens/vetores utilizados nos treinos
das RNAs. Os resultados subjetivos deste teste estão disponíveis no APÊNDICE C.
Tabela 5: Variação da quantidade de treinos.
Quantidade
de Imagens
Erro de
Convergência PSNR
1 0,00119839 25,66
2 0,00119910 25,87
3 0,00110834 25,90
4 0,00146434 25,84
5 0,00159801 25,75
Fonte: Autoria própria, 2007.
25,5
25,55
25,6
25,65
25,7
25,75
25,8
25,85
25,9
25,95
1 2 3 4 5
Treinos
PS
NR
Figura 18 – Gráfico PSNR versus quantidade de treinos. Fonte: Autoria própria, 2007.
58
Através da visualização da Tabela 5 e da Figura 18, é possível perceber que
ocorreu um progresso na qualidade das imagens decodificadas quando utilizou-se até
três imagens nos treinos. Isso aconteceu porque a RNA teve mais informações durante
seu treino para aprender a fazer melhor a relação entre vetor de entrada e índice de
saída. Essa quantidade de vetores serviu como reforço durante a etapa de treino.
A quantidade de três imagens de treino corresponde a 3600 vetores, cada um
contendo 10 posições, aplicados na entrada da RNA. Acima dessa quantidade, a
qualidade começou a diminuir porque ocorreu uma quantidade de informação muito
grande para a RNA tratar, tendo apenas 10 neurônios na camada oculta. Como pode
ser verificado na Figura 13, os pesos internos dessa RNA são apenas 100 (10
neurônios de entrada conectados com 10 neurônios na camada oculta), para essa
arquitetura utilizada. Chega um ponto em que a quantidade de pesos não é suficiente
para se ajustar a um número muito alto de informação.
Observando-se a Tabela 5 é possível perceber que o erro de convergência
também tem uma relação direta com a qualidade da imagem, conforme pode ser
verificado na Figura 19.
25,5
25,55
25,6
25,65
25,7
25,75
25,8
25,85
25,9
25,95
0,00110834 0,00119839 0,0011991 0,00146434 0,00159801
Erro de Convergência
PS
NR
Figura 19 – Gráfico PSNR versus erro de convergência. Fonte: Autoria própria, 2007.
59
A Figura 19 mostra que quanto maior o erro de convergência, menor é a medida
de PSNR, ou seja, a qualidade da imagem restaurada diminui. Embora o gráfico da
Figura 19 apresente uma anomalia no segundo ponto, e isso pode estar relacionado
com a qualidade dos vetores que formaram a segunda imagem utilizada no treino dessa
RNA, de forma geral, esse resultado demonstra que quanto mais próximo de zero
estiver o erro de convergência, melhor é o aprendizado da RNA em função das
informações utilizadas em seu treino, e também fica melhor a relação entre os índices
escolhidos pela RNA e os índices escolhidos pelo algoritmo FS. O teste realizado na
próxima subseção buscou verificar o comportamento da RNA ao se diminuir a
quantidade informações utilizadas em seu treino.
7.2.3 Teste – codebook com 1000 vetores e uma imagem de treino
Nesta subseção realizou-se um teste com uma RNA que foi treinada utilizando-
se um codebook com apenas 1000 vetores de imagens. A intenção dessa experiência
foi investigar o comportamento de uma RNA com a mesma arquitetura utilizada nos
testes da subseção 8.2.2, mas que estivesse lidando com um número menor de
informação.
Com um codebook com 1000 vetores, conseguiu-se diminuir a quantidade de
informação em 10 vezes em relação ao teste anterior. O erro de convergência desta
RNA ficou em 0,00158337 e o resultado visual juntamente com seu valor de PSNR está
exposto na Figura 20.
60
Figura 20 – Imagem Lena restaurada por RNA: 26,85 dB. Fonte: Autoria própria, 2007.
O resultado de PSNR deste teste mostra uma melhora na qualidade da imagem
restaurada de aproximadamente 5% em relação ao resultado de 25,66 dB obtido no
teste da subseção 8.2.1, que também utilizou a mesma arquitetura de RNA e também
somente uma imagem no treino.
Essa melhoria de qualidade ocorreu pelo fato dessa RNA ter lidado com menos
informações durante seu treino. Ela teve que aprender a fazer escolhas em um conjunto
com apenas 1000 índices ao invés de 10000.
Da mesma forma que o outro codebook utilizado nos testes anteriores, este
também estava ordenado e com os vetores correspondentes às cores preta e branca
em suas extremidades. A figura utilizada para construir esse codebook é mostrada no
APÊNDICE B.
7.2.4 Teste – 4 RNAs treinadas, cada uma com 1/4 da imagem de treino
Este teste também buscou verificar o comportamento das RNAs em relação à
diminuição da quantidade de informação que são tratadas por elas e se essa
diminuição de informação poderia influenciar, novamente, nos resultados de qualidade
de imagem.
61
Esta subseção apresenta a realização de um teste onde utilizou-se 4 RNAs
especialistas em uma determinada faixa de tons de cinza. Para se conseguir essa
especialização, utilizou-se novamente o algoritmo FS, assim como nos outros testes,
para se verificar os índices que deveriam ser escolhidos por cada RNA para cada vetor
da imagem utilizada para treino das RNAs. A diferença para o teste desta subseção é
que os resultados dos 1200 índices escolhidos pelo algoritmo FS e os respectivos
vetores, foram colocados em ordem crescente para se conseguir agrupar os índices e
vetores pertencentes ao mesmo grupo de tons de cinza da imagem de treino.
Após essa ordenação, os índices escolhidos do codebook e seus respectivos
vetores foram divididos em 4 partes iguais, ou seja, conseguiu-se 4 partes formadas por
300 vetores de treino (1200/4=300). Cada uma desses 300 vetores juntamente com
seus índices foram utilizados para treinar cada uma das 4 RNAs.
A diminuição de informação utilizada para treinar cada RNA está no fato de que
utilizou-se apenas 300 vetores para o treino de cada RNA, ao invés de 1200, caso
fosse utilizado uma imagem inteira para treiná-las. Isso resultou em uma diminuição de
75% na quantidade de dados tratados por cada uma das RNAs.
Como os 1200 resultados obtidos pelo algoritmo FS para serem utilizados no
treino das RNAs foram ordenados, então cada 1/4 dessas informações estava
representando 1/4 dos tons de cinza da imagem utilizada no treino. Isso significa que o
primeiro 1/4 estaria representando os tons de cinza mais próximos à cor preta e o último
1/4 estaria representando os tons de cinza mais próximos à cor branca.
O resultado que se esperava é que as RNAs por terem sido treinadas, cada uma
com 1/4 ordenado da imagem que foi utilizada para seu treino, fizesse com que cada
RNA respondesse melhor, no momento da codificação, aos vetores que pertencessem
ao grupo de tons de cinza equivalentes aos que elas foram treinadas.
Para este teste, também se utilizou a imagem da Figura 14, que foi aplicada às
quatro RNAs, e o mesmo codebook com 10000 vetores que foi empregado nos testes
anteriores.
Cada RNA ao receber os vetores da imagem de teste em suas entradas,
definiam em suas saídas os índices correspondentes. Para cada vetor de entrada, as 4
RNAs disponibilizavam um índice em sua saída, que eram utilizados para endereçar 4
62
vetores no codebook. Esses quatro vetores foram então comparados com o vetor da
imagem original utilizada no teste e, através da medida de MSE, identificou-se o vetor
com menor erro, e o índice desse vetor foi então armazenado. Esse procedimento foi
repetido até que todos os vetores da imagem de teste fossem codificados e os índices
referentes aos vetores com menor MSE formam utilizados para se restaurar a imagem
novamente. A Figura 21 mostra a imagem restaurada e seu respectivo PSNR e a
Tabela 6 exibe os erros de convergência de cada uma das 4 RNAs.
Figura 21 – Imagem Lena restaurada por RNA: 27,70 dB. Fonte: Autoria própria, 2007.
Tabela 6: Erro de convergência de cada RNA.
Grupo de
tom de cinza
da RNA
Erro de
Convergência
1/4 0,000363171
2/4 0,000281873
3/4 0,000636435
4/4 0,000111117
Fonte: Autoria própria, 2007.
É possível observar na Tabela 6 o erro de convergência alcançado por cada
RNA após seu treino. Em comparação ao erro de convergência da RNA da subseção
63
8.2.2, que foi treinada com 1200 vetores, conseguiu-se uma diminuição de
aproximadamente 10 vezes nessa medida, ou seja, um erro quase 10 vezes menor.
Essa melhoria deve-se ao fato de que essas RNAs tiveram que tratar com menos
informação do que a RNA da subseção 8.2.2, que foi treinada com 1200 vetores.
Com um erro de convergência menor, os índices escolhidos pelas RNAs ficaram
mais próximos aos índices escolhidos pelo algoritmo FS e com isso a qualidade da
imagem decodificada também teve uma melhora de aproximadamente 8% em relação
ao resultado desse outro teste.
Outra diferença do teste desta subseção em relação aos outros testes realizados
é que foi necessária a realização de uma comparação para se escolher para cada vetor
de imagem de entrada, qual dos 4 vetores indicados pelas RNAs seria o mais
adequado para se realizar a decodificação.
Para codificar os 1200 vetores dessa imagem de teste, foram realizadas 4800
comparações; bem menos do que as 12000000 efetuadas pelo algoritmo FS.
O tempo utilizado para se escolher o melhor vetor entre os quatro indicados por
cada RNA para os 1200 vetores da imagem de teste foi menor do que 0,001ms. Esse
tempo ainda é muito menor em relação aos 6,79s (conforme pôde ser verificado na
Tabela 3 da seção 8.1) utilizados pelo algoritmo FS para codificar essa mesma imagem.
O tempo total para se codificar a imagem de teste utilizando-se o método
descrito nesta subseção (levando-se em conta o pior caso, onde as imagens seriam
codificadas pelas RNAs de forma seqüencial e não paralelamente) está exibido na
Tabela 7 e o gráfico da diferença do PSNR da imagem Lena restaurada pelo algoritmo
FS e pelas 4 RNAs especialistas é mostrado na Figura 22.
Tabela 7: Discriminação dos tempos de codificação.
Tempo da RNA 1 0,01s
Tempo da RNA 2 0,01s
Tempo da RNA 3 0,01s
Tempo da RNA 4 0,01s
Tempo das comparações < 0,001ms
Tempo total de codificação ~0,04s
Fonte: Autoria própria, 2007.
64
0
5
10
15
20
25
30
35
40
1 2
FS 4 RNAs
PS
NR
Figura 22 – Diferença de PSNR entre o algoritmo FS e 4 RNAs especialistas. Fonte: Autoria própria, 2007.
Embora que a medida de PSNR seja logarítmica, em outras palavras, essa
pequena diferença de qualidade de imagem entre a imagem restaurada utilizando-se as
4 RNAs especialistas e a imagem restaurada pelo algoritmo FS esteja fazendo uma
diferença considerável na avaliação subjetiva, é possível observar que em termos de
avaliação objetiva o resultado obtido pelas 4 RNAs especialistas está próximo ao obtido
pelo algoritmo FS.
65
8 CONCLUSÃO
A quantização vetorial é comprovadamente uma técnica que consegue alta taxa
de compressão de dados, mas sua aplicação plena ainda não acontece porque o
método que consegue a melhor qualidade de imagem necessita de muito
processamento computacional.
Mesmo em outras pesquisas realizadas, ou a qualidade ainda não é aceitável, ou
o tempo de processamento continua acima do ideal, ou ocupa-se a banda de
transmissão de maneira não otimizada.
As RNAs, por serem uma arquitetura intrinsecamente paralelas, conseguem um
ótimo desempenho computacional, principalmente em relação ao algoritmo FS que é o
processo que consegue a melhor qualidade de imagem em quantização vetorial.
Pôde-se observar através dos resultados realizados, que se mostrou muito
promissor a utilização de RNAs, juntamente com a técnica de quantização vetorial,
como uma solução para compressão de imagem digital.
Em termos de qualidade de imagem, as RNAs se mostraram inferiores ao
algoritmo FS em torno de 21% para os testes realizados até este momento, mas em
relação ao tempo de processamento, a RNA foi muito superior ao algoritmo FS.
A realização de novos testes poderá mostrar se as tendências observadas
durante esta pesquisa se confirmarão. Por exemplo, uma RNA com um número maior
de neurônios na camada escondida, com mais épocas de treino e com um número
maior de imagens e treino, poderá diminuir a diferença de qualidade que existe em
relação ao algoritmo FS. Com mais neurônios, os pesos sofrerão uma menor variação
durante o treino, e com mais épocas, a rede poderá diminuir o erro de escolha dos
índices do codebook.
66
Também se pode levar em conta, como influência para se melhorar a qualidade
da imagem, a utilização de um codebook mais adequado, formado por vetores que
abranjam de maneira mais ampla as possibilidades das imagens de entrada na RNA.
8.1 Limitações
O tempo normalmente é uma limitação, quando se tem um cronograma para
seguir e datas para se finalizar determinadas tarefas. Nesta pesquisa não foi diferente.
Alguns testes demorariam muito tempo para ser realizados, monopolizando o
equipamento utilizado nesta experiência. Por essa razão, foram escolhidos testes que
permitissem verificar o comportamento de quantização vetorial utilizando RNA, mas que
necessitassem de menos tempo para se visualizar os resultados.
Não foi realizada uma pesquisa para se definir se o tamanho do codebook pode
influenciar nos resultados, nem qual o conjunto de vetores que melhor representariam
as imagens de entrada neste codificador. Dessa forma, não foi possível definir se o
codebook utilizado nesta pesquisa era o mais adequado.
8.2 Trabalhos futuros
Como trabalho futuro, pode-se sugerir a confecção de um codebook com um
número maior de vetores e que abranja de maneira mais ampla as possibilidades de
imagens de entrada na RNA. Com mais vetores, a RNA terá mais opções de escolha
para encontrar um vetor mais adequado a um vetor da imagem de entrada.
Durante os testes, o aumento na quantidade de neurônios na camada escondida
da RNA, maior número de imagens durante o treino e maior quantidade de épocas,
apresentou uma melhora na qualidade da imagem decodificada. Uma pesquisa que
poderia ser realizada futuramente é a verificação de como uma RNA se comportaria
67
aumentando-se esses parâmetros. Com mais neurônios na camada escondida, os
pesos poderão ser melhores distribuídos e sofrerão uma menor variação durante o
treino da RNA; com mais imagens na fase de treino, a RNA terá mais informações para
ajustar seus pesos para as diferentes imagens que serão aplicadas em sua entrada; e
com mais épocas, a RNA terá mais tempo para melhorar os ajustes dos pesos e com
isso tentar satisfazer, através do aprendizado supervisionado, os parâmetros durante a
fase de treinamento.
Uma outra opção para trabalho futuro seria uma RNA com mais neurônios de
saída. Então, ao invés de se ter apenas uma saída para endereçar os índices do
codebook de forma decimal, poderia se fazer esse endereçamento de forma binária, ou
seja, no caso de se endereçar um codebook com 65536 vetores, a RNA poderia ter 16
neurônios de saída, cada um representando um dos 16 bits para formar a palavra de
endereçamento dessa quantidade de posições (216=65536). Essa idéia também se
baseia na tentativa de se aumentar a quantidade de neurônios da RNA e com isso
dividir mais a distribuições dos pesos em cada conexão entre os neurônios.
Neste trabalho, foram realizados testes com somente as dez primeiras
informações dos vetores das imagens, gerando uma RNA com apenas dez neurônios
de entrada. Isso foi feito principalmente para se agilizar os testes e não se monopolizar
o equipamento utilizado, pois se fosse criada uma RNA com 64 entradas para cobrir
todas as 64 posições dos vetores dos blocos de 8x8 das imagens, ter-se-ia uma RNA
com um número muito maior de neurônios, e o tempo necessário para os treinos nesse
caso, seria muito grande, em torno de 1 semana.
Como opção para futuros testes, poderia ser criada uma RNA que receba todas
as posições dos vetores de entrada e com isso ela teria mais informações para escolher
um vetor mais adequado para representar o vetor de entrada.
Após a aplicação da DCT nos blocos da imagem, o coeficiente DC, ou seja, o
primeiro valor de cada vetor acaba sendo o valor mais significativo e com maior
representação numérica. Neste trabalho foi utilizado blocos de 8x8 que acabaram
gerando vetores com 64 posições. Uma outra indicação de trabalho futuro poderia ser a
realização dos testes utilizando-se blocos de 4x4, que gerariam vetores com 16
posições. Dessa forma, poderia se ter uma RNA com menos neurônios em sua entrada,
68
mas que abrangeria toda a informação de cada vetor de entrada. Claro que isso geraria
mais vetores para uma mesma imagem, ou seja, mais variação nos pesos.
O último teste realizado neste trabalho demonstrou a melhor qualidade de
imagem restaurada, que se alcançou utilizando-se RNAs especialistas em tons de
cinza.
As análises intermediárias mostraram que a divisão da imagem de treino não
ficou linear, ou seja, para um codebook com 10000 vetores, o ideal é que uma das
RNAs endereçasse no codebook do índice 1 até o 2500, outra RNA do índice 2501 até
5.000, e assim até a quarta RNA endereçasse do índice 7501 até o 10000.
Para se conseguir isso, teria que ser confeccionado uma imagem de teste que
permitisse essa divisão, ou algo muito perto disso.
69
REFERÊNCIAS
AHMED, N; NATARAJAN, T.; RAO, K. R. Discrete Cosine Transform. IEEE Transactions of Computers, New York, v.C-23, p. 90-93, jan. 1974. ALPCAN, Tansu.; KESAL, Mustafa; DELIÇ, Hakan. Wavelet Based Subband Vector Quantization Algorithm for Gray Images. In: International Conference on Signal and Image Processing, Las Vegas, Nevada, p. 720-724, out. 1998. BAYAZIT, Ulug; PEARLMAN, William A. Variable-Length Constrained-Storage Tree-Structured Vector Quantizaton. IEEE Transactions on Image Processing, New York, v.8, n.3, p. 321-331, mar. 1999. BOSE, N. K.; GARGA, Amulya K. Neural Network Desing Using Voronoi Diagrams. IEEE Transactions on Neural Networks, New York, v.4, n.5, p. 778-787, set. 1993. BRUNO, Gaspare Giuliano Elias. VEBit: um Algoritmo para Codificação de Vídeo com Escalabilidade. 2003. 99 f. Dissertação (Mestrado) - Universidade Federal do Rio Grande do Sul, Instituto de Informática, Programa de Pós-Graduaçao em Computação. CAO, Hugh Q.; LI, Weiping. A Fast Search Algorithm for Vector Quantization Using a Direct Graph. IEEE Transactions on Circuits and Systems for Video Technology, New York, v.10, n.4, p. 585-593, jun. 2000. CARBONARA, Mattew R.; FOWLER, James E.; AHALT, Stanley C. Compression of Digital Video Data Using Artificial Neural Network Differential Vector Quantization. Proceedings of SPIE, v.1709, p. 422-433, set. 1992. CHU, W. C.; BOSE, N. K. Vector Quantization of Neural Networks. IEEE Transactions on Neural Networks, New York, v.9, n.6, p. 1235-1245, nov. 1998. COSMAN, Pamela C. et al. Using Vector Quantization for Image Processing. Proceedings of the IEEE, New York, v.81, n.9, p. 1326-1341, set. 1993.
70
FERRAZ, Marcelo Coelho. Codificação de Imagens. 1998. 232 f. Dissertação (Mestrado) - Instituto Nacional de Matemática Pura e Aplicada, Rio de Janeiro. FLEURY, Cláudio A.; CARRIJO, Gilberto A. Quantização Vetorial Classificada Adaptada Perceptivamente, In: XXVIII Congresso Nacional de Matemática Aplicada e Computacional. São Paulo, 2005. FOWLER, James E. Adaptative Vector Quantization for Efficient Zerotree-Based Coding of Video with Nonstationary Statistics. IEEE Transactions on Circuits and Systems for Video Technology, New York, v.10, n.8, p. 1478-1488, dez. 2000. GERSHO, A.; GRAY R. M. Vector Quantization and Signal Compression. Kluwer Academic Publishers, 1991. GOOGLE SUMMER OF CODE. Fast Artificial Neural Network Library (FANN). Disponível em: <http://leenissen.dk/fann/index.php>. Acesso em: agosto 2007. GRAY, Robert M.; NEUHOFF, David L. Quantization. IEEE Transactions on Information Theory, New York, v.44, n.6, p. 2325-2383, out. 1998. GRAY, Robert M.; LINDE, Yoseph. Vector Quantizers and Predictive Quantizers for Gauss-Markov Sources. IEEE Transactions on Communications, New York, v.30, n.2, p. 381-389, fev. 1982. JACK, Keith. Video Demystified: a handbook for the digital engineer. 4. ed. Elsevier, 2005. JOST, Randy J.; UPPULURI, Avinash. MATLAB-Based Toolkit for an introductory Course in SAR Image Processing. IEEE International Radar Conference, p. 685-690, maio 2005. JUNIOR, Nelson Ismar da Silva. Um Sistema de Compressão de Imagens Aplicado a Documentos Históricos. 1993. 146 f. Dissertação (Mestrado) - Universidade Federal de Minas Gerais, Instituto de Ciências Exatas, Departamento de Ciência da Computação.
71
KARAYIANNIS, Nicolaos B.; LI, Yiding. A Replenishment Technique for Low Bit-Rate Video Compression Basedon Wavelets and Vector Quantization. IEEE Transactions on Circuits and Systems for Video Technology, New York, v.11, p.658-663, maio 2001. KHALIL, Hosam; ROSE, Kenneth; REGUNATHAN, Shankar L. The Asymptotic Closed-Loop Approach to Predictive Vector Quantizer Design with Application in Video Coding. IEEE Transactions on Image Processing, New York, v.10, n.1, p. 15-23, jan. 2001. KIM, Y. K.; RA, J. B. Adaptative Learning Method in Self-Organization Map for Edge Preserving Vector Quantization. IEEE Transactions on Neural Networks, New York, v.6, n.1, p. 278-280, jan. 1995. KLAUTAU, Aldebaro B. R. PredictiveVector Quantization with Intrablock Prediction Support Region. IEEE Transactions on Image Processing, New York, v.8, n.2, p. 293-295, fev. 1999. LAI, Jim. Z. C.; LIAW, Yi-Ching. Fast-Searching Algorithm for Vector Quantization Using Projection and Triangular Inequality. IEEE Transactions on Image Processing, New York, v.13, n.12, p. 1554-1559, dez. 2004. LIN, Yih-chuan; TAI, Shen-chuan. A Fast Vector Quantization Encodeer for Video Coding. IEEE Transactions on Consumer Electronics, New York, v.40, n.3, p. 451-457, ago. 1994. LINDE, Yoseph; BUZO, Andrés; GRAY, Robert M. An Algorithm for Vector Quantizer Design. IEEE Transactions on Communications, New York, v.28, n.1, p. 84-95, jan. 1980. LUGER, G. F., Inteligência Artificial: estruturas e estratégias para a solução de problemas complexos. Bookman, 2004. MAKUR, Anamitra; SUBBALAKSHMI, K. P. Variable Dimension VQ Encoding and Codebook Design. IEEE Transactions on Communications, New York, v.45, n.8, p. 897-899, ago. 1997. MARGRAVE, F. et al. MATLAB – Neural Networks Toolbox Hardware Post-Processor. IEE Colloquium on Applied Control Techniques Using MATLAB , p. 6/1- 6/3, jan. 1995.
72
MARTINETZ, Thomaz M.; BERKOVICH, Stanislav G.; SCHULTEN, Klaus J. Neural-Gas Network for Vector Quantization and its Application to Time-Series Prediction. IEEE Transactions on Neural Networks, New York, v.4, n.4, p. 558-569, jul. 1993. MARTINS, Ronaldo de Andrade. Modelagem e Medições de Ondas de Rádio para Predição de Perda de Propagação em Ambientes Urbano s. 2006. 151 f. Tese (Doutorado). Universidade Federal de Rio Grande do Norte, Programa de Pós-Graduação em Engenharia Elétrica. NASRABADI, Nasser M.; KING, Robert A. Image Coding Using Vector Quantization: A Review. IEEE Transactions on Communications, New York, v.36, n.8, p. 957-971, ago. 1988. NIELSEN, Robert H. Theory of the Backpropagation Neural Network. In: International Joint Conference on Neural Networks. San Diego, California, v.1, p. 593-605, jun. 1989. PALIWAL, Kuldip K.; Ramasubramanian V. Comments on Modified K-Means Algorithm for Vector Quantizer Design. IEEE Transactions on Image Processing, New York, v.9, n.11, p. 1964-1967, nov. 2000. PINAGÉ, Frederico da Silva. Avaliação do Desempenho de Algoritmos de Compressão de Imagens Usando Recorrência de Padrões Multiescalas. 2005. 113 f. Dissertação (Mestrado) - Universidade Federal do Rio de Janeiro. SALOMON, David. Data Compression: the complete reference. 3. ed. Springer, 2004. SANGHAMITRA, Roy; BANERJEE, Prith. An Algorithm for Trading Off Quantization error with Hardware Resources for MATLAB-Based FPGA Design. IEEE Transactions on Computers, New York, v.54, n.7, p. 886-896, jul. 2005. SETIONO, Rudy; LU, Guojun. Image Compression Using a Feedforward Neural Network. IEEE International Conference on Neural Networks, New York, v.7, p. 4761-4765, jun. 1994. SHEPPARD, David G. et al. A Vector Quantizer for Image Restoration. IEEE Transactions on Image Processing, New York, v.7, n.1, p. 119-124, jan. 1998.
73
SICURANZA, G. L., ROMPONI, G. e MARSI, S. Artificial Neural Network for Image Compression. In: Electronics Letters, v. 26, n. 7, p. 477-479, mar. 1990. SITARAM, Vijay S.; HUANG, Chien M. e Israelsen, Paul D. Efficient Codebooks for Vector Quantization Image Compression with an Adaptative Tree Search Algorithm. IEEE Transactions on Communications, New York, v.42, n.11, p. 3027-3033, nov. 1994. SOBREIRO, Marcos Vinícius Rayol. Quantização de Imagens. 1998. 101 f. Dissertação (Mestrado) - Pontifícia Universidade Católica do Rio de Janeiro, Curso de Pós-Graduação em Ciência da Computação. SUDHIR, G.; LIOU, Ming. L.; LEE, John C. M. Average Optimal Vector Transform for VQ-Based Imaage and Video Compression. IEEE Transactions on Circuits and Systems for Video Technology, New York, v.9, n.4, p.617-629, jun. 1999. TAI, S. C., LAI C. C. e LIN Y. C. Two Fast Nearest Neighbor Seaarching Algorithms for Image Vector Quantization. IEEE Transactions on Communications, New York, v.44, n.12, p. 1623-1628, dez. 1996. TSAI, Jyi-Chang; HSIEH, Chaur-Heh; HSU Te-Cheng. A New Dynamic Finite-State Vector Quantization Algorithm for Image Compression. IEEE Transactions on Image Processing, New York, v.9, n.11, p. 1825-1836, nov. 2000. YANG, Shiueng-Bien. Variable-Branch Tree-Structured Vector Quantization. IEEE Transactions on Image Processing, New York, v.13, n.9, p. 1275-1285, set. 2004. ZHU, Ce; PO, Lai-Man. Minimax Partial Distortion Competitive Learning for Optimal Codebook Design. IEEE Transactions on Image Processing, New York, v.7, n.10, p. 1400-1409, out. 1998.
74
APÊNDICE A – Tabela de testes de parâmetros das RNA s do MATLAB. A tabela abaixo mostra os resultados dos testes de qualidade das imagens restauradas por RNAs, que foram construídas combinando-se os parâmetros aqui apresentados e, que estão disponíveis na ferramenta MATLAB 7.0.
Training
Function
Adaption
Learnig Function
Transfer
Function
Erro de convergência PSNR
TRAINLM LEARNGDM TANSIG 0,00110754 25,66
TRAINGDX LEARNGDM TANSIG 0,00326451 26,10
TRAINBFG LEARNGDM TANSIG 0,00125997 25,47
TRAINBR LEARNGDM TANSIG 1,47935 25,78
TRAINCGB LEARNGDM TANSIG 0,00228745 25,82
TRAINCFG LEARNGDM TANSIG 0,00228759 25,94
TRAINCGP LEARNGDM TANSIG 0,00215051 25,92
TRAINGD LEARNGDM TANSIG 0,00484782 25,68
TRAINGDM LEARNGDM TANSIG 0,00583735 25,97
TRAINGDA LEARNGDM TANSIG 0,00383784 25,91
TRAINOSS LEARNGDM TANSIG 0,00176199 26,07
TRAINR LEARNGDM TANSIG 0,0211287 25,79
TRAINRP LEARNGDM TANSIG 0,0012856 25,68
TRAINSCG LEARNGDM TANSIG 0,00167612 25,87
TRAINLM LEARNGD TANSIG 0,00166755 25,88
TRAINGDX LEARNGD TANSIG 0,00371032 25,91
TRAINBFG LEARNGD TANSIG 0,00142708 1,57
TRAINBR LEARNGD TANSIG 1,53629 25,67
TRAINCGB LEARNGD TANSIG 0,00339402 25,62
TRAINCFG LEARNGD TANSIG 0,0021561 25,79
TRAINCGP LEARNGD TANSIG 0,00224865 25,98
TRAINGD LEARNGD TANSIG 0,00564167 25,68
TRAINGDM LEARNGD TANSIG 0,00504624 25,85
75
TRAINGDA LEARNGD TANSIG 0,00485224 25,92
TRAINOSS LEARNGD TANSIG 0,00174508 25,83
TRAINR LEARNGD TANSIG 0,00211765 25,95
TRAINRP LEARNGD TANSIG 0,00163536 25,98
TRAINSCG LEARNGD TANSIG 0,00156399 25,73
TRAINLM LEARNGDM LOGSIG 0,00114869 25,75
TRAINGDX LEARNGDM LOGSIG 0,00368008 25,80
TRAINBFG LEARNGDM LOGSIG 0,00119605 25,84
TRAINBR LEARNGDM LOGSIG 1,52023 25,85
TRAINCGB LEARNGDM LOGSIG 0,00223946 26,02
TRAINCFG LEARNGDM LOGSIG 0,00229269 25,88
TRAINCGP LEARNGDM LOGSIG 0,00214671 25,89
TRAINGD LEARNGDM LOGSIG 0,0105858 25,24
TRAINOSS LEARNGDM LOGSIG 0,00187126 25,92
TRAINGDM LEARNGDM LOGSIG 0,00690139 25,55
TRAINGDA LEARNGDM LOGSIG 0,00405155 25,68
TRAINR LEARNGDM LOGSIG 0,00222014 26,01
TRAINRP LEARNGDM LOGSIG 0,00142516 25,86
TRAINSCG LEARNGDM LOGSIG 0,00171192 25,97
TRAINLM LEARNGD LOGSIG 0,00110797 25,19
TRAINGDX LEARNGD LOGSIG 0,00356192 25,83
TRAINBFG LEARNGD LOGSIG 0,00122602 1,03
TRAINBR LEARNGD LOGSIG 1,52442 25,99
TRAINCGB LEARNGD LOGSIG 0,00224357 25,94
TRAINCFG LEARNGD LOGSIG 0,0020544 25,78
TRAINCGP LEARNGD LOGSIG 0,00234739 25,81
TRAINGD LEARNGD LOGSIG 0,0174261 24,99
TRAINGDM LEARNGD LOGSIG 0,00979033 25,45
TRAINGDA LEARNGD LOGSIG 0,00426851 25,93
TRAINOSS LEARNGD LOGSIG 0,00187386 25,87
TRAINR LEARNGD LOGSIG 0,00227883 25,81
76
TRAINRP LEARNGD LOGSIG 0,00156133 25,84
TRAINSCG LEARNGD LOGSIG 0,00171682 25,79
TRAINLM LEARNGDM PURELIN 0,00409927 25,80
TRAINGDX LEARNGDM PURELIN 0,00409927 25,79
TRAINBFG LEARNGDM PURELIN 0,00409927 25,80
TRAINBR LEARNGDM PURELIN 29,9981 24,91
TRAINCGB LEARNGDM PURELIN 0,00409934 25,89
TRAINCFG LEARNGDM PURELIN 0,00409934 25,72
TRAINCGP LEARNGDM PURELIN 0,00409934 25,81
TRAINGD LEARNGDM PURELIN 0,00553746 25,69
TRAINGDM LEARNGDM PURELIN 0,0049618 25,57
TRAINGDA LEARNGDM PURELIN 0,00445221 25,77
TRAINOSS LEARNGDM PURELIN 0,00409927 25,82
TRAINR LEARNGDM PURELIN 0,00416711 25,63
TRAINRP LEARNGDM PURELIN 0,00409927 25,80
TRAINSCG LEARNGDM PURELIN 0,82665 3,39
TRAINLM LEARNGD PURELIN 0,00409927 25,80
TRAINGDX LEARNGD PURELIN 0,00410437 25,78
TRAINBFG LEARNGD PURELIN 0,00409927 25,80
TRAINBR LEARNGD PURELIN 4,91916 25,66
TRAINCGB LEARNGD PURELIN 0,00409928 25,81
TRAINCFG LEARNGD PURELIN 0,00409978 25,64
TRAINCGP LEARNGD PURELIN 0,0041001 25,68
TRAINGD LEARNGD PURELIN 0,00656165 25,67
TRAINGDM LEARNGD PURELIN 0,00544957 25,65
TRAINGDA LEARNGD PURELIN 0,0041954 25,85
TRAINOSS LEARNGD PURELIN 0,00409927 25,81
TRAINR LEARNGD PURELIN 0,00416768 19,22
TRAINRP LEARNGD PURELIN 0,00409927 25,79
TRAINSCG LEARNGD PURELIN 0,00409927 25,78
77
APÊNDICE B – Imagem utilizada para formar o codebook com 1.000 vetores.
78
APÊNDICE C – Resultados visuais da imagem Lena rest aurada por RNAs treinadas com diferentes quantidades de imagens.
Imagem Lena restaurada utilizando-se duas imagens no treino.
Imagem Lena restaurada utilizando-se três imagens no treino.
79
Imagem Lena restaurada utilizando-se quatro imagens no treino.
Imagem Lena restaurada utilizando-se cinco imagens no treino.
80
ANEXO A – Imagens que formaram o codebook com 10.000 vetores.
81
82
ANEXO B – Imagens utilizadas nos treinos das RNAs.
Imagem utilizada nos treinos com apenas uma imagem.
Imagem adicionada no treino com duas imagens.
83
Imagem adicionada no treino com 3 imagens.
Imagem adicionada no treino com 4 imagens.
Imagem adicionada no treino com 5 imagens.