Douglas Santamarina Done

Corretor ortográfico utilizando algoritmo de Similaridade

Trabalho de conclusão de curso apresentado ao

Instituto Federal de São Paulo, como parte dos
requisitos para a obtenção do grau de Tecnólogo
em Sistemas para Internet.

Área de Concentração: Banco de Dados

Orientador: Prof. Gustavo A. Prieto

São João da Boa Vista

2013
Autorizo a reprodução e divulgação total ou parcial deste trabalho, por qualquer
meio convencional ou eletrônico, para fins de estudo e pesquisa, desde que
citada a fonte.

Ficha catalográfica preparada pela Seção de Tratamento

da Informação do Serviço de Biblioteca – IFSP

Done, Douglas Santamarina.

Corretor ortográfico utilizando algoritmo de
Similaridade. / Douglas Santamarina Done ; orientador
Gustavo A. Prieto. São João da Boa Vista, 2013.

Trabalho de Conclusão de Curso, IFSP, 2013.

Similaridade. Jaro-Winkler. K-Nearest Neighbor. Asp.Net

1. Similaridade. 2. Jaro-Winkler. 3. K-Nearest

Neighbor. 4. Corretor ortográfico.

I. Corretor ortográfico utilizando algoritmo de

Similaridade
AGRADECIMENTOS

Agradeço primeiramente a Deus, a minha família e a todos os professores

que muito auxiliaram e contribuíram para minha formação.

 RESUMO

DONE, Douglas Santamarina. (2013). Corretor ortográfico utilizando algoritmo de

Similaridade. Trabalho de Conclusão de Curso - Instituto Federal de São Paulo, São João da
Boa Vista, 2013.

Este trabalho tem por objetivo apresentar as principais funções de similaridade para
dados complexos (imagens e vídeos) e textos. Para os dados complexos são diferenciadas as
formas de recuperação por descrição e conteúdo, exibida as premissas para a função de
distância e apresentadas as principais funções métricas (Euclidiana, Manhattan e Chebyshev).
Outra abordagem apresentada neste trabalho é em relação as métricas de similaridade
utilizadas para textos, sendo apresentadas as principais delas (Levenshtein, Jaro-Winkler,
Monge-Elkan e Carla) sendo diferenciado os dois tipos de consulta Range Query e K-Nearest
Neighbor. Por fim, a proposta deste trabalho é a elaboração de um aplicativo corretor
ortográfico desenvolvido em ASP.Net utilizando Entity Framework na qual a palavra digitada
é a própria fonte para extração das características, e que implemente a métrica e o algoritmo
Jaro-Winkler. Os dados correspondem a uma listagem definida de palavras do dicionário
nacional e são armazenadas no Banco de Dados SqlServer sendo utilizada o tipo de busca K-
Vizinho Mais Próximo para seleção dos resultados. Por fim o algoritmo de Jaro-Winkler em
conjunto com as tecnologias: C# ASP.Net MVC, Entity Framework, jQuery, JSON e Ajax,
mostrou ser uma solução bastante eficaz para a consulta de similaridade.

Palavras-chave: Similaridade. Jaro-Winkler. K-Nearest Neighbor. Corretor ortográfico.

 ABSTRACT

DONE, Douglas Santamarina. (2013). Spell algorithm using Similarity algorithm. Course
Conclusion Project – Instituto Federal de São Paulo, São João da Boa Vista, 2013.

This study aims to present major similarity functions for complex data (images and
videos) and texts. For complex data are differentiated the retrieval forms by description and
by content, are displayed premises for the distance function and presented major functions
metrics (Euclidiana, Manhattan e Chebyshev). Another approach presented in this paper
compare the similarity metrics used for texts, being presented the main (Levenshtein, Jaro-
Winkler, Monge-Elkan e Carla) and the two tipes of query are differentiated: Range Query
and K-Nearest Neighbor. Finally the proposal of this work is the development of a
spellchecker application in ASP.Net using Entity Framework and each word typed is the very
source for feature extraction that implements the Jaro-Winkler algorithm, the data correspond
to a defined list of words in Brazilian dictionary and they are stored in SqlServer database
being used to query type K-Nearest Neighbor for results selection. Finally the Jaro-Winkler
algorithm together with the technologies: C # ASP.Net MVC, Entity Framework, jQuery,
JSON and Ajax proved to be a very effective solution for similarity query.

Keywords: Similarity. Jaro-Winkler. K-Nearest Neighbor. Spellchecker.

 LISTA DE FIGURAS

Figura 1 – Similaridade cognitiva (TRAINA, 2012).. .................................. ……20

Figura 2 – Função Euclidiana no plano ............................................................23
Figura 3 - Função Manhattan no plano .............................................................24
Figura 4 – Função Chebyshev no plano .......................................................... 25
Figura 5 – Distâncias Chebyshev, Euclidiana e Manhattan representadas em um
plano (TRAINA, 2012) ...................................................................25
Figura 6 – Ilustração representativa do Range Query ......................................29
Figura 7 – Ilustração representativa do K-Nearest Neighbor ............................30
Figura 8 - Etapas de desenvolvimento .............................................................34
Figura 9 – Interface da aplicação ………………………………………………….37
Figura 10 – Equação de Jaro ………………………………………………………45
Figura 11 - Função jQuery para obtenção de retorno assíncrono.....................46
Figura 12 – Método de retorno das palavras relevantes....................................47
Figura 13 – Função jQuery para inclusão de novas palavras ...........................47
Figura 14 – Função jQuery para inclusão de novas palavras............................48
 LISTA DE TABELAS

Tabela 1 – Resultados obtidos pelo termo ‘similaidade’.. .......................... ……51

 LISTA DE SIGLAS

ACM ACM Digital Library

IEEE IEEEXplore Digital Library

ISIWK ISI Web of Knowledge

MVC Model, View, Controller

MSDN Microsoft Developer Network

 SUMÁRIO

1 INTRODUÇÃO ...........................................................................................................15

1.1 Motivação ............................................................................................................................. 16

1.2 Objetivos ............................................................................................................................... 16

1.3 Organização deste trabalho ................................................................................................... 17

2 PESQUISA BIBLIOGRÁFICA ...................................................................................19

2.1 Recuperação de dados complexos ........................................................................................ 19

2.1.1 Recuperação por Descrição ................................................................................................ 19

2.1.2 Recuperação por Conteúdo ................................................................................................ 20

2.2 Extração de características .................................................................................................... 21

2.2.1 Características externas ...................................................................................................... 21

2.2.2 Características Internas ...................................................................................................... 22

2.3 Função de distância............................................................................................................... 22

2.3.1 Não negatividade................................................................................................................ 22

2.3.2 Simetria .............................................................................................................................. 22

2.3.3 Desigualdade triangular ..................................................................................................... 22

2.4 Funções métricas para imagens ............................................................................................ 23

2.4.1 Função Euclidiana .............................................................................................................. 23

2.4.2 Função Manhattan .............................................................................................................. 24

2.4.3 Função Chebyshev ............................................................................................................. 24

2.5 Métricas de similaridade para strings ................................................................................... 26

2.5.1 Hamming............................................................................................................................ 26

2.5.2 Levenshtein ........................................................................................................................ 27

2.5.3 Jaro e Jaro-Winkler ............................................................................................................ 27

2.5.4 Monge-Elkan ...................................................................................................................... 28

2.5.5 Carla ................................................................................................................................... 28

2.6 Tipos de consulta .................................................................................................................. 29

2.6.1 Range Query....................................................................................................................... 29

2.6.2 K-Nearest Neighbor Query ................................................................................................ 30

3 METODOLOGIA ....................................................................................................... 33

3.1 Tecnologia ............................................................................................................................ 33

3.2 Etapas de desenvolvimento ................................................................................................... 34

3.2.1 Criação do Banco de Dados e inclusão dos registros ......................................................... 34

3.2.2 Consulta com filtro para eliminar resultados sem relevância ............................................. 35

3.2.3 Implementação do algoritmo Jaro-Winkler em ASP.Net ................................................... 35

3.2.4 Melhorias e adaptações do algoritmo ................................................................................. 36

3.2.5 Implementação do tipo de consulta K-Nearest Neighbor................................................... 36

3.2.6 Criação de mecanismo de busca assíncrona ....................................................................... 36

3.2.7 Interface com o usuário ...................................................................................................... 37

3.2.8 Testes e correções............................................................................................................... 38

3.3 Desenvolvimento .................................................................................................................. 38

3.3.1 Banco de Dados.................................................................................................................. 38

3.3.2 Aplicação............................................................................................................................ 39

3.3.3 Desempenho ....................................................................................................................... 39

3.3.4 Entity Framework............................................................................................................... 39

3.3.5 Solução híbrida utilizando Entity Framework e RaptorDB ............................................... 40

3.3.6 Solução híbrida utilizando Entity Framework, listas e armazenamento em cache ............ 41

3.3.7 Implementação do algoritmo Jaro-Winkler ........................................................................ 41

3.3.8 Funcionamento do algoritmo ............................................................................................. 42

3.3.9 Função para cálculo da distância Jaro-Winkler .................................................................. 44

3.3.10 Mudança de arquitetura para integração com o jQuery .................................................... 45

4 RESULTADOS .......................................................................................................... 50

5 CONCLUSÕES .......................................................................................................... 53

REFERÊNCIAS ............................................................................................................... 54
 Capítulo

15

1 Introdução

É cada vez mais comun ver aplicações e sistemas de informação que armazenam
dados multimídia como imagens, vídeos ou mesmo uma quantidade grande de texto. Para a
busca deste tipo de dado, uma busca por termos iguais torna-se ineficiente ou mesmo inviável,
visto, por exemplo, que duas imagens mesmo representando um mesmo objeto podem ter
formas, cores e texturas um pouco diferentes o que já as caracterizariam como diferentes
(ARANTES et al., 2003).
A similaridade surgiu desta necessidade, de localização de imagens, textos, vídeos,
dentre outros que não possuem informações exatamente iguais, mas similares. Este conceito é
amplamente utilizado na medicina para comparação de tomografias, ressonância magnética,
radiografias e mamografias servindo para encontrar tumores ou outro tipo de exames que
podem ser identificados. Neste tipo de análise seria impossível realizar uma comparação por
igualdade porque uma tomografia de um paciente, por exemplo, nunca é igual ao de outro,
porém a forma, textura e cor de tumores podem ser semelhantes e com isto sendo possível
identifica-los (SANTOS FILHO et al., 2001).
Esta similaridade também pode ser utilizada para recuperação biométrica de
impressões digitais, reconhecimento de voz e identificação da íris, para este último exemplo
existem programas de similaridade que provê acerto de aproximadamente 99,10% dos casos
(GONZAGA, 2012).
Embora hoje existam resultados satisfatórios para determinadas situações, esta ideia
de similaridade ainda é um dos grandes desafios da informática. Embora já se tenha avançado
para soluções específicas, este desafio se baseia na criação de máquinas com poder dedutivo
que consigam reconhecer padrões e semelhanças entre imagens ou textos (CASTRO;
PRADO, 1999).
Para a utilização da similaridade em imagens são utilizadas funções matemáticas
dentro do plano cartesiano, nas quais as distâncias entre pontos podem representar
semelhanças entre as imagens de estudo, nos exames médicos por exemplo, podem
representar um tumor ou a existência de alguma doença que precisa de tratamento (CURA,
2002).
 16

A similaridade em texto procura mensurar a diferença entre uma palavra e outra, para
isto várias técnicas são utilizadas. Contudo a ideia principal consiste em medir quantas
alterações de letras seriam necessárias para transformar uma palavra em outra, por exemplo,
para transformar a palavra ‘nota’ em ‘cota’ seria necessária apenas mudar a primeira letra, ou
seja, uma única alteração é necessária (BORGES; CONY; FREITAS, 2005).

1.1 Motivação

É cada vez mais comum que aplicações e serviços tenham que lidar com dados
complexos como som e imagens, em que a busca por igualdade nem sempre é
eficiente. Para contornar este problema de forma simples estes tipos de dados podem
ser descritos através de tags, porém estas informações podem não ter uma grande
abrangência limitando assim os resultados das buscas. Na busca por similaridade em
textos ou palavras este conceito é muito próximo, podendo ser adotado este padrão de
similaridade em uma gama de aplicações, como melhoria em ferramentas de buscas,
análise de DNAs e corretores ortográficos.
Na literatura embora existam algoritmos que trabalhem com a similaridade com textos
ou palavras, não foi encontrada uma aplicação que mescle os algoritmos de
similaridade com uma linguagem de programação Orientada a Objetos e que tenha
uma preocupação com desempenho. Este trabalho explora este nicho para a criação de
uma aplicação para este fim.

1.2 Objetivos

Este trabalho tem como objetivo mostrar os conceitos de similaridade, sua relevância
para as aplicações atuais e as áreas de conhecimento na qual o seu uso é necessário.
Através de embasamento teórico e analogias ao mundo real são apresentadas as
principais funções métricas para cálculo da distância entre dois objetos.
Também são estudados os cinco principais algoritmos de busca por similaridade
presentes na literatura para a busca por conteúdo em textos ou palavras.
Como resultado é desenvolvido uma aplicação que faz a busca por similaridade de
termos digitados. Neste trabalho não é adotado a morfologia ou semântica das
 17

palavras, sendo a proximidade entre elas definidas através do uso do algoritmo Jaro-
Winkler, que verifica a quantidade de alterações necessárias para que uma palavra seja
transformada em outra. A aplicação propõe melhorias para este algoritmo de forma
que ele se adeque ao contexto e faz uma verificação de palavras propostas com um
dicionário previamente implementado trazendo os dez resultados mais relevantes
(através da busca K-Nearest Neighbor) e os exibindo em ordem de proximidade. Após
a exibição dos resultados, será possível selecionar algum dos termos e proceder a
substituição do termo pesquisado podendo a aplicação ser utilizada como um corretor
ortográfico.

1.3 Organização deste trabalho

Este trabalho está dividido da seguinte forma: o capítulo 1 traz a introdução sobre o
assunto de similaridade assim como a motivação e objetivos estabelecidos nesta
monografia. O capítulo 2 traz a pesquisa bibliográfica que contém todo o
embasamento teórico adquirido para a realização da aplicação de similaridade. O
capítulo 3, por sua vez, apresenta a metodologia sendo esta dividida em seis etapas
distintas que vão desde a criação do Banco de dados até o término da aplicação,
passando por etapas de desenvolvimento, melhorias, testes e correções.
O capítulo 4 apresenta os resultados obtidos e o capítulo 5 apresenta as conclusões
finais do presente trabalho.
 Capítulo

19

2 Pesquisa Bibliográfica

Com o avanço da tecnologia e dos sistemas de informação grande parte das aplicações
não manipulam apenas dados simples, como textos e números, mas necessitam gerenciar e
manipular também imagens, vídeos, áudio ou mesmo uma quantidade grande de texto. Este
tipo de informação é chamada de dados complexos. Os dados complexos dificultam ou
impossibilitam a busca convencional por igualdade, sendo necessário recorrer à pesquisa por
similaridade, onde através de um cálculo de distância é possível mensurar o quanto objetos se
assemelham ao objeto pesquisado (ARANTES et al., 2003).
Em aplicações práticas e comerciais, a pesquisa por similaridade é muito utilizada na
medicina, onde são analisadas cadeias de DNA, ferramentas de apoio a diagnóstico (exames
de tomografia, ressonância magnética, radiografias, mamografias, etc). As tomografias de
dois pacientes nunca são iguais, desta forma para identificação de um tumor de forma
automatizada são desenvolvidos algoritmos e técnicas que trabalham com formas, tamanhos,
cores e dimensões aproximadas para esta identificação (SANTOS FILHO et al., 2001).

2.1 Recuperação de dados complexos

Para realizar uma busca de um dado complexo, é possível fazê-la de duas formas, que
são descritas nas duas subseções seguinte, 2.1.1 e 2.1.2:

2.1.1 Recuperação por Descrição

É a mais simples e comumente utilizada na busca por igualdade, para uma busca de
imagem ou vídeo sendo feita através das tags previamente inseridas. É um mecanismo de
busca funcional, porém a sua eficiência se baseia na intuição da pessoa que as inseriu
(RODRIGUES; CECIM; ARAÚJO, 2003).
As imagens são descritas através de atributos textuais que são a base para a consulta.
Por exemplo, escrever o nome da pessoa caso seja um rosto ou conter a cor predominante,
forma ou mesmo através de uma tentativa de descrever a imagem (CURA, 2002).
 20

Este tipo de recuperação é bastante utilizado na web para descrever imagens, apesar da
grande quantidade de imagens disponíveis a busca e recuperação de determinada imagem
pode ser um processo árduo e dificultoso devido à imprecisão dos resultados, carência ou
inexistência de informações para sua localização (ALVES, 2012).

2.1.2 Recuperação por Conteúdo

A recuperação por conteúdo implementa técnicas e algoritmos para que as buscas por
vídeos ou imagens utilizem de critérios de percepção. Na busca por imagens, por exemplo,
possibilita recuperar a informação de forma visual levando em consideração as cores e
gradientes e ao compará-las é possível estabelecer o quão similar duas imagens são
(RODRIGUES; CECIM; ARAÚJO, 2003).
Este tipo de abordagem é muito utilizada na área da medicina para identificação de
tumores em radiografias e também pode ser utilizada, por exemplo, para auxiliar o
sensoriamento remoto para identificação de desmatamentos, crescimento da área urbana de
uma cidade, dentre outros (CURA, 2002).

Figura 1 – Similaridade cognitiva (TRAINA, 2012)

Através da intuição e de estímulos é possível perceber através da Figura 1 que embora as

imagens tenham naturezas distintas que elas são semelhantes devido as características afins,
tais como cor dos olhos, cor do cabelo e pelo, comprimento entre o cabelo e orelha, dentre
outros. Esta interpretação é possível através de nossa cognição que envolve vários aspectos
 21

humanos como percepção, memória e raciocínio. O grande desafio é o desenvolvimento de

máquinas e algoritmos que permitam tal interpretação (CASTRO; PRADO, 1999).
Para a busca textual, os critérios de indexação e recuperação também seguem a linha de
Recuperação por Descrição e Recuperação por Conteúdo. A primeira adota termos ou
características informadas por uma pessoa, enquanto a segunda faz uma indexação e busca de
todo o conteúdo (RODRIGUES; CECIM; ARAÚJO, 2003).
Como analogia ao mundo real, imagine uma pesquisa bibliográfica de um mesmo artigo
em formato impresso e digital. Neste exemplo a Recuperação por Descrição representaria a
busca de determinado termo, que seria pesquisado no sumário e nas palavras-chave deste
artigo, caso nenhum termo similar seja encontrado, certamente o artigo seria descartado para
o uso. Já o arquivo digital exemplifica a Recuperação por Conteúdo, onde é possível através
de softwares de leitura e edição de documentos, realizar uma busca de determinado termo no
artigo completo.

2.2 Extração de características

Para realizar a comparação por imagens primeiramente é feita uma extração de suas
características em uma região para permitir a sua comparação. São realizados cálculos para
obtenção de valores e propriedades qualitativa ou quantitativa de acordo com o objetivo
proposto. As características podem ser, por exemplo, distância entre um ponto e outro,
diferenciação de cores, tamanho, dentre outras (ROSA; TRAINA, 2002).
No presente trabalho a extração de características será adotada de forma mais
simplificada, visto que serão comparadas duas palavras e o cálculo de distância será feito
baseado na quantidade de alterações necessárias para transformar uma palavra em outra,
analisando fatores como tamanho e posição de cada caractere.
Existem duas formas de representação e comparação utilizando as regiões, utilizando as
características externas e internas, que são citadas nas duas subseções seguintes:

2.2.1 Características externas

Baseia-se nas características presentes na parte externa da região adotada para

comparação, onde as principais características são representes pelo formato da imagem
(ROSA; TRAINA, 2002).
 22

2.2.2 Características Internas

Baseia-se no conteúdo da imagem em si, sendo analisada a distância entre pixels, cor e
textura (ROSA; TRAINA, 2002).

2.3 Função de distância

A similaridade trabalha com comparações e utiliza de uma função de distância chamada

dissimilaridade para definir o quanto um objeto se diferencia de outro d(x, y), quando os
objetos são iguais a função retornará zero sendo este valor alterado quando maior a
discrepância entre os objetos, com isto o resultado da diferença pode variar de 0 a N, onde N
corresponde a um número inteiro positivo (ROSA; TRAINA, 2002).
A função d(x, y) é a distância entre palavras sendo calculada se três propriedades forem
satisfeitas. As propriedades são citadas abaixo:

2.3.1 Não negatividade

A distância entre dois pontos é sempre positiva ao menos que o ponto x incida sobre o
ponto y, neste caso a distância será igual a 0 (VARANDAS, 2003).
d(x,y) = 0 para x = y e d (x,y) > 0 para x ≠ y;

2.3.2 Simetria

A distância entre os pontos x e y é igual a distância entre os pontos y e x (VARANDAS,

2003).
d(x,y) = d(y,x)

2.3.3 Desigualdade triangular

Quando adicionado um terceiro ponto no plano qualquer lado do triângulo é menor que a
soma dos outros dois lados (VARANDAS, 2003).
d(x,y) ≤ d(x,z) + d(z,y)
Para o cálculo da dissimilaridade existe uma série de funções matemáticas que satisfazem
estas três premissas são utilizadas para determinar o quanto um objeto encontra-se distante do
outro em um plano.
 23

O valor da similaridade por sua vez varia da escala [0, 1] sendo o valor crescente quanto
mais próximos os objetos estão e sendo 1 para informações iguais (BORGES; CONY;
FREITAS, 2005).
A busca por similaridade envolve três vertentes: a métrica (distância entre os elementos),
o objeto central da pesquisa e o tipo de consulta (TRAINA, 2012).

2.4 Funções métricas para imagens

Dentre as principais funções métricas são citadas:

2.4.1 Função Euclidiana

Em um plano com os pontos P1 e P2 com as coordenadas (x1, y1) e (x2, y2) a distância
d() entre estes pontos é definida pela equação 𝑑 = √(𝑥1 − 𝑥2)2 + (𝑦1 − 𝑦2)2 em que é
traçada uma reta diagonal entre os pontos P1 e P2 e desta forma medindo a menor distância
entre estes elementos no plano. Considerando que estes pontos venham a formar um triângulo
retângulo, o valor da função é o valor de sua hipotenusa. Segue abaixo a Figura 2 que melhor
ilustra este caso.

Figura 2 – Função Euclidiana no plano

 24

2.4.2 Função Manhattan

É também conhecida como Função Taxi Cab ou Função City Block. Em um plano com
os pontos P1 e P2 com as coordenadas (x1, y1) e (x2, y2) a distância d() entre estes pontos é
definida pela equação d = |x1 - x2| + |y1 - y2| em que é medida a menor distância porém
utilizando somente retas horizontais e verticais no plano. Considerando um triângulo
retângulo, o valor desta função coincide sobre a soma dos dois catetos conforme ilustra a
Figura 3 (CLESIO, 2012)

Figura 3 – Função Manhattan no plano

2.4.3 Função Chebyshev

É também conhecida como distância do tabuleiro de Xadrez. Em um plano com os pontos

P1 e P2 com as coordenadas (x1, y1) e (x2, y2) a distância d() entre estes pontos é definida
pela equação d = max(|x1 - x2|, |y1 - y2|), ou seja, esta distância representa a máxima
distância entre dois pontos em um plano no eixo X e Y através de suas coordenadas. Em um
exemplo prático supondo que existam dois pontos em um plano ponto P1 = (1,1) e ponto P2 =
(3,2). A distância entre estes pontos no eixo X e Y são respectivamente 2 e 1, portanto a
distância Chebyshev entre P1 e P2 é igual a 2, podendo este exemplo ser visualizado no plano
através da Figura 4 (CHA, 2007).
 25

Figura 4 – Função Chebyshev no plano

A Figura 5 ilustra cada uma destas funções de distâncias vistas em um plano, para o
exemplo considere a variável com o nome ‘r’ com o valor 1. Para a função Manhattan a
distância em relação ao elemento será de 1 ponto na horizontal ou vertical, faz parte deste
conjunto todos os elementos que estiverem neste contexto. A função Euclidiana por sua vez,
consegue encontrar elementos na diagonal, ou seja, represente um círculo com raio igual a 1.
A distância Chebyshev traça um quadrado em que cada um dos seus lados está distante em r
de seu epicentro, com isto cada um de seus lados terá o tamanho de 2r (FORSTER, 2008).

Figura 5 – Distâncias Chebyshev, Euclidiana e Manhattan representadas em um plano

(TRAINA, 2012)
 26

Como analogia ao mundo real, a Função Euclidiana corresponde ao voo do ponto P1

ao ponto P2, já a distância de Manhatan corresponde a ida de táxi de um ponto a outro, onde
seria necessário percorrer vários quarteirões para chegar ao destino. Já a distância de
Chebyshev representa o menor número de movimentos do rei em um jogo de xadrez para
movimentar-se entre o ponto P1 e P2, onde a peça deve andar uma casa por vez na horizontal,
vertical ou diagonal sendo esta ação caracterizada como um movimento.
Segundo o estudo e análise quantitativa as funções Euclidiana e Manhattan são
mencionadas em 73,7% e a Chebyshev em 42,1% dos artigos que tratam de Similaridade e
Recuperação de Imagens baseadas em conteúdo presente nas bibliotecas web IEEE, ACM,
Scopus, ISIWK e Banco de Dados de Teses da USP, o que comprova a importância destas
funções para calcular a dissimilaridade entre dois objetos (GONÇALVES; NUNES;
DELAMARO, 2010).

2.5 Métricas de similaridade para strings

Para a comparação de string por sua vez, são encontradas na literatura com maior
frequência as seguintes métricas para cálculo de distância.

2.5.1 Hamming

Comparação simples entre palavras de mesmo tamanho em que o resultado equivale ao

menor número de substituições para que uma string fique igual a outra (HAMMING, 1950).
Esta métrica é bastante utilizada para detecção de falhas na transmissão de dados onde
além das informações enviadas são também enviados bits de redundância. Através de
algoritmos de Hamming é possível validar a informação e comparar com os bits verificadores.
Em caso de pequenas falhas o próprio algoritmo consegue realizar a correção de um bit
incorreto ou na pior das hipóteses solicitar um novo envio (ARGENTA; AMORIM, 2012).
Um exemplo de utilização do algoritmo de Hamming é para a verificar se o código de
barras de um produto esta correto. O código de barras que é composto por 13 dígitos, sendo o
último deles um dígito verificador. Para este cálculo são atribuídos alternadamente os pesos 1
e 3 para cada posição e no final realizada a soma de todos estes elementos e uma divisão por
10, se o resto for igual a 0 significa que o número é válido. Com o algoritmo de Hamming é
 27

possível identificar e corrigir 100% dos casos em que houve um erro individual, ou seja, um
dos elementos foi digitado incorretamente (ARGENTA; AMORIM, 2012).

2.5.2 Levenshtein

Esta técnica calcula a Distância de Edição entre duas palavras com o auxílio de uma
matriz calcula o menor custo operacional para transformar uma palavra em outra. Este cálculo
é feito pela quantidade de substituições, inclusões e exclusões tendo cada uma destas o
mesmo custo operacional para comparação (LEVENSHTEIN, 1966).
Este algoritmo é bastante utilizado para mensurar distâncias fonéticas, variantes
linguísticas ou dialetos, tendo versões desta implementação em várias línguas como Irlandês,
Alemão, Holandês, dentre outras. Este algoritmo foi utilizado, por exemplo, para examinar 15
diferentes dialetos da Noruega a fim de identificar possíveis correlações entre eles (VALLS et
al., 2012)
A métrica de Levenshtein também tem seu uso na medicina sendo utilizada para
sequenciamento e análise de cadeia de DNA sendo mensurada a quantidade de edições
necessárias para transformar uma cadeia de DNA em outra por exemplo (BORGES; CONY;
FREITAS, 2005).

2.5.3 Jaro e Jaro-Winkler

Diferentemente da técnica Levenshtein, estas duas métricas se baseiam na quantidade e

na ordem dos caracteres comuns entre as duas strings. Segundo Cohen, Ravikumar e Fienberg
(2012) estas técnicas são recomendadas para a comparação entre nomes ou palavras curtas.
Os valores de similaridade variam entre 0 e 1, sendo 0 o valor mais discrepante e 1 para string
iguais.
Esta métrica é basicamente dividida em três operações: (1) verifica o tamanho da palavra,
(2) encontra o número de caracteres semelhantes em duas strings, e (3) encontra a quantidade
de transposições (caracteres que estão em ordem diferente em cada uma das palavras)
(HERZOG; SCHEUREN; WINKLER, 2010).
A métrica de Jaro-Winkler possui uma melhoria em relação a Jaro em que é realizada
uma correção do valor final da comparação, de forma a evitar que strings diferentes apenas na
parte final tenham uma distância grande entre elas. Esta técnica também se mostra eficiente
por considerar o conceito de prefixo na comparação das strings (FROZZA; MELLO, 2007).
 28

Esta métrica é utilizada em empresas para remover dados duplicados de lista de e-mails
com redução do custo para o envio de mailings. Agências governamentais também utilizam
muito desta métrica em pesquisas de censo para eliminar possíveis registros duplicados que
comprometeriam a confiabilidade e o resultado final de determinada pesquisa, reduzindo
assim o custo operacional por reduzir o tempo de revisão e limpeza destas informações
(HERZOG; SCHEUREN; WINKLER, 2010).

2.5.4 Monge-Elkan

Propõe uma métrica que além de calcular a distância entre os caracteres divide as strings
de comparação em tokens, e então aplica uma função de calculo de distância de edição, ao
final será gerado um valor que será a semelhança entre estas strings (GONÇALVES, 2008).
A primeira aplicação desta métrica foi utilizada para localizar artigos científicos
disponíveis no acervo da Universidade de Califórnia. Os artigos poderiam ser encontrados
através de uma combinação dos nomes dos autores, palavras chaves, títulos, resumos ou
informações bibliográficas, após identificado o nome do artigo, era procurada a afiliação, o
algoritmo então localizava o local onde este arquivo encontrava-se disponível podendo ser o
site institucional ou uma página própria do autor (MONGE; ELKAN, 1996).

2.5.5 Carla

Criada pelo Departamento de Informática da Universidade Federal do Rio Grande do Sul

procura combater uma deficiência presente nos outros métodos, esta métrica faz uma
comparação também por termos e conjunto de caracteres, sendo verificado também a ordem
em que estes termos encontram-se no texto, frase ou palavra pesquisada. Esta métrica é muito
eficiente em consultas de endereços, nomes próprios ou autores de obras (BORGES; CONY;
FREITAS, 2005).
Enquanto as métricas Euclidiana e Manhattan trabalham com objetos composto, como
exames de tomografia, nas quais são comparados, cores, texturas, formato, dimensão, as
técnicas de Hamming, Levenshtein, Jaro e Jaro-Winkler, Monge-Elkan e Carla trabalham
com uma sequência de caracteres, podendo ser utilizadas para análise de cadeia de DNA ou
comparação entre duas palavras por exemplo (BORGES; CONY, 2005).
 29

2.6 Tipos de consulta

Os tipos de consulta comparam a posição e distância de cada elemento em um plano

cartesiano, segundo Arantes et al. (2003) os tipos de consulta, ou operadores básicos, mais
comuns são Range Query e K-Nearest Neighbor Query que são mais detalhados a seguir:

2.6.1 Range Query

Recupera os objetos que diferem até determinada distância do objeto pesquisado (raio de
busca) estando sempre o objeto de referência no centro dos resultados. A Figura 6 mostra os
resultados obtidos em uma pesquisa por Range Query onde r é o raio de busca (SANTOS
FILHO et al. 2001).

Figura 6 – Ilustração representativa do Range Query

 30

2.6.2 K-Nearest Neighbor Query

Retorna a quantidade de objetos (para K > 1) mais próximos ao valor pesquisado, não
tendo o objeto de referência ao centro dos resultados. Na Figura 7 é ilustrada uma busca por
K-Nearest Neighbor em que o valor de K é igual a 5. (SANTOS FILHO et al. 2001).

Figura 7 – Ilustração representativa do K-Nearest Neighbor

Arantes et al. (2003) propõe ainda soluções híbridas como o kAndRange e kOrRange. O
primeiro caso utiliza conjunção para recuperar os valores, ou seja, os resultados devem
atender a ambos os operadores, com isto prevalece como resultado a função mais restritiva,
este algoritmo poderia ser utilizado em um texto para, quando uma palavra for digitada
errada, listar no máximo 10 palavras que difiram em até 2 caracteres. O segundo caso por sua
vez utiliza de disjunção, ou união, na qual o resultado só precisa satisfazer um dos critérios de
similaridade, um exemplo prática de uso deste algoritmo seria utilizado na área da genética
para resolver o seguinte problema: “Selecionar ao menos 20 sequências de DNA mais
parecidas com uma sequência qualquer apresentada incluindo todas as que difiram dela por
até 10 códons”. O grande benefício das soluções híbridas é que propiciam um desempenho até
40 vezes melhor do que se fossem executadas em separado.
Através de processos de indexação, as buscas podem tornar-se mais eficientes. Embora
sejam utilizados para propósitos diferentes a consulta por Range Query possui um
desempenho melhor, pois são conhecidos o domínio e o raio de pesquisa desde o início da
 31

consulta podendo através da indexação ser eliminados resultados. A consulta por vizinhos
mais próximos geralmente leva um tempo maior de processamento, pois todas as informações
devem ser verificadas e ordenadas para apresentação do resultado final (ARANTES et al.,
2003).
O presente trabalho faz a pesquisa de similaridade em textos, sendo a palavra digitada a
própria fonte para extração das características, sendo cada uma de suas letras uma
característica a ser comparada para a obtenção dos resultados. Será adotada para
desenvolvimento a métrica e algoritmo de Jaro-Winkler por ser a que melhor trabalha com
palavras individuais e por não ter o tamanho da palavra como um limitador, sendo retornadas
10 palavras similares sendo estas selecionadas através do tipo de consulta K-Nearest
Neighbor.
 Capítulo

33

3 Metodologia

Este capítulo tem por objetivo descrever a tecnologia utilizada assim como cada uma
das etapas partindo da criação do Banco de Dados e finalizando com os testes e correções
provenientes do desenvolvimento. A aplicação funciona de forma semelhante a um corretor
ortográfico, utilizando o algoritmo Jaro-Winkler e o K-Nearest Neighbor como o tipo de
busca. Neste capítulo são descritos os passos.

3.1 Tecnologia

Para o desenvolvimento do algoritmo de seleção por similaridade é utilizada a

linguagem ASP.NET, com a utilização da ferramenta de desenvolvimento Microsoft Visual
Studio 2010 e o Sistema Gerenciador de Banco de Dados (SGBD) Microsoft SQL Server
2008.
A linguagem ASP.NET foi escolhida por ser uma linguagem que possui uma série de
recursos e funcionalidades que facilitam o desenvolvimento com interface web. É utilizado
também o framework Entity Framework, que propicia uma rápida e fácil conexão com o
banco de dados SQL Server 2008, permitindo assim uma comunicação simples entre Banco
de Dados e aplicação.
O Entity Framework é oficialmente recomendado pela Microsoft por propiciar uma
das melhores soluções para acesso ao Banco de Dados, ele permite o mapeamento objeto-
relacional que permite trabalhar com dados relacionais usando objetos específicos do
domínio. Eliminando assim a necessidade de codificar a interface de acesso ao Banco de
Dados (MSDN, 2013).
O Entity Framework é um framework de padronização, persistência e geração de
códigos que faz um mapeamento direto da base de dados, sendo criada uma interface com o
Banco de Dados em si, sendo cada uma de suas tabelas vistas pela aplicação como uma
classe, podendo ser realizadas buscas com LINK Expressions que utilizam uma sintaxe bem
parecida com o próprio SQL. O Entity Framework foi adotado por ter um bom desempenho
em sistemas ou aplicações simples.
 34

3.2 Etapas de desenvolvimento

A Figura 8 descreve cada uma das etapas de desenvolvimento da aplicação tratada

neste projeto.

• Início
• Criação do Banco de Dados e inclusão dos registros
• Consulta com filtro para eliminar resultados sem relevância
• Implementação do algoritmo Jaro-Winkler em ASP.Net
• Melhorias e adaptações do algoritmo
• Implementação do tipo de consulta K-Nearest Neighbor
• Criação de mecanismo de busca assíncrona
• Interface com o usuário
• Testes e correções
• Fim

Figura 8 – Etapas de desenvolvimento

As próximas subseções detalham o desenvolvimento de cada uma destas etapas, após

o desenvolvimento e testes serão analisados os resultados finais e geradas as conclusões.

3.2.1 Criação do Banco de Dados e inclusão dos registros

O primeiro passo para a implementação consiste na criação do Banco de Dados, sua

estruturação e obtenção dos dados a serem tratados.
O Banco de Dados possui uma única tabela denominada ‘Dicionario’ contendo dois
campos, Id do tipo ‘int’ e com ‘auto incremento’ sendo a chave primária da tabela, além do
campo ‘Palavra’ sendo um nvarchar de 50 posições.
Embora a aplicação tenha uma validação para evitar palavras repetidas a criação de
uma chave primária é uma solução para melhorar o desempenho e a indexação por parte do
Framework.
 35

A tabela é preenchida com a listagem de palavras do dicionário brasileiro sendo estes

registros utilizados para as consultas da aplicação.

3.2.2 Consulta com filtro para eliminar resultados sem relevância

Como a aplicação sempre trabalha com uma quantidade grande de registros a cada
consulta do usuário, o desempenho seria um dos maiores problemas e que poderia tornar a
aplicação inviável para outros fins que não seja o acadêmico.
Para resolver este problema é realizado um único acesso a banco que traz todos os
resultados, sendo então realizados diretamente na aplicação os filtros prévios antes da
realização do algoritmo de similaridade e ordenação dos elementos. Este filtro tem por
objetivos eliminar os resultados discrepantes e sem nenhuma relevância, sendo aplicado
diretamente na lista de palavras obtidas, sendo os resultados compostos por um loop que
funciona de forma semelhante a uma consulta de elementos com o operador ‘ou’, esta
consulta é melhor exemplificada nos parágrafos abaixo utilizando a sintaxe ASP.NET C#.
Supondo que sejam digitados para a consulta os caracteres ‘tes’, este primeiro filtro
faz agrupamento em pares para a realização de uma consulta que traz resultados relevantes,
ou seja, neste caso são utilizadas duas clausulas OR, ficando a consulta da seguinte forma:
SELECT id, palavra FROM Dicionario WHERE (palavra like ‘%te%’) OR (palavra
like ‘%es%’)
É possível perceber pelo comando criado que os resultados discrepantes são
desconsiderados, para a posterior busca por similaridade. A quantidade de cláusulas ‘ou’
utilizada sempre é o tamanho da string de consulta menos um, no exemplo foi possível
perceber isto visto que a palavra ‘tes’ possui três letras e foram utilizadas duas clausulas ‘or’.

3.2.3 Implementação do algoritmo Jaro-Winkler em ASP.Net

A criação do algoritmo de similaridade Jaro-Winkler é realizada em duas grandes

etapas de desenvolvimento. A primeira delas consiste em obter o algoritmo já existente na
literatura em C e reescrevê-lo em linguagem ASP.Net, implementando recursos em jQuery,
Ajax e cache para permitir que o desempenho seja viável.
A proposta inicial sugere a utilização como base do algoritmo em C presente nos
anexos do artigo de Borges, Cony e Freitas (2005).
 36

3.2.4 Melhorias e adaptações do algoritmo

Como o algoritmo é desenvolvido para trabalhar com palavras de língua portuguesa

uma melhoria é desenvolvida para trabalhar exclusivamente com os caracteres acentuados,
sendo também considerada a similaridade destes elementos.
Um exemplo prático desta necessidade é visto ao digitar os caracteres ‘esta’ pois, após
a implementação da melhoria, é encontrado com maior relevância tanto os termos ‘esta’
(pronome demonstrativo feminino) e ‘está’ (presente do indicativo do verbo estar).
Na literatura pesquisada embora seja possível encontrar vários artigos que utilizam o
algoritmo Jaro-Winkler não foi encontrado nenhum artigo que tenha se preocupado ou tenha
dado algum enfoque prático ou teórico para a acentuação.
O algoritmo também não faz a distinção entre caracteres maiúsculos e minúsculos,
sendo ambos considerados iguais para a aplicação.

3.2.5 Implementação do tipo de consulta K-Nearest Neighbor

O tipo de consulta selecionada é a K-Nearest Neighbor na qual a aplicação trabalha

basicamente com uma lista de string que contem todas as palavras encontradas de acordo com
o termo digitado e uma lista na qual ficam todos os resultados ordenados da maior para a
menor relevância, podendo variar entre 1e 0. A lista possui dois atributos dos tipos string e
double, sendo respectivamente a palavra e o valor de sua similaridade, e com ordenação do
maior para o menor valor de similaridade.
Para permitir um melhor desempenho é feito primeiramente a verificação do valor da
similaridade de cada palavra sendo este objeto adicionado na lista, ao término da verificação
de todos os elementos é aplicada a ordenação pela relevância, sendo então pegos os dez
primeiros resultados.

3.2.6 Criação de mecanismo de busca assíncrona

Para melhorar o desempenho o sistema de busca é feito de forma assíncrona, ou seja,

os processamentos são realizados de forma transparente ao usuário não havendo
recarregamento das páginas após o término da execução.
Este tipo aplicação permite que a cada interação do usuário seja criado um novo
processo que fica em execução e ao seu término são exibidos os resultados logo abaixo da
caixa de texto com o auxílio de jQuery, JavaScript, Ajax e JSON. Para evitar processamento
 37

desnecessário caso uma interação seja feita enquanto um processo ainda estiver em execução
este será interrompido permitindo que o novo processo faça uso da memória e processador.

3.2.7 Interface com o usuário

O sistema possui uma interface simples contendo um único campo para digitação da
palavra, a cada interação por parte do usuário o sistema faz a consulta e a seleção por
similaridade e exibe os resultados.
A aplicação traz as 10 palavras mais similares após o cálculo da métrica Jaro-Winkler,
de acordo com os termos pesquisados. Estes resultados são exibidos logo abaixo da caixa de
pesquisa, e em ordem decrescente de proximidade sendo cada um dos resultados um link que
poderá ser clicado e com isto realizando a substituição do termo previamente digitado.
A aplicação tem um botão chamado ‘Adicionar’ que tornará possível inserir novos
termos no banco de dados, permitindo assim a inclusão de novas palavras que não estejam
contidas no contexto inicial, tais como gírias, abreviações ou estrangeirismos. A Figura 9
ilustra a interface utilizada no sistema.

Figura 9 – Interface da aplicação

 38

Embora o estudo e implementação tenham cunho científico e acadêmico esta solução

pode ser implementada para funcionar como um WebService ou como módulo de um sistema
web ou desktop.

3.2.8 Testes e correções

Após a realização de todas as etapas descritas acima é realizada uma rotina de testes e
correções, o principal enfoque das correções é para resolver problemas de desempenho,
exceções e carga.
Uma das possíveis soluções que deverá ser implementada será para o tratamento de
números ou caracteres inválidos, desta forma ao digitar uma data, por exemplo 14/07/2012, a
aplicação não consegue comparar estes caracteres com os registros literais presentes na
aplicação, visto que não seria possível prever uma similaridade em busca de correções.
Os testes de desempenho por sua vez, são realizados através da pesquisa de vários
termos para calcular o tempo entre a digitação dos termos e o resultado da busca.
A última etapa de teste é o teste de carga, onde várias instâncias (navegadores) faz
acesso a aplicação para ver como ela se comporta em relação a múltiplos acessos, embora
tenham os limitadores de tamanho de banda e desempenho de disco.
Em caso de grandes problemas de desempenho ou carga uma solução seria abrir mão
das vantagens e facilidades do Entity Framework e realizar uma solução em que a consulta
seja feita diretamente em banco de dados, eliminando assim a dependência de um Framework
para este fim.
O tópico seguinte relata todas as etapas realizadas para o desenvolvimento e
concepção da aplicação.

3.3 Desenvolvimento

3.3.1 Banco de Dados

O desenvolvimento do projeto iniciou-se com a criação do Banco de Dados e inclusão

dos registros, para isto foi utilizado o Sistema Gerenciador de Banco de Dados Microsoft
SQL Server 2008 Management Studio. Nesta etapa foi criada a base de dados chamada
‘Similaridade’, sendo então adicionada a tabela de nome ‘Dicionario’ com as colunas ‘Id’
 39

(chave-primária do tipo inteiro e com auto-incremento) além do campo ‘Palavra’ (do tipo
literal).
As palavras que popularam a tabela dicionário foram recuperadas do complemento
‘Verificador Ortográfico para Português do Brasil’ desenvolvido para o Mozilla Firefox,
desenvolvido por Vinícius Della Líbera e Adriana Quintanilha (2013). Através deste
complemento foram recuperadas 264.315. Das palavras encontradas foram removidas as
abreviações (como por exemplo: ‘sr.’, ‘dr.’), por não ter relevância para o trabalho.

3.3.2 Aplicação

Ao término da criação da Base de Dados foi dado início a criação da aplicação no

software Microsoft Visual Studio 2010. Com o objetivo de criar uma aplicação com interface
web foi criado um projeto do tipo ‘Web site’. Para facilitar a interface de comunicação entre
aplicação e banco de dados, foi criada uma Entidade de Modelagem de Banco de Dados
utilizando o Entity Framework, sendo gerado um arquivo com extensão ‘edmx’ responsável
pela comunicação entre aplicação e Banco de Dados.

3.3.3 Desempenho

Embora o estudo não tenha como foco principal o desempenho, é tomado um cuidado
especial em todas as etapas do desenvolvimento, de modo que a aplicação realize todas as
requisições e processamento em um tempo aceitável. Para que isto tornasse possível várias
alternativas foram implementadas e testadas, abaixo são enumeradas as soluções
implementadas sendo enumerados os pontos fortes e fracos sendo justificado o motivo da
escolha.

3.3.4 Entity Framework

A primeira solução foi a utilização somente do Entity Framework utilizando consultas

com expressão Link, a ideia desta implementação faria com que a cada novo termo
pesquisado seria feita uma nova requisição no Banco de Dados para encontrar as palavras que
continham ao menos uma dupla de palavras pesquisadas, por exemplo, ao digitar o termo ‘tes’
seria criada uma expressão Link que funcionaria de forma semelhante ao operador ‘ou’ que
localizariam as palavras que continham ‘te’ ou ‘es’.
 40

O desenvolvimento desta solução mostrou-se bastante trabalhoso, por não haver uma
forma simples para realizar consultas utilizando este tipo de expressão juntamente com
cláusulas ‘ou’ dinâmicas, ou seja, não era possível realizar uma única requisição ao banco de
Dados para realizar a pesquisa. Com isto a única medida possível era realizar uma consulta ao
Banco de Dados para cada dupla de palavras, com isto a quantidade de consultas era
proporcional ao tamanho do termo digitado, tendo a relação: (tamanhoDaPalavra – 1) * 2,
com isto ao inserir uma palavra com 5 caracteres seriam feitas 4 consultas ao Banco de
Dados, esta solução por fim teve desempenho inferior quando comparado as soluções abaixo.

3.3.5 Solução híbrida utilizando Entity Framework e RaptorDB

Como proposta para resolver o problema de requisições múltiplas e desempenho, foi

visto como alternativa o software open source denominado RaptorDB. O RaptorDB é uma
base NoSql, baseada em JSON, que permite a consulta através de expressões Link sendo feito
um mapeamento da aplicação.
Para a implementação foi feito o download do software diretamente através do site da
comunidade CodePlex, responsável pelo seu desenvolvimento. A implantação e incorporação
das classes foi simples, tendo apenas que importar as classes para permitir o funcionamento
da aplicação. Todas as classes foram implementadas com exceção dos testes unitários que não
será utilizado por não ser o foco do trabalho.
Após a conclusão da implantação do RaptorDB foi pensado em utilizá-lo não como
base principal das palavras, mas sim como uma interface que permitisse a coleta de dados
junto ao SQLServer uma única vez, e então todas as novas requisições seriam feitas
diretamente no arquivo em que ele armazena as informações.
Nos testes iniciais de desempenho o RaptorDB mostrou ser uma boa solução para
suprir esta necessidade, porém a sua estrutura mostrou-se limitada para a implementação da
solução proposta, isto porque as consultas deveriam utilizar termos exatos, desta forma não
era possível realizar uma validação se determinada palavra continha um conjunto de
caracteres. Esta limitação por fim, acabou inviabilizando o seu uso.
 41

3.3.6 Solução híbrida utilizando Entity Framework, listas e armazenamento

em cache

Por fim, foi realizada uma nova tentativa de implementação desta vez utilizando uma
solução híbrida que concilia as consultas à base de dados utilizando o Entity Framework, uma
lista de palavras para execução no sistema e o cache nativo da linguagem C# para
armazenamento dos resultados.
A proposta agora utiliza o Entity Framework apenas como interface de comunicação
entre aplicação e Banco de Dados, e visando diminuir a quantidade de acessos e requisições
ao disco é realizada uma única consulta que traz todas as palavras armazenando-as em uma
lista de strings para uso da aplicação. Esta listagem é armazenada em cache que permite a
recuperação de seu conteúdo sem que seja necessário recorrer ao Banco de Dados.
Esta lista de palavras é então utilizada durante todo o tempo de execução da aplicação,
sendo recriada a cada nova execução. O cache, por sua vez, foi definido para ter validade de
um dia, ou seja, o sistema fará uma nova requisição somente ao término deste período, sendo
então recriado o cache.

3.3.7 Implementação do algoritmo Jaro-Winkler

A proposta inicial do trabalho era reescrever o código em C presente no artigo de

Borges, Cony e Freitas (2005) e convertê-lo para C#, porém o código original não foi
compilado em nenhum dos compiladores utilizados, foram testados o DEV C++ e Turbo C.
Como solução para resolver o problema, foi encontrado o algoritmo Jaro-Winkler em
linguagem VB.NET na comunidade VB.NET Brasil, e então todo reescrito para a linguagem
C# (VB.NET Brasil, 2012).
Apesar das linguagens apresentem sintaxes semelhantes, a reescrita mostrou-se
trabalhosa. Parte das bibliotecas utilizadas não foram encontradas, sendo necessárias
adaptações do código fonte para garantir o pleno funcionamento.
Após a implementação foram realizados testes aleatórios para verificar a
funcionalidade do algoritmo, esta etapa inicial de teste consistiu basicamente de apresentar as
entradas e verificar se as palavras de saída possuíam a relevância esperada. Nesta etapa foi
possível verificar que os caracteres acentuados não eram tratados, e desta forma palavras com
grande similaridade acabavam sendo vistas com grande distância.
 42

Para solucionar esta questão foi realizada uma melhoria para a função Jaro-Winkler
em que todos os caracteres acentuados eram desconsiderados durante a verificação da
distância. Para a remoção dos acentos foi utilizada a função proposta por Schimanco (2011)
que faz a remoção por base bytes de acentuação presente em cada caractere.

3.3.8 Funcionamento do algoritmo

Ao carregar a página o algoritmo primeiramente valida se a listagem contendo todas

as palavras do dicionário já está armazenada em cache, caso não esteja, o algoritmo faz uma
busca de todas as palavras armazenadas no Banco de Dados e as armazena em uma listagem
de string e armazena os resultados em uma lista de strings global chamada ‘palavras’ e então
chama o método ‘RenovarCache()’. Caso as palavras já estivessem armazenadas em cache a
aplicação recupera estes valores e armazena os resultados também na lista de strings
‘palavras’.
A função RenovarCache(), por sua vez, primeiramente remove um cache antigo caso
já exista e depois armazena a listagem de palavras em um cache nomeado como ‘dicionario’
este cache foi definido para expirar em um dia.
Ao digitar cada termo o sistema chama a função para RecuperarRelevancia() que
retornará uma listagem de palavras ordenadas pela similaridade através do algoritmo Jaro-
Winkler.
É possível também adicionar uma nova palavra, gíria ou abreviação ao dicionário já
existente, quando o botão de adicionar é clicado o sistema primeiramente verifica se a palavra
já existe na listagem presente no sistema, caso não exista ela é então inserida no Banco de
Dados e também na listagem, após estas duas etapas o sistema também chama a função
RenovarCache() que remove o cache já existente e o recria com a nova listagem de palavras.
A função RecuperarRelevancia() é divida em três etapas:

Etapa 1: Consulta com filtro para recuperar resultados sem relevância

Nesta etapa é recuperada a palavra digitada pelo usuário e feita uma divisão a cada
dois termos que é armazenado em uma lista de strings chamada ‘trechos’. O tamanho da
listagem com os trechos sempre será o tamanho da palavra menos um.
Para armazenar os resultados na lista, o sistema realiza um loop que recupera a
posição de um caractere e recupera os próximos dois caracteres subsequentes até que a
palavra chegue ao fim.
 43

Ao término é então realizada uma distinção de todos os trechos para eliminar

resultados idênticos, isto é feito para diminuir a quantidade de processamento, pois pode
diminuir a quantidade de requisições as listagens para recuperar por esta relevância.
Por fim é feita a consulta de cada trecho na listagem principal de palavras, a busca é
feita em um laço de repetição sendo para cada termo verifica quais palavras contém este
conjunto de caracteres sendo armazenados os resultados na listagem denominada ‘relevancia’.
Ao término do laço também é feita a distinção de todas as palavras encontradas. Realizada
esta triagem inicial estas palavras terão o cálculo de distância realizado, dando início a etapa
número dois.

Etapa 2: Consulta de distância para cada termo

Para cada palavra recupera através do filtro descrito no item um, é acionada a função
DistanciaJaroWinkler() que faz todos os cálculos de similaridade e retorna um objeto da
classe DistanciaJW que possui as propriedades: palavra e distância. A palavra é o termo
propriamente dito, já a distância armazena um valor decimal presente entre 0 e 1 que
representa a distância entre a palavra informada e o termo recuperado.
Após o cálculo de todas as palavras relevantes, o sistema faz uma reordenação
utilizando a distância em ordem decrescente, ou seja, trazendo primeiramente os resultados
com maior relevância.

Etapa 3: Armazenamento em arquivo

A terceira etapa foi implementada para facilitar os testes e para permitir uma
visualização mais clara e contundente dos resultados.
Nesta etapa é chamada a função ‘ArmazenarEmArquivo()’ que recebe como
parâmetro a listagem da classe DistanciaJW e a palavra utilizada para a pesquisa, sendo
gerado um arquivo com extensão ‘.csv’ contendo a palavra e o valor de sua distância também
armazenados em ordem decrescente de distância.
 44

3.3.9 Função para cálculo da distância Jaro-Winkler

A função de cálculo de distância recebe sempre dois parâmetros, o termo digitado e a

palavra a ser comparada. Para evitar resultados discrepantes em palavras acentuadas
primeiramente é chamada a função que remove os acentos para ambas as palavras.
Como a métrica Jaro-Winkler surgiu do método implementado por Jaro,
primeiramente é feita a comparação por Jaro para depois aplicar a melhoria proposta por
Winkler. A primeira comparação verifica se ambas as palavras são iguais, neste caso
retornando o valor ‘1’ que representa o maior valor. Caso as palavras sejam diferentes, então
é realizado o cálculo de similaridade.
Para este cálculo é acionada a função ‘RecuperarCaracteresComuns()’ que recebe
como parâmetro as duas palavras e também o tamanho médio arredondado da maior string.
As comparações são realizadas comparando caractere por caractere, na qual o loop percorre
todos os elementos da primeira palavra informada. A comparação é realizada até o término da
segunda palavra ou caso o caractere esteja a ‘x’ posições de distância a partir da posição atual,
onde ‘x’ é igual ao tamanho médio arredondado da maior string. Caso o algoritmo consiga
encontrar o caractere básico de comparação na segunda palavra, ele é concatenado em uma
variável do tipo string para o retorno. Estes procedimentos são realizados até o término do
loop principal de iteração.
Para que seja possível mensurar as transposições o algoritmo aciona novamente a
função de ‘RecuperarCaracteresComuns()’ desta vez passando as palavras em posições
invertidas, ou seja, a variável ‘palavra1’ passa a ser a ‘palavra2’, e a ‘palavra2’ agora é a
‘palavra1’. Supondo, por exemplo, que seja passadas duas palavras: ‘oi’ e ‘io’ neste caso a
primeira vez a função for chamada ela fará as comparações por base na primeira palavra,
sendo o termo ‘oi’ a base de comparação, neste exemplo como todos os caracteres são
comuns a função retornará ‘oi’. Já quando chamamos a função pela segunda vez, e invertemos
os parâmetros, a comparação toma como base o termo ‘io’ e comprovando que todos os
caracteres são comuns, é retornado ‘io’. Por base neste exemplo é possível perceber que a
função embora tenha realizado os mesmos procedimentos, o seu retorno foi diferente, e é
exatamente esta diferença que permite o cálculo das transposições.
Caso as palavras sejam bastante discrepantes e não seja encontrada nenhuma
semelhança entre elas, é retornado o valor ‘0’ que representa o menor valor.
Havendo valores semelhantes, é realizado o cálculo de transposições. Para isto é
realizado um loop que percorre cada um dos caracteres comuns retornados da função
 45

‘RecuperaCaracteresComuns()’ e verifica se a sua posição é igual a posição resultante da

segunda comparação, caso sejam diferentes é incrementado em 1 o valor da variável de
quantidade de transposições.
Após recuperar os resultados é realizada a equação de Jaro, exibida na Figura 10, para
recuperar o valor total da similaridade.

Figura 10 – Equação de Jaro

Sendo:
- quantidadeComum: variável que armazena a quantidade de caracteres comuns
encontrados entre as duas palavras.
- palavra1.Length – tamanho da primeira palavra passada para a função.
- palavra2.Length – tamanho da segunda palavra passada para a função.
- transposicoes – quantidade de transposições necessárias referente aos caracteres
comuns.
Por fim o algoritmo faz um último cálculo para aumentar o grau de similaridade dos
primeiros caracteres. Este aumento pode ser de até 40% do valor que foi perdido durante o
cálculo da similaridade, ou seja, caso a similaridade inicial seja de 90 pontos mas a palavra
tenha os quatro primeiros caracteres iguais, a similaridade será aumentada em 40% dos 10
pontos restantes, sendo acrescidos 4 pontos da similaridade inicial, chegando a 94 pontos.

3.3.10 Mudança de arquitetura para integração com o jQuery

Como última etapa do desenvolvimento foi dado início a implementação de código em

JavaScript, jQuery e Ajax para permitir a comunicação assíncrona para exibição dos
resultados.
Após uma série de tentativas e testes sem sucesso foi visto como alternativa a
mudança de arquitetura para o padrão MVC (Model, View, Controller) que permite uma
integração mais simples com a biblioteca do Ajax e jQuery.
A principal dificuldade da mudança de arquitetura foi em relação ao armazenamento
em cache pois a biblioteca utilizada para a arquitetura ‘Web Forms’ não funcionava com o
MVC sendo necessário utilizar a biblioteca ‘HttpContext’.
 46

Após a integração, foi acrescentada a biblioteca ‘UI’ do jQuery para tornar possível o
desenvolvimento das funções que retornassem os resultados de forma assíncrona. O
desenvolvimento foi baseado no modelo de implementação encontrado no blog da MSDN
(Microsoft Developer Network) na qual o material propunha a utilização do jQuery para criar
um autocomplete para um campo do tipo texto (MSDN, 2012)
A função em jQuery que faz a comunicação de forma assíncrona com o servidor é
mostrada na Figura 11.

Figura 11 – Função jQuery para obtenção de retorno assíncrono

A função primeiramente acrescenta a propriedade ‘autocomplete’ para o campo

contido no página que possui o identificador ‘palavra’, feito isto para cada nova requisição
(evento de digitar um caractere) é acionado via Ajax a url relativa ao conteúdo presente em
‘home/pesquisar’, sendo passado como parâmetro uma variável de nome ‘palavra’ que
contém o conteúdo presente no input de mesmo nome, o código ASP.Net que retorna os
resultados é apresentado na Figura 12. Após a obtenção do retorno, é acrescida uma listagem
de palavras armazenadas. Caso seja efetuado o clique em alguma destas palavras é acionado o
 47

evento select que acrescenta o respectivo conteúdo na caixa de texto e limpa o conteúdo da
caixa de texto ‘palavra’.

Figura 12 – Método de retorno das palavras relevantes

Ao ser acionado o método de pesquisa, é recuperada a listagem de todas as palavras

contidas em cache ou no Banco de Dados, sendo então passados por parâmetro a listagem e o
termo inserido pelo usuário para a função que recupera a similaridade.
Feito isto é utilizada uma expressão Lambda que recupera apenas o atributo ‘Palavra’
da lista e recupera os primeiros dez valores, sendo retornados no formato JSON para
utilização através da View.
Outro método apresentado na página principal da aplicação tem a função de adicionar
novas palavras no Banco de Dados para posterior uso através da aplicação. Este botão
também aciona um método assíncrono que faz a inclusão do termo no Banco de Dados e
também na caixa de teste. É possível visualizar esta funcionalidade através do código contido
na Figura 13.

Figura 13 – Função jQuery para inclusão de novas palavras

 48

O método de adicionar tem sintaxe semelhante com o método jQuery que obtém os
resultados de forma assíncrona, pois ambos utilizam de implementação em Ajax para
realizarem a requisição junto ao Controller.
O botão adicionar, conforme mencionado anteriormente, tem como finalidade inserir
uma nova palavra no Banco de Dados e também na caixa de texto da aplicação.
Primeiramente é acionada a função ‘home/adicionar’ sendo passado como parâmetro o valor
presente no input ‘palavra’, na sequência é então inserido o mesmo valor na caixa de texto
que armazena os conteúdos apresentados, a última etapa consiste em limpar o elemento
‘palavra’ para permitir uma nova inserção.
A Figura 14 exibe a codificação realizada para permitir que o controlador faça a
inclusão do conteúdo no Banco de Dados.

Figura 14 – Função jQuery para inclusão de novas palavras

Para adicionar uma nova palavra a aplicação primeiramente recupera a listagem

contendo todas as palavras existentes no Banco de Dados. Para evitar que uma palavra seja
inserida em duplicidade é feita uma validação para ver se a palavra já não existe na listagem,
e consequentemente, também não existe na base de dados. Verificado que a palavra é
realmente nova é feita a inclusão do novo termo, utilizando Entity Framework, diretamente na
 49

tabela ‘Dicionario’. Ao término da inclusão a palavra também é adicionada na listagem e

acionada a função que faz a consulta de todas as palavras existentes e as armazena em cache.
 Capítulo

50

4 Resultados

Para verificar os resultados obtidos pelo algoritmo foi criado um método que
armazena todas as palavras obtidas após o filtro inicial e o seu valor de similaridade em um
arquivo com extensão ‘csv’.
Este arquivo teve grande importância durante toda a etapa de testes, pois tornou
possível identificar que por padrão o algoritmo de Jaro-Winkler considerava o valor de
similaridade diferente entre palavras acentuadas. Por exemplo, ao pesquisar o termo ‘esta’ a
palavra ‘está’ aparecia na posição 344 com apenas 88,3 pontos de similaridade, atrás de
palavras como ‘estação’ (91,42 pontos) e ‘estadual’ (90 pontos).
Com os resultados presentes em uma tabela tornou mais viável a verificação dos
valores para estudo e entendimento do algoritmo Jaro-Winkler, através da análise foi possível
perceber que o algoritmo mostrou-se bastante eficaz e que o seu uso pode ser incorporado em
diversos tipos de aplicações, servindo como um autocomplete e com a vantagem de também
prever possíveis erros de digitação.
Um dos pontos fracos e que acabou influenciando na análise dos resultados foi a
listagem de palavras obtidas. Como a listagem possui mais de 260.000 palavras os resultados
nem sempre pareciam satisfatórios pois eram exibidas uma série de termos que não são
comumente utilizados, porém em todas as situações o algoritmo funcionou e obteve os
resultados esperados.
A consulta mais onerosa realizada para a aplicação é feita ao digitar somente o
caractere ‘a’, neste caso são recuperadas 186.994 palavras que se candidatam para ser a
palavra com maior relevância. Após a realização da similaridade palavra por palavra, a
aplicação retorna em aproximadamente 2 segundos, os 10 resultados com maior relevância.
Que são ‘ab’, ‘ac’, ‘ad’, ‘ag’, ‘ah’, ‘ai’, ‘aí’, ‘al’, ‘am’ e ‘ao’, e neste caso em específico todas
possuem relevância igual a 85, sendo a ordem alfabética adotada como segundo critério de
ordenação.
 51

Outro exemplo, que permite mostrar o comportamento da aplicação foi feito ao digitar o

termo ‘similaidade’, supondo que o usuário tenha cometido algum erro de digitação, neste

caso o algoritmo traz as seguintes palavras por ordem de relevância exibidas na Tabela 1.

Valor S I M I L A I D A D E

98,3 S I M I L A R I D A D E

92,1 S I M I L I D A D E

90,9 S Í M I L E

90,5 S I M I L I T U D E

90,2 S I M I Í D E O

89,0 S Í M I L

88,0 S I M I L A R

88,0 S Í M I L E S

87,0 S I M I L I A

86,9 S I F Í L I D E

Tabela 1 – Resultados obtidos pelo termo ‘similaidade’

Através deste exemplo é possível perceber que o algoritmo de Jaro-Winkler, embora

tenha trazido os resultados, apresenta uma lógica que pune palavras que possuem novos

caracteres mesmo se existe maior incidência de caracteres semelhantes.

Esta situação é possível perceber através da comparação dos resultados obtidos pelas

palavras ‘símile’ e ‘similitude’ note que o primeiro termo possui seis caracteres comuns em

comparação com ‘similaidade’ e nenhuma inclusão, já a palavra ‘similitude’ possui oito

caracteres comuns mas por conter a inclusão de dois caracteres ‘tu’ o valor de sua

similaridade ficou inferior.

52
 53

5 Conclusões

O algoritmo Jaro-Winkler em conjunto com as tecnologias utilizadas: C# ASP.Net

MVC, Entity Framework, jQuery, JSON e Ajax, mostraram ser uma solução bastante eficaz
para permitir a implementação do algoritmo de forma a torná-lo viável para uso acadêmico e
até mesmo corporativo.
O tempo médio de espera para a obtenção dos resultados fica abaixo de dois segundos
em um ambiente favorável, desconsiderando fatores externos como, por exemplo, velocidade
de banda.
Este trabalho visa ainda prover uma contribuição de código ao implementar o
algoritmo de Jaro-Winkler em C# visto que a implementação nesta linguagem não foi
encontrada na literatura pesquisada.
Pelos testes executados neste trabalho conclui-se enfim, que o algoritmo de Jaro-

Winkler, embora tenha apresente bons resultados, nem sempre premiará a “melhor” palavra

presente no dicionário pois apresenta uma lógica que pune palavras que possuem novos

caracteres mesmo se existe maior incidência de caracteres semelhantes. Este fato em alguns

casos leva a palavras não desejáveis. Fica a proposta de realização de testes supervisionados

por especialistas em línguas para mapear melhor o comportamento do algoritmo.

O presente trabalho abre o leque para uma série de trabalhos futuros, como: criação de
WebService para incorporar a similaridade a sites; criação de plugin para navegadores;
implementação de nova métrica para comparação dos resultados ou até mesmo propor
melhorias para o algoritmo de Jaro-Winkler.
 54

Referências
ALVES, Cláudio Diniz. Metadados para a Recuperação de Imagens na WEB: utilizando o
software ADOBE BRIDGE. PontodeAcesso, v. 6, n. 1, p. 32-48, 2012.

ARANTES, Adriano S. et al. Operadores de seleção por similaridade para sistemas de

gerenciamento de bases de dados relacionais. XVIII Brazilian Simposium on Database, p.
341-355, 2003.

ARGENTA, Daniel; AMORIM, E. Rafael. ESTUDO E IMPLEMENTAÇÃO DE DÍGITOS

VERIFICADORES. 2012.

BEYER, Kevin et al. When is “nearest neighbor” meaningful?. In: Database Theory -
ICDT’99. Springer Berlin Heidelberg, 1999. p. 217-235.

BORGES, Eduardo Nunes; CONY, Carlos Akcelrud. Consultas por Similaridade em SGBDS
Comerciais: Estendendo o PostgreSQL. 90f. Projeto de Diplomação (Engenharia de
Computação), FURG, Rio Grande, 2005.

BORGES, Eduardo N.; CONY, Carlos Akcelrud; FREITAS, A. L. C. Utilização de

algoritmos de busca por similaridade em SGBDs comerciais. SIRC 2005, 2005.

CASTRO, Armando Antonio Monteiro; PRADO, Pedro Paulo Leite. Algoritmos para
reconhecimento de padrões. 2001.

CLESIO, 2012. Medidas de distância. Disponível em:

<http://mineracaodedados.wordpress.com/2012/02/27/medidas-de-distancia/> Acesso em: 20
de abril de 2013

CHA, Sung-Hyuk. Comprehensive survey on distance/similarity measures between

probability density functions. City, v. 1, n. 2, p. 1, 2007.

COHEN, William W.; RAVIKUMAR, Pradeep; FIENBERG, Stephen E. A comparison of

string distance metrics for name-matching tasks. In: Proceedings of the IJCAI-2003
Workshop on Information Integration on the Web (IIWeb-03). 2003.

CURA, Luis Mariano Del Val. Um modelo para recuperação por conteúdo de imagens de
sensoriamento remoto. 2002. Tese (Doutorado) - Curso de Ciência da Computação,
Departamento de Instituto de Computação, Universidade Estadual de Campinas, Campinas,
2002.

FORSTER, Carlos Henrique Q. Introdução à Análise de Padrões. 2008. Curso de Ciência

da Computação, Departamento de Divisão de Ciência da Computação, Instituto Tecnológico
de Aeronáutica, São José dos Campos, 2008.

FROZZA, Angelo Augusto; MELLO, R. dos S. Um método para determinar a

equivalência semântica entre esquemas GML. 2007. Tese de Doutorado. Universidade
Federal de Santa Catarina, Centro Tecnológico. Programa de Pós-graduação em Ciência da
Computação.
 55

GONÇALVES, Rodrigo et al. Algoritmos de pré-processamento para uniformização de

instâncias XML heterogêneas. 2012.

GONÇALVES, Vagner M.; NUNES, Fátima LS; DELAMARO, Márcio E. Avaliação de

Funções de Similaridade em Sistemas de CBIR: Uma Revisão Sistemática. 2010.

GONZAGA, Adilson. Estudo e avaliação das características dinâmicas do olho humano para
aplicações biométricas. 2012.

HAMMING, Richard W. Error detecting and error correcting codes. Bell System technical
journal, v. 29, n. 2, p. 147-160, 1950.

HERZOG, Thomas H.; SCHEUREN, Fritz; WINKLER, William E. Record linkage. Wiley
Interdisciplinary Reviews: Computational Statistics, v. 2, n. 5, p. 535-543, 2010.

LEVENSHTEIN, Vladimir I. Binary codes capable of correcting deletions, insertions and

reversals. In: Soviet physics doklady. 1966. p. 707.

LÍBERA Vinícius Della, QUINTANILHA Adriana. 2013. Verificador Ortográfico para

Português do Brasil. Disponível em: <https://addons.mozilla.org/pt-
br/firefox/addon/verificador-ortogr%C3%A1fico-para-p/> Acesso em: 31 de agosto de 2013.

MONGE, Alvaro E.; ELKAN, Charles. The field matching problem: Algorithms and
applications. In: Proceedings of the second international Conference on Knowledge
Discovery and Data Mining. 1996. p. 267-270.

MSDN, Microsoft Developer Network. 2012. ASP.NET MVC & jQuery UI autocomplete.
Disponível em: <http://blogs.msdn.com/b/ukadc/archive/2012/04/24/asp-net-mvc-amp-
jquery-ui-autocomplete.aspx> Acesso em: 01 de novembro de 2013

MSDN, Microsoft Developer Network. 2013. Entity Framework. Disponível em:

<.http://msdn.microsoft.com/en-us/data/ef.aspx>. Acesso em: 08 de setembro de 2013.

RODRIGUES, Michael Alan Souza; CECIM, Pollyanna Rodrigues; ARAÚJO, Taianna

Miranda. Técnicas de recuperação de informação visual pelo conteúdo cromático. 2003.
Tese (Bacharelado) - Curso de Bacharelado Em Ciência Da Computação, Universidade Da
Amazônia Centro De Ciências Exatas e Tecnologia, Amazônia, 2003.

ROSA, Natália Abdala; TRAINA, A. Uma abordagem prática e eficiente de consultas por
similaridade para suporte a diagnóstico por imagens. 2002. Tese de Doutorado. Master’s
thesis, Universidade de Sao Paulo, Sao Carlos–BR.

SANTOS FILHO, Roberto et al. Desmistificando o Conceito de Consultas por Similaridade:

A Busca de Novas Aplicações na Medicina. 2001.

SCHIMANCO Cesar Cassiano. Code break. 2011. Função para remover acentos em C# -
ASP.NET. Disponível em: <http://www.cbsa.com.br/post/funcao-para-remover-acentos-em-c-
--aspnet.aspx> Acesso: 25 de outubro de 2013
 56

TRAINA, Agma Juci Machado. Consultas por Similaridade em Dados

Complexos: Conceitos, Recursos, Aplicações e Desafios. 2012. Curso de Ciência da
Computação, Departamento de Ciências de Computação, Universidade de São Paulo, São
Carlos, 2012.

VALLS, Esteve et al. Applying the Levenshtein Distance to Catalan dialects: A brief
comparison of two dialectometric approaches. Verba: anuario galego de filoloxía, v. 39,
2012.

VARANDAS, 2003. O Conceito de Função. Disponível em:

<http://www.educ.fc.ul.pt/icm/icm2000/icm28/func/grfun.htm> Acesso em: 27 de abril de
2013

VB.NET Brasil. 2012. Jaro-Winkler algoritmo para tratamento de nomes. Disponível em:
<http://www.vbnetbrasil.com.br/index.php/jaro-winkler-algoritmo-para-tratamento-de-
nomes/> Acesso em: 14 de setembro de 2013