Escolar Documentos
Profissional Documentos
Cultura Documentos
-1-
Table of Contents
Introduccion......................................................................................................................... 5
Trminos y Documentos................................................................................................. 6
Documentos estructurados y documentos no estructurados............................................7
Consultas..............................................................................................................................7
Consultas puntuales.........................................................................................................7
Consultas Booleanas....................................................................................................... 8
Consulta de Frases...........................................................................................................8
Consultas estructuradas................................................................................................... 8
Consultas con Comodines............................................................................................... 9
Consultas difusas.............................................................................................................9
Consultas por proximidad............................................................................................. 10
Consultas ranqueadas.................................................................................................... 10
Resolucin de consultas .................................................................................................... 11
Fuerza bruta...................................................................................................................11
Vectores de incidencia.................................................................................................. 11
Indices invertidos: introduccin.................................................................................... 12
Indices Invertidos............................................................................................................... 17
Almacenamiento de punteros........................................................................................ 17
Modelos Globales..................................................................................................... 19
Modelo Binario Plano..........................................................................................19
Cdigos Unarios.................................................................................................. 19
Cdigo Gamma.................................................................................................... 20
Cdigos Delta...................................................................................................... 21
Modelo global tipo Bernoulli...............................................................................23
Cdigos de Golomb............................................................................................. 23
Forma vectorial de los cdigos............................................................................ 25
Modelo Global de Frecuencia Observada............................................................26
Modelos Locales.......................................................................................................26
Modelo Local tipo Bernoulli................................................................................26
Modelo Local Tipo Bernoulli escalonado............................................................27
Modelo Hiperblico Local...................................................................................27
Modelo Local de Frecuencia Observada..............................................................28
Resumen................................................................................................................... 29
Almacenamiento del lxico...........................................................................................29
Trminos de longitud fija......................................................................................... 30
Concatenacin de trminos.......................................................................................30
Front Coding........................................................................................................ 31
Front Coding Parcial............................................................................................ 32
Hashing Perfecto y Mnimo................................................................................. 32
-2-
-4-
Introduccion
En este apunte vamos a tratar un problema bastante simple: como realizar bsquedas sobre
una coleccin de datos. Este tema es tan amplio que abarca problemas como los siguientes:
Buscar pginas web que contengan informacin sobre medicina
Encontrar las obras de Shakespeare en las cuales un rey es asesinado
Buscar recetas de cocina que utilicen palmitos, pollo y aceitunas verdes
Encontrar sentencias jurdicas que traten sobre delitos contra la propiedad
pblica
Etc...
Es fcil darse cuenta que el tema es tan amplio que las posibilidades son practicamente
infinitas. Las aplicaciones en las cuales se deben aplicar las tcnicas vistas en este apunte van
desde sistemas de help, motores de bsqueda de pginas web, sistemas para almacenar textos,
etc.Algunas de las caractersticas de los sistemas en los cuales la resolucin de bsquedas sobre
la informacin no es una tarea trivial son:
Enormes volmenes de informacin en forma de textos.
Frecuentemente los textos son acompaados de imgenes o grficos.
Se requieren ndices especiales que permitan realizar consultas sobre los textos
almacenados.
El espacio ocupado, tanto por los textos como por los ndices es crtico.
Consultas complejas, a veces usando un lenguaje de consultas ad-hoc.
Las consultas deben resolverse en forma rpida aun para colecciones de gran tamao.
Varios sistemas que presentaban este tipo de requerimientos fueron construidos usando
bases de datos relacionales o incluso archivos planos resultando en un fracaso absoluto. Un
ejemplo muy actual y que muestra el enorme espectro que cubren estos sistemas son las
enciclopedias, tutoriales o textos que se distribuyen en Cd-Rom, este tipo de aplicacin cubre
todos y cada uno de los requisitos que mencionbamos antes. Estos sistemas se caracterizan por
reunir una enorme cantidad de informacin textual y el objetivo de automatizar esta informacin
es poder realizar consultas sobre los datos que manualmente seran irrealizables o bien
insumiran una enorme cantidad de tiempo. Por ejemplo:
Cuales son los textos de mayor relevancia para un conjunto de temas.
En qu textos puede encontrarse una determinada palabra.
En qu textos pueden encontrarse dos o mas palabras o bien una palabra u otra.
Para la lingstica, por ejemplo, analizar en que contextos utilizo un autor una determinada
palabra es un trabajo de suma importancia, este tipo de trabajo se denomina concordancia. Una
concordancia de las obras de Shakespeare insumi en el siglo pasado la vida de una persona, sus
hijos y los hijos de estos. Hoy en da estas otrora maratnicas tareas ya no cobran vidas y pueden
realizarse en lapsos de tiempo realmente sorprendentes.
-5-
Bsicamente estos sistemas estn compuestos por textos ndices almacenados en disco y un
sistema o motor de interpretacin, optimizacin, resolucin de consultas y recuperacin de
informacin en base a las consultas. Un abogado que quiera obtener aquellos artculos legales en
los cuales se trate un determinado tema no va a poder entender que la consulta insuma varias
semanas ni tampoco que se necesiten 20Gb de espacio en disco para resolverla, aunque suene
exagerado esto es exactamente lo que se necesitaba para dicha consulta usando una base
relacional para guardar los textos.
Los sistemas de indexacin pueden construirse en forma independiente, anexarse como
modulo a un sistema de mayor envergadura o bien anexarse como una funcionalidad ms de una
base de datos relacional. Curiosamente las bases de datos orientadas a objetos parecen mas
flexibles para incorporar estas funciones a los objetos de tipo texto, mas all de esta facilidad la
usabilidad real de una base de datos orientada a objetos permanece en discusin.
En este apunte trataremos los temas ms delicados de este tipo de sistemas: el
almacenamiento de los textos, el almacenamiento y construccin de los ndices y la resolucin de
consultas. Muchos de los temas aqu tratados son bastante nuevos y resultan muy interesantes no
solo para este tipo de sistemas sino tambin en otros campos.
Pre-requisitos: Este es un apunte netamente tcnico, si bien los temas han sido tratados en
profundidad y con ejemplos en casi todos los casos hay algunos temas que el lector debe conocer
para poder estudiar en profundidad este tema. En este apunte suponemos que el lector tiene
conocimientos de programacin y estructuras de datos complejas (rboles, tries, heaps, hashtables etc). Nociones bsicas de clculo logartmico. Conocimientos de probabilidad y
estadstica. Conocimientos de teora de la informacin y compresin de datos, cdigos prefijos,
cdigos de huffman, compresin aritmtica. Manejo de ndices, ndices invertidos rboles B, B+.
Sort interno y externo, Natural Selection, Replacement Selection, Key-Sort. etc.
Trminos y Documentos
La construccin de un ndice se hace en base a dos conceptos que debemos definir:
trminos y documentos. En lneas generales, un ndice sirve para buscar dentro de un conjunto de
documentos uno o ms trminos, los resultados son aquellos documentos que matchean la
consulta formulada. Dependiendo de la aplicacin para la cual vaya a usarse la base de datos los
trminos y los documentos pueden ser definidos en forma muy variada. Por ejemplo podemos
decir que un trmino es una palabra y que el documento est especificado por un nmero de
prrafo o bien que los trminos son temas y que el documento es un determinado archivo.
Trmino: Un trmino es la unidad mnima de informacin que puede buscarse en un texto.
En el 99% de los casos se define que un trmino es una palabra. En general se limita la longitud
de los trminos a 256 caracteres y adems no se consideran trminos a los nmeros de ms de 4
dgitos.
Documento: Un documento es la unidad mnima de informacin que se recupera del texto.
Al realizarse una consulta la misma devuelve el o los documentos que matchean con la consulta
-6-
formulada. En general un documento es una lnea, un prrafo, una pgina o bien un archivo
completo de texto.
Cuando los documentos tienen estructura se debe indexar cada campo del texto de forma
independiente de forma tal de poder realizar consultas indicando los campos sobre los cuales se
quiere buscar, cuando un documento no tiene estructura se lo considera equivalente a un
documento con un nico campo que contiene los datos del documento.
Consultas
Para entender el alcance de nuestro problema es fundamental analizar los distintos tipos de
consultas que un usuario puede querer realizar sobre una coleccin de datos. Como vamos a ver
existen muchos tipos de consulta distintos y las estructuras y los algorimos que debemos emplear
para resolver cada tipo de consulta pueden variar enormemente.
La sintxis usada para representar las distintas consultas es la utilizada por Lucene, un
sistema de indexacin gratuito y open-source disponible en varios lenguajes. La sintaxis se puede
leer en: http://jakarta.apache.org/lucene/docs/queryparsersyntax.html
Consultas puntuales
Una consulta puntual es la forma mas bsica que puede tomar una consulta, y consiste en
recuperar los documentos en los cuales aparece un determinado trmino.
-7-
Q: jedi
Buscara en nuestra coleccin de datos los documentos que contienen el trmino jedi y
devolvera un listado de los mismos.
Consultas Booleanas
Las consultas booleanas son aquellas en las cuales se utilizan operadores booleanos para
indicar los trminos que deben contener o no los documentos que nos interesan.
Consulta de Frases
Hasta el momento hemos visto consultas basadas en trminos aislados, es posible que el
usuario quiera buscar frases enteras en la coleccin de datos, por ejemplo:
Q1: let it be
Q2: organizacin de datos
En estas consultas debemos recuperar aquellos documentos que contengan la frase
completa, lo cual es equivalente a que los documentos contengan cada palabra de la frase y que
ademas estas palabras aparezcan en forma consecutiva.
Las frases se indican utilizando comillas dobles o simples.
Consultas estructuradas
Cuando los documentos que estamos buscando contienen informacin estructurada es
posible realizar consultas sobre ciertos campos en particular, por ejemplo:
-8-
Q1: dir*
Q2: fernand?
La primer consulta busca todos los documentos que contengan trminos que comiencen
con 'dir', la segunda consulta busca documentos que contengan trminos que comiencen con
'fernand' y sigan con un caracter mas (no mas de uno).
'* ' matchea uno o mas caracteres, cualesquiera.
'?' matchea un caracter cualquiera
Consultas difusas
Una consulta difusa (fuzzy en ingls) es aquella en la cual los documentos a recuperar
son aquellos que contienen trminos parecidos al que indicamos en la consulta. La semntica
de parecidos depende de cada sistema, por ejemplo se pueden buscar trminos cuya
pronunciacin sea similar a la del trmino buscado o trminos que estn a una cierta distancia
de edicin del trmino buscado. La distancia de edicin se define como la cantidad de
caracteres a cambiar para obtener un trmino a partir de otro.
Q1: ~puerto
Esta consulta buscara documentos que contienen puerto o bien documentos que
contienen trminos que estan a distancia de edicin 1 de puerto, por ejemplo puerta,
puerro, puertos.
-9-
Consultas ranqueadas
Las consultas ranqueadas son las mas ultilizadas en casi todos los sistemas de bsqueda, ya
que permiten recuperar los documentos mas relevantes a partir de una cierta lista de palabras.
- 10 -
La consulta busca documentos que contengan fotos de neptuno indicando que la palabra
neptuno es 8 veces mas importante que fotos
Resolucin de consultas
Para comenzar vamos a partir de una posible consulta que un usuario podria querer realizar
sobre un sistema que almacena guiones de pelculas. Los guiones
se almacenan en archivos de texto en donde el nombre del archivo
indica el nombre de la pelcula. La cos consultas mas tpicas
consisten en encontrar aquellas pelculas que contengan determinados textos.
Guiones de pelculas en:
http://www.script-orama.com/snazzy/dircut.html
Consulta: Buscar en una base de guiones de pelculas las pelculas cuyos guiones
contengan las palabras 'Rome' y 'Emperator' pero no contengan la palabra 'Gladiator'
Fuerza bruta
La primera solucin que podemos pensar consiste en recorrer secuencialmente todos los
guiones almacenados buscando las palabras 'Rome' y 'Emperator', descartando luego aquellos que
contengan la palabra 'Gladiator'. Esta solucin por mas simple que parezca acarrea el problema
fundamental de que los tiempos que puede llegar a insumir una bsqueda pueden llegar a ser
prohibitivos si el volumen de datos es lo suficientemente grande. Cuando esto ocurre nos
encontramos en la necesidad de construir 'indices' que permitan buscar informacin en nuestros
datos de manera mas eficientes.
Esta solucin es entonces muy eficiente en cuanto al espacio usado ya que no se usa
espacio alguno mas alla del necesario para guardar los datos. Sin embargo falla completamente
en cuanto al tiempo necesario para resolver una consulta.
Para resolver esta y otras consultas en forma efciente es necesario contar con ndices que
permitan resolver la consulta rapidamente sin necesidad de recorrer toda la coleccin de datos,
una primera aproximacin a la construccin de un ndice es el uso de los denominados vectores
de incidencia
Vectores de incidencia
Una forma bsica de indexar datos consiste en construir lo que se conoce como 'vectores
de incidencia' basicamente una matriz en la cual las filas representan los 'trminos' y las
columnas representan los documentos indicando con un 1 o un 0 si un documento contiene un
determinado trmino.
- 11 -
Term/Doc Doc1 Doc2 Doc3 Doc4 Doc5 Doc6 Doc7 Doc8 Doc9
casa
hola
arbol
luna
Lo que la matriz indica es que el documento 'Doc1' contiene los trminos 'casa' y 'luna', el
documento 'Doc2' contiene 'hola' etc.
Para resolver una consulta de tipo 'casa' AND 'hola' AND NOT 'arbol' lo unico que
tenemos que hacer es tomar el vector correspondiente a cada termino y realizar un AND a nivel
de bits entre los mismos, teniendo cuidado de invertir los bits en caso de que uno de los trminos
este negado.
casa = 100100100
hola = 111000100
arbol = 001000100 Not arbol = 110111011
Realizando el and nos queda: 100000000 es decir que el documento que contiene 'casa' y
'hola' pero no contiene 'arbol' es el documento 'Doc1'.
Esta solucin resulta muy simple y eficiente para resolver consultas, requiriendose en
general muy poco tiempo, sin embargo tiene un problema fundamental: el espacio necesario para
almacenar el ndice.
Consideremos por ejemplo la coleccin TREC, una recopilacin de textos muy usada para
probar y evaluar sistemas de indexacin y bsqueda. Esta coleccin cuenta con 742.358
documentos, conteniendo 538.244 trminos distintos. Por lo tanto nuestra matriz tendra:
- 12 -
Un ndice invertido es un listado de todos los trminos de un texto acompaados por todos
los nmeros de documento en los cuales aparecen dichos trminos. Se lo denomina as por ser la
inversin de la forma de mostrar los datos, se pasa de tener muchos documentos pudiendo para
cada uno de ellos obtener cada uno con sus trminos a tener muchos trminos pudiendo para cada
uno de ellos obtener los documentos en que aparecen.
El primer paso para construir un ndice invertido consiste en recorrer cada documento y
generar un archivo en el cual se indique por cada termino el nmero de documento en el cual
aparece. Por ejemplo para el siguiente texto:
En algunos casos, la verdad es la nica
fuente de iluminacin con la que pueden
contar algunos tristes personajes que
ni siquiera cuentan con la iluminacin
natural con la que todos nacemos.
Considerando que cada lnea es un documento y que cada palabra es un trmino se
construye algo de la siguiente forma:
Trmino
Doc
En
algunos
casos
la
verdad
es
la
nica
fuente
de
iluminacin
con
la
que
pueden
contar
algunos
tristes
personajes
que
ni
siquiera
cuentan
- 13 -
Trmino
Doc
con
la
iluminacin
natural
con
la
que
todos
nacemos
Trmino
Doc
algunos
algunos
casos
con
con
con
contar
cuentan
de
En
es
fuente
iluminacin
iluminacin
la
la
la
la
la
nacemos
natural
ni
personajes
pueden
que
- 14 -
Trmino
Doc
que
que
siquiera
todos
tristes
nica
verdad
A continuacin las filas 'repetidas' se eliminan agregando una columna que indique la
frecuencia de cada termino en cada documento. (Por ejemplo notar que 'la' aparece dos veces en
el documento 1)
Trmino
Doc
Freq
algunos
algunos
casos
con
con
con
contar
cuentan
de
En
es
fuente
iluminacin
iluminacin
la
la
la
la
nacemos
natural
ni
personajes
pueden
que
que
- 15 -
Trmino
Doc
Freq
que
siquiera
todos
tristes
nica
verdad
Para evitar repetir trminos innecesariamente podemos agrupar los documentos en los
cuales aparece cada termino en una sola entrada del ndice de la forma:
Palabra
#Docs
En
algunos
casos
la
verdad
es
nica
fuente
de
iluminacin
con
que
pueden
contar
algunos
tristes
personajes
ni
siquiera
cuentan
natural
todos
nacemos
Ocu
1
1
1
4
1
1
1
1
1
2
3
3
1
1
1
1
1
1
1
1
1
1
1
1
1
1
5
1
1
1
1
1
2
3
3
1
1
1
1
1
1
1
1
1
1
1
Documentos.
1
1
1
1,2,4,5
1
1
1
2
2
2,4
2,4,5
2,3,5
2
3
3
3
3
4
4
4
5
5
5
#Docs
1
1
1
4
1
1
1
1
Ocu
1
1
1
5
1
1
1
1
Offset
0
1
2
3
7
8
9
10
- 16 -
1
2
3
3
1
1
1
1
1
1
1
1
1
1
1
11
12
14
17
20
21
22
23
24
25
26
27
28
29
30
Indices Invertidos
En el punto anterior hemos visto una rpida introduccin a la estructura bsica de un indice
invertido, basicamente un listado de trminos ordenado sobre el cual se realiza una bsqueda
binaria recuperando los documentos en los cuales podemos encontrar dichos trminos.
Un indice invertido se compone basicamente de dos partes:
En esta seccin vamos a estudiar formas eficientes para almacenar tanto el diccionario
como los punteros de forma tal de ocupar la menor cantidad de espacio posible sin entorpecer el
uso del ndice para realizar bsquedas.
Almacenamiento de punteros
Para tener una idea sobre el espacio necesario para almacenar los punteros vamos a usar
datos sobre algunas colecciones de datos bastante populares: Biblia es el texto completo de la
Biblia, considerando cada versculo como un documento. GNU es una coleccin de textos breves
sobre computacin que recopilo GNU, cada documento es un archivo independiente. TREC, por
- 17 -
ltimo es una gran coleccin de artculos de todo tipo (finanzas, ciencia y tecnologa). Los datos
estadsticos de estas tres colecciones son:
Recordemos que por puntero entendemos a un nmero de documento referenciado desde
un trmino indicando que el trmino puede ser encontrado en dicho documento.
Documentos
Trminos
Trminos distintos
Punteros
Tamao
Bible
GNU
TREC
31102
64267
742358
884988
2570939
335856749
9020
47064
538244
699131
2228135
136010026
4,33 Mb 14,05 Mb
2,054 Gb
Para estimar el espacio ocupado por un archivo invertido podemos hacer el siguiente
anlisis: cada palabra en ingls o castellano ocupa en promedio 5 caracteres y esta seguida por
uno o dos espacios en blanco y/o signos de puntuacin. Si cada puntero ocupa 32 bits tenemos 4
bytes de punteros por cada 6 bytes de datos, esto es verdad si consideramos que cada trmino no
aparece mas de una vez en cada documento lo cual no es verdad, con esta ltima consideracin
se puede estimar que la longitud de un archivo invertido es de aproximadamente el 55% de la
longitud del archivo de datos.
Supongamos que el trmino elefante aparece en un texto en los documentos
3,5,20,21,23,76,77,78. La entrada en un ndice invertido para dicho trmino es de la forma:
Elefante;8;3,5,20,21,23,76,77,78
El 8 es la frecuencia del trmino y corresponde a la cantidad de documentos en
donde aparece el trmino, siempre que hablemos de frecuencia de un trmino en este apunte lo
haremos contando cantidad de documentos y no ocurrencias individuales del trmino en todo el
texto.
Como puede verse la lista de punteros esta formada por nmeros en orden ascendente, otra
forma de expresar la misma secuencia es escribir el primer nmero de documento y luego la
distancia hasta el prximo nmero y as sucesivamente. En nuestro caso quedara.
Elefante;8;3,2,15,1,2,53,1,1
La nueva lista la denominaremos lista de distancias. Aunque no se note a simple vista la
lista de distancias se puede comprimir con mayor facilidad que la lista de punteros. El motivo de
esto reside en que para las palabras mas frecuentes (las que aparecen muchas veces en el texto)
vamos a tener una lista de distancias cortas, mientras que las palabras ms raras presentaran una
lista de distancias relativamente grandes en promedio. De esta forma las distancias cortas son
mucho ms probables que las distancias largas y podemos aprovechar esta caracterstica para
comprimir la lista de distancias.
Analizaremos varios modelos de compresin para la lista de distancias. En primer lugar
- 18 -
(Aclaracin: Todos los logaritmos de este apunte estn en base 2 a menos que se indique
otra base)
Modelos Globales.
Modelo Binario Plano.
Este es en realidad el modelo mas simple y en realidad no representa compresin alguna, lo
que se hace es sabiendo que hay N documentos en el texto representar a cada puntero en log(N)
bits.
Este modelo es bastante deficiente, en primer lugar supone
que todas las distancias son equiprobables cosa que como vimos
no es cierta y adems usa longitudes fijas para todas las distancias.
Si bien es el mtodo mas simple (es terriblemente simple) es
totalmente desaconsejable ya que como veremos es mucho mas
conveniente un mtodo que asigne a las distancias longitudes variables de acuerdo a su
probabilidad.
Utilizando este modelo se
necesitaran 340Gb para
almacenar los punteros de
TREC (20 bits por puntero)
Cdigos Unarios.
Este es un modelo en el cual cuanto mas chica es la distancia menos bits se necesitan para
representarla.
En unario una distancia X 1 se codifica como X-1 bits en uno y un bit en cero.
Ejemplos:
0=1
10 = 2
110 = 3
1110 = 4 etc...
Se ve que la longitud de una distancia X es de X bits por lo que la longitud en bits utilizada
para representar las distancias es lineal. El cdigo unario funciona bien para trminos que
aparecen en muchos documentos pero es muy malo cuando se encuentra una distancia grande
- 19 -
Cdigo Gamma.
En un cdigo gamma una distancia x se representa como:
Un cdigo unario correspondiente a 1+ log x
Una representacin binaria de X- 2log x que ocupa exactamente log x bits.
- 20 -
Ejemplos:
1=0
2 = 100
3 = 101
4 = 11000
5 = 11001
6 = 11010
7 = 11011
8 = 1110000
9 = 1110001
etc.
La distancia x se representa en gamma usando 1+2 log x bits.
Cdigos Delta.
Los cdigos delta son similares a los cdigos gamma, la distincin consiste en que la parte
que en Gamma se expresaba en unario en el cdigo delta se expresa en gamma. Con esto se
Ejemplo:
1110 001 = 9 en gamma.
1110 en unario es 4, 4 en gamma es 11000
9 en delta es 11000 001
Por lo tanto la longitud de una distancia X es 1+
12log 2 2 x log x
- 21 -
2
+ log x que es lo mismo que
Comparativo.
Nmero
1
2
3
4
5
6
7
8
9
10
Unario
0
10
110
1110
11110
111110
1111110
11111110
111111110
1111111110
Gamma
0
100
101
11000
11001
11010
11011
1110000
1110001
1110010
Delta
0
1000
1001
10100
10101
10110
10111
11000000
11000001
11000010
Se ve que para las distancias menores a 15 el cdigo gamma ocupa menos que el delta pero
de ah en adelante esto deja de ocurrir y desde la distancia 32 el cdigo gamma ser siempre
- 22 -
menor. Por ejemplo para X=1000000 el cdigo gamma ocupa 39 bits y el delta solamente 28.
Tambin se puede apreciar la gran diferencia que hay entre ambos cdigos y el unario para
distancias grandes.
Cdigos de Golomb.
Para un determinado parmetro b un nmero X se codifica como.
q+1 en unario.
r en binario en forma prefija.
Siendo q=
X 1
r= x-qb-1
- 23 -
Por ejemplo para b = 3 hay tres restos (r) posibles (0,1,2) que en forma prefija se codifican
como 0,10,11. Para b=6 hay seis restos posibles que en notacin prefija son: 00, 01, 100, 101,
110, 111.
Ejemplos: Si tomamos b=3, para la distancia X=9, q=2 y r=2, por lo que la distancia 9 en
golomb con b = 3 se codifica como 110 11. En cambio para b = 6 tenemos q = 1 y r = 2 por lo
que se codifica como 10 100. En la siguiente tabla se muestran ms ejemplos
Nmero
1
2
3
4
5
6
7
8
9
10
b=3
00
010
011
100
1010
1011
1100
11010
11011
11100
b=6
000
001
0100
0101
0110
0111
1000
1001
10100
10101
b optimo.
1
2
3
4
5
6
7
8
9
10
- 24 -
En colecciones grandes donde p es muy chico el b ptimo tiende a ser un nmero grande,
para Biblia por ejemplo el b ptimo es 278 y para TREC el b ptimo es 2036.
Si se diera el caso en el cual p>0,5 usando este modelo es conveniente invertir el archivo
invertido!!! Es decir incluir por cada trmino punteros a los documentos que NO contienen dicho
trmino.
i1
j=1
j=1
xj X xj
codificacin del grupo. Luego se representara la posicin del cdigo dentro del grupo como
i1
- 25 -
(11110)
Luego en el grupo 5 hay 16 cdigos distintos. Utilizando binario necesito 4 bits para
representar a 17-16, o sea 1 (0001), Uniendo ambos cdigos queda que 17 en gamma es
111100010
Como ejemplos de otros cdigos, delta utiliza (1,2,4,8,16) codificando con gamma y
binario y golomb es (b, b, b, b,) utilizando unario y cdigos prefijos.
Ahora supongamos que nos dan el siguiente vector: (2, 2, 4, 8, 8) y nos piden utilizando
unario y binario representar la distancia 2 y la 7. Para la 2, se encuentra en el primer grupo por lo
que es 1 en unario (0) y luego 1 en binario de 1 bit (1) con lo que el cdigo final es 01. Para la
distancia 7 se codifica el grupo 3 en unario (110) y 2 en binario de 2 bits (10) con lo que el
cdigo final es 11010
Modelos Locales.
Modelo Local tipo Bernoulli.
En este modelo partimos de la suposicin de que se conoce ft, frecuencia del trmino t
en el texto (o sea en todos los N documentos). Luego para este modelo se utilizan los cdigos de
Golomb calculando b a partir de la frecuencia del texto. (Y no a partir de un p genrico para
todo el texto como en el modelo global).
Dado ft => p = ft/N (probabilidad de ocurrencia de dicho trmino)
- 26 -
Este fenmeno se conoce como clustering y aunque parezca extrao ocurre con la gran
mayora de las palabras de cualquier texto. Una forma de adaptar el proceso Bernoulli a este
fenmeno es tomar un vector que es en cierta forma una combinacin de los cdigos gamma y
los de Golomb de la forma V=(b,2b,4b,....2^ib) y luego codificar usando cdigos de Golomb (o
sea, unario y prefijo). Tomando al nmero b como la distancia media de cada entrada del
archivo invertido nos aseguramos que al menos la mitad de las distancias caen en el primer
bucket del vector. Para este modelo hay que guardar b en cada entrada, como b es grande
para los trminos mas raros conviene en realidad guardar N/b usando cdigos Gamma.
- 27 -
u= 1/ln(m+1)+0,5772
m es la distancia mxima probable (cantidad de trminos del texto).
Las distancias se comprimen en funcin de su probabilidad usando compresin aritmtica.
Este modelo representa las probabilidades usando una distribucin hiperblica que ajusta
mejor al fenmeno de clustering que el proceso Bernoulli. Sin embargo es el modelo mas difcil
de implementar ya que no es posible usar los cdigos de Golomb y es necesario aplicar
compresin aritmtica, la complejidad y lentitud que insume implementar este modelo es causa
suficiente para dejarlo de lado aunque tericamente es muy eficiente.
Batching.
La idea de esta tcnica es que compartir el mismo modelo para los trminos de igual
frecuencia, de forma tal que para los N trminos de igual frecuencia solo se almacena un modelo.
De esta forma se necesitan tantos modelos como frecuencias distintas haya. Una mejora es
guardar un modelo no por frecuencias iguales sino por log(ft) iguales. Con lo cual se reduce un
poco ms la cantidad de modelos a guardar. Otra posibilidad es usar otra base para el logaritmo y
una forma muy usada es log 1,618033 (ft) es decir el logaritmo en base al nmero ureo (aparece
en todos lados). Este logaritmo se basa en la serie de Fibonacci por lo cual para las entradas de
frecuencia 1 se guarda un modelo, lo mismo para las entradas de frecuencias 2 y 3. Luego se
guarda un nico modelo para las frecuencias 4 y 5. Otro para las frecuencias 6,7,8 etc...
siguiendo la serie de Fibonacci.
Los modelos basados en esta tcnica no son demasiado complejos (ya que puede usarse
Huffman) y resultan extremadamente eficientes.
- 28 -
Resumen.
A continuacin resumimos en una tabla la cantidad de bits por puntero en promedio
utilizados por cada uno de los mtodos vistos para las colecciones Biblia, GNU y Trec.
Mtodo
Unario. (global)
Binario, Flat Model. (global)
Bernoulli. (global)
Gamma. (global)
Delta. (global)
Frecuencia observada. (global)
Bernoulli. (local)
Hiperblico. (local)
Bernoulli escalonado. (local)
Batched. (local)
Bible
GNU
264
15,00
9,67
6,55
6,26
5,92
6,13
5,77
5,68
5,61
TREC
920
16,00
11,65
5,69
5,08
4,83
6,17
5,17
4,71
4,65
1719
20,00
12,61
6,43
6,19
5,83
5,73
5,74
5,28
5,27
Como puede observarse hay varios modelos que funcionan bastante bien, la eleccin del
modelo a utilizar depender del tiempo que se disponga para implementar el mtodo, la forma en
que se vaya a utilizar el ndice y el grado de ahorro de espacio en disco que quiera utilizarse. En
lneas generales nosotros recomendamos el modelo local tipo Bernoulli usando cdigos de
Golomb, aunque hay muchos otros sistemas que funcionan muy bien con otros mtodos.
De esta forma cerramos el tema de compresin de los punteros del archivo invertido, ahora
resta analizar la forma en la que se van a almacenar los trminos para definir la estructura del
ndice.
- 29 -
Freq
20
5
3
1
2
Offset a Punteros
xxx
xxx
xxx
xxx
xxx
Esta solucin si bien es la mas simple desperdicia muchsimo espacio en disco ya que la
longitud promedio de un trmino en el ndice es de alrededor de 8 bytes (notar que la longitud
promedio de una palabra en el texto es menor ya que las palabras cortas son mas frecuentes, en el
ndice cada palabra se almacena solo una vez por lo que el promedio crece), con lo cual si
tenemos una longitud mxima de alrededor de 20 caracteres desperdiciamos en promedio 12
bytes por entrada. El desperdicio en disco y/o en memoria es enorme, para la base TREC el
espacio necesario para guardar los trminos (sin contar los punteros) es de 28Mb.
Concatenacin de trminos.
Una solucin mejor consiste en concatenar todos los trminos del ndice en una parte del
ndice y en otra almacenar la frecuencia, un offset a la seccin de strings y los punteros. Nuestro
ejemplo quedara de la forma.
STRINGS: casacasadocascadacascotecasita
Frecuencia
Offset al string
20
5
3
1
2
0
4
10
17
24
Offset a punteros
xxx
xxx
xxx
xxx
xxx
- 30 -
extras por entrada (para el offset) pero ahorramos los 12 bytes que se desperdiciaban en
promedio. Para el mismo ndice de la base TREC que ejemplificbamos antes el espacio se
reduce de 28 a 20Mb, pero esto aun es mucho, la prxima solucin consiste en ahorrar offsets
representando en la tabla no todos los trminos sino uno de cada n trminos de la siguiente
forma.
La estructura es muy similar a la anterior pero con cambios leves, en primer lugar la tabla
contendr una entrada por cada n palabras del texto. A cada trmino, a su vez hay que preconcatenarle su longitud (o utilizar algn carcter que no pueda existir en el termino, como el
carcter 0 si se guardan palabras). Luego lo que se guarda es: los strings, una tabla de offsets y la
tabla de frecuencias y punteros (en donde se mantiene una entrada por trmino)
Ejemplo usando N=2.
STRINGS: 4casa6casado7cascada7cascote6casita
Frecuencia
20
5
3
1
2
Offset a Punteros
xxx
xxx
xxx
xxx
xxx
Offset
0
12
28
Con esta tcnica ahorramos un poco mas de espacio ya que la longitud se puede codificar
con menos bytes que el offset, y el ndice de TREC pasa de 20 a 18 Mb. Sin embargo hay que
notar que mientras ms espacio ahorramos, ms tiempo se perdern luego con las consultas. Esta
tcnica hace que las bsquedas en el ndice sean un tanto ms complejas al agregarse el
procesamiento secuencia de un bloque de n trminos. Sin embargo esto no complica realmente
mucho la eficiencia de las bsquedas en el ndice ya que una bsqueda binaria usando la tabla de
offsets y recorriendo secuencialmente cada bloquecito de trminos apuntado por un offset no es
demasiado ms lenta que una bsqueda binaria normal.
Front Coding
Un detalle muy aprovechable para comprimir los trminos es que los mismos se guardan
ordenados alfabticamente y las palabras que son consecutivas unas de otras suelen compartir
varios caracteres en comn, para aprovechar esta caracterstica se utiliza una tcnica denominada
Front coding, en la cual lo que se guarda es la cantidad de caracteres que se repiten del trmino
anterior, la cantidad de caracteres nuevos, cuales son dichos caracteres y luego obviamente la
frecuencia y los punteros.
- 31 -
Repetidos
Distintos
0
4
3
4
3
4
2
4
3
3
Chars
casa
do
cada
ote
ita
Freq
20
5
3
1
2
Offset a punteros
xxx
xxx
xxx
xxx
xxx
Para guardar la columna Chars, que es de longitud variable, se puede hacer otra vez
concatenacin de trminos que aunque agrega otra vez el espacio de los punteros, esta vez el
lxico es mucho menor si se lo compara con la concatenacion de terminos sin front coding. Al
tener los terminos ordenados, la cantidad de caracteres ahorrados en promedio es muy probable
que se ahorren mas caracteres por utilizar front coding que lo que se pierde por agregar el campo
distintos a cada entrada. Sin embargo este metodo tiene una desventaja notablemente seria: ya
no es posible realizar bsquedas binarias. Para combinar las ventajas en acceso de la bsqueda
binaria con el ahorro de espacio del Front-Coding se utiliza una tcnica denominada Frontcoding parcial.
- 32 -
Funcin de hashing:
Dado cualquier string s y un espacio de direcciones N.
h(s) =r tal que 0<=r<N.
Funciones de hashing perfectas.
Una funcin de hashing es perfecta si nunca produce sinnimos.
Funcin de hashing perfecta.
h(s1) = h(s2) <=> s1 = s2
Funciones de hashing mnimas.
Una funcin de hashing es mnima cuando la cantidad de strings posibles a hashear es
igual al espacio de direcciones N.
Funciones de hashing preservadoras del orden.
Una funcin de hashing preserva el orden si:
h(s1) < h(s2) <=> s1 < s2
Para la construccin de nuestro ndice utilizaremos una funcin de hashing perfecta,
mnima y conservadora del orden. Al buscar uno de los trminos, se le aplicara dicha funcin que
nos devolver un nmero que corresponder con la entrada en el archivo invertido para dicho
trmino. Entonces:
Los strings a hashear son los trminos del ndice.
El espacio de direcciones es igual a la cantidad de strings.
- 33 -
- 34 -
4.1. Se elige un vrtice vi al que no se le haya fijado un valor todava. Se le asocia un valor
cualquiera entre 0 y N-1. Al asociar este valor al vrtice vi, el valor g(i) queda fijado
4.2. Mientras queden aristas que conecten un vrtice vj con valor asociado y un vrtice vk
sin valor asociado, se fija el valor asociado a vk como Rotulo de la arista g(j), fijando
entonces el valor de g(k). Es importante saber que la resta anterior tambin debe ser
hecha trabajando con lgebra de modulo N.
4.3. Finalmente, si al llegar a este paso quedo algn vrtice al que no se le haya asociado un
valor, se vuelve al paso 4.1
Una vez finalizado el mtodo todos los vrtices han quedado con un valor asociado, y la
funcin g se puede obtener como g(i) = Valor asociado al vrtice i.
Analicemos el mtodo:
Cada vrtice esta asociado con un valor de g. g(i) ser el valor asociado al vrtice vi.
Cada arista representa a una de las ecuaciones que deben cumplirse para que h sea
perfecta, mnima y conservadora del orden. Relaciona los vrtices que equivalen a los dos
valores de g de la ecuacin y se asocia a un numero que corresponde a la suma de dichos
valores
En el paso 4.1 se fija un valor de g(i). Al hacer esto, algunas de las ecuaciones que
relacionan valores de g pueden haber quedado con una sola incgnita, con lo cual se
pueden despejar sus valores. Eso es lo que se hace en el punto 4.2. A su vez al mismo
tiempo al despejar un nuevo valor de g an ms ecuaciones pueden haber quedado con una
sola incgnita, y se debe repetir hasta que nicamente queden ecuaciones con 2 incgnitas.
Si se repiten los pasos 4.1 y 4.2 llegar un momento en que no haya vrtices sin valor
asociado y que todas las aristas relacionen vrtices tal que la suma de sus valores asociados
en lgebra de modulo N sea el rotulo de la arista. Cuando ocurra esto, tenemos valores de g
tal que cumplen con todas las ecuaciones y por ello tenemos una funcin h perfecta mnima
y conservadora del orden
En el paso 3 hay que notar que podra tenerse un ciclo en el grafo pero igual obtener una
solucin con valores enteros. Como ejemplo, si se tiene 3 = g(a) + g(b); 4 = g(a) + g(c) y 5
= g(b) + g(c), se tendr un ciclo en el grafo pero existe una solucin que es g(a) = 1, g(b) =
2, g(c) = 3. Sin embargo, para grandes cantidades de trminos es mucho ms simple volver
a empezar todo de nuevo que perder una gran cantidad de tiempo analizando los ciclos a
ver si se producirn valores no enteros de g(x). As que siempre que se encuentre un ciclo
se tomaran nuevas funciones h1 y h2 y se comenzar desde el principio hasta encontrar un
grafo acclico
Finalmente se ve que con este mtodo no solo se deben grabar los M valores g(x) sino que
tambin se deber identificar en el archivo que funciones de hashing h1 y h2 se terminaron
utilizando. Una forma simple es utilizar funciones h1 y h2 que dependan de una cierta
cantidad de valores random; si el grafo queda cclico se eligen otros valores random hasta
que quede acclico. En este caso, lo que se guarda en el archivo final es la tira de valores
random que finalmente se utilizo
Veamos ahora como funciona el hashing perfecto con un ejemplo. Se utilizaran los
siguientes trminos: Arnaldo, Bartolo, Celsa, Edgar, Emilce, Hilda, Humberto, Olga, Rene,
Sandro y Victor. Las funciones de hashing h1 y h2 tendrn la forma
- 35 -
i sizeof v ]* s[i ]
v
strlen s 1
i=0
O sea, la sumatoria de cada carcter multiplicado por una posicin distinta de un vector v
de valores random (obviamente cada funcin con un distinto vector random o devolveran lo
mismo). Tambin se le debe aplicar a la salida de cada funcin un MOD 16, numero > 11
(cantidad de trminos) que se eligi como espacio de direcciones de h1 y h2. Los vectores
generados al azar de 4 caracteres de tamao fueron:
Vector Random 1 : 47 - 60 - 187 - 120
Vector Random 2 : 0 - 218 - 231 - 34
h1(s)
2
6
4
14
3
7
10
6
12
5
0
h2(s)
9
1
12
11
11
6
15
11
14
10
11
Paso 1: Construimos el grafo, con 16 vrtices. El numero 16 no fue elegido por alguna
razn en particular, cualquier numero mayor a 11 habra servido, pero mientras mayor sea el
numero es mas fcil que el grafo quede acclico.
Paso 2: Para cada string los valores de h1 y h2 determinan una arista del grafo. En nuestro
caso las aristas son:
2-9;6-1;4-12;14-11;3-11;7-6;10-15;6-11;12-14;5-10;0-11
Las aristas se rotulan con el nmero de string que la genero, para el string Arnaldo las
funciones de hashing daban valores 2 y 9, por eso la arista 2-9 tiene el rotulo 0 (cero). El grafo
generado luego de los dos primeros pasos es: (el texto subrayado son los rtulos de las aristas)
- 36 -
- 37 -
Elegimos un valor asociado cualquiera para el vrtice 2, por ejemplo 0. Entonces por la
arista rotulada 0, el valor del vrtice 9 ser 0-0 = 0. Se defini entonces g(2) = 0 y g(9) = 0. Se
vuelve al paso 4.1 porque hay vrtices sin valor asociado
Elegimos un valor asociado cualquiera para el vrtice 5, para variar un poco elegiremos el
valor 2. El valor asociado al vrtice 10 ser entonces 9-2 = 7. Luego el valor del vrtice 15 ser
de 6-7 = -1 = 10 en lgebra mod 11. Volvemos al paso 4.1 debido a los vrtices 8 y 13, que los
rotulamos a ambos con un valor cualquiera ya que todas las aristas ya conectan vrtices con valor
asociado. Para ambos elegimos el valor asociado 9. Quedaron definidos entonces g(5) = 2, g(10)
= 7. g(15) = 10, g(8) = 9, g(13) = 9.
Hemos terminado con el mtodo. El grafo final es el siguiente:
- 38 -
g(x)
0
4
0
5
9
2
8
8
9
0
7
10
4
9
4
10
h1(s)
2
6
h2(s)
9
1
g(h1(s))
0
8
- 39 -
g(h2(s))
0
4
h(s)
0
1
Celsa
Edgar
Emilce
Hilda
Humberto
Olga
Rene
Sandro
Victor
4
14
3
7
10
6
12
5
0
12
11
11
6
15
11
14
10
11
9
4
5
8
7
8
4
2
0
4
10
10
8
10
10
4
7
10
2
3
4
5
6
7
8
9
10
Como puede observarse los valores de h son nicos con lo cual la funcin de hashing h(s)
es perfecta , mnima y adems mantiene el orden de los strings.
Una vez vista la forma en la cual se construye la funcin de hashing es conveniente
analizar cuanto tiempo insume la construccin de la misma. El problema surge de la necesidad
de probar grafos hasta encontrar uno acclico que asegura la existencia de la funcin g. La
cantidad de grafos a probar disminuye si el nmero M se hace mas grande.
La cantidad de grafos a testear (promedio) utilizando M = C * N puede calcularse como:
m
2k
e k=1 2 kc
Para un c pequeo, esta cantidad es excesivamente grande. En cambio para c > 2 se da que
c
lim 22kc = 12 ln c2
m
m k =1
Con lo que si tenemos un numero muy grande de terminos (o sea un n muy grande) la
cantidad de grafos promedios a testear quedaria expresada como
c
M
=
c2
M 2 N
Con M=3N por ejemplo la cantidad de grafos a testear en promedio es 1,7 lo cual es muy
manejable. Sin embargo usar un valor de M muy grande como por ejemplo 3N tiene como
desventaja que se ocupa mucho espacio en disco (la funcin g hay que guardarla en disco) con lo
cual deja de tener sentido usar una funcin de hashing en lugar de los strings.
La solucin pasa por aumentar el nmero de funciones de hashing que se aplican a los
strings, usando 3 funciones de hashing en lugar de dos. De esta forma en lugar de un grafo
binario tenemos un grafo ternario. Cada arista conecta ahora tres vrtices y el requisito para que
exista la funcin g es que no haya subgrafos que contienen nicamente vrtices de grado dos o
superior. El algoritmo a aplicar si el grafo rene las condiciones es idntico al que aplicbamos
- 40 -
- 41 -
Pedro
1
1
0
1
2
y
1
0
0
1
0
Pablo
1
0
1
0
0
corre
0
1
0
1
1
respira
0
0
1
1
0
1
1
1
0
0
2
1
0
1
0
3
0
0
0
1
4
1
1
1
1
5
2
0Pablo
1
0
- 42 -
- 43 -
si se hacan en memoria pero se volvan lentsimos al implementarse sobre disco debido a que
realizaban muchsimos accesos al disco. La idea de la inversin por sort es realizar la mayora de
los accesos al disco en forma secuencial de forma tal de reducir el tiempo insumido accediendo
al disco.
La inversin por sort consta de tres fases.
Extraccin del lxico y construccin del archivo auxiliar.
Sort.
Construccin del ndice invertido.
Natural selection.
Replacement selection.
Key-Sort.
Postman-sort.
Muchos sistemas que utilizan inversin por sort prestan poca atencin al mecanismo de
sort a utilizar lo cual constituye un grave error ya que el etapa mas costosa (en tiempo y espacio)
de todo el mtodo, en este apunte vamos a analizar las cuatro alternativas de sort posibles
(descartando el sort interno por ser siempre inferior al replacement selection en volmenes de
datos abundantes) evaluando cual es la tcnica mas apropiada. Un sort por Natural Selection
tampoco parece buena alternativa ya que de todos los mtodos es el nico que requiere de
espacio extra en disco para generar las particiones, si consideramos el tamao del archivo(s) de
texto mas el espacio extra necesario para el archivo auxiliar mas el espacio del ndice es evidente
que no podemos darnos el lujo de adems reservarle una parte del disco al sort.
Queda elegir entre un replacement selection y un key-sort, el key-sort usualmente no es una
buena opcin para un sort externo, pero aqu adquiere un protagonismo inusual ya que las claves
- 44 -
son realmente muy chicas, cuando las claves son muy chicas un sort de este tipo podra llegar a
ser conveniente. Lo malo del key-sort es que luego de levantar las claves en memoria y
ordenarlas realiza accesos al disco en forma random para ordenar el archivo, como dijimos que la
idea de este proceso de inversin era minimizar los accesos al disco tenemos que descartar el
algoritmo de key-sort inmediatamente.
Por lo tanto el algoritmo elegido para la etapa de sort es el Replacement selection. Para el
merge final se utilizar optimal merge
Fase 3: Construccin del ndice invertido.
En esta etapa a partir del lxico (obtenido en la fase 1) y del archivo auxiliar ordenado se
construye el archivo invertido. Para ello hay que recorrer el archivo auxiliar ordenado (en forma
secuencial) hasta que el nmero de trmino cambie, cuando ello ocurre se escribe la entrada
correspondiente al trmino en el archivo invertido que consistir en el trmino (o su equivalente
segn el mtodo que se use), la frecuencia del mismo (suma de todas las frecuencias ledas del
archivo auxiliar) y los documentos en donde apareci el texto. Una vez generadas todas las
entradas puede eliminarse el archivo auxiliar. Luego de esto puede ser necesario regenerar el
ndice si el mtodo elegido para guardar los punteros exige una segunda pasada. Con este mtodo
la generacin del ndice pasa de seis semanas a aproximadamente veinte horas. Por ejemplo:
Pedro y Pablo.
Pedro corre.
Pablo respira.
Pedro corre y respira.
Pedro corre Pedro
El lxico es de la forma:
Pedro
y
Pablo
corre
respira
corre
Pablo
Pedro
respira
y
Documento
1
1
1
2
2
3
3
4
4
Freq
1
1
1
1
1
1
1
1
1
- 45 -
5
4
3
1
4
4
5
5
1
1
2
1
Documento
2
4
5
1
3
1
2
4
5
3
4
1
4
Freq
1
1
1
1
1
1
1
1
2
1
1
1
1
Ordenando:
No-Termino
1
1
1
2
2
3
3
3
3
4
4
5
5
Freq
3
2
5
2
2
Docs
2,4,5
1,3
1,2,4,5
3,4
1,4
Como vimos, el proceso de inversin de un archivo muy grande es un proceso muy costoso
y que insume varias horas de trabajo, afortunadamente este suele ser un proceso que se realiza
solo una vez, el mejor algoritmo de inversin consiste en averiguar si el proceso puede hacerse
en memoria, en cuyo caso se utiliza el algoritmo del estudiante, en caso contrario si se tiene que
hacer en disco se usa la inversin por sort.
Que indexar
El proceso de construir un archivo invertido involucra el parsear cada documento para
extraer los terminos que contiene e indexarlos. Estos trminos en formato crudo pueden
presentar varios problemas que pueden complicar las bsquedas por lo que existen varios
procesos que pueden usarse para determinar que trminos deben indexarse y cuales no y de que
forma deben pre-procesarse los mismos.
- 46 -
Stop Words
Stop words son trminos que no queremos indexar, en general se evita indexar trminos
que aparezcan en mas de un 50% de los documentos de la coleccin, en caso de que por alguna
razon se quiera indexar todos los trminos cuando los trminos aparecen en mas del 50% de los
documentos de la coleccin es preferible almacenar los documentos en los cuales NO aparecen
los trminos a efectos de minimizar la cantidad de punteros a almacenar.
Case folding
El proceso de case-folding consiste en convertir todos los trminos a minsculas con
excepcin de aquellos trminos que comienzan en mayscula en el medio de una oracin. Por
ejemplo siglas o nombres propios.
Las bsquedas son en general case-insensitive pero pueden realizarse case-sensitive
cuando se esta buscando una sigla o un determinado nombre propio.
Puntuacion
Un aspecto a considerar es la eliminacin de los signos de puntuacin de los trminos
excepto aquellos que son estrictamente necesarios. Algunas reglas que pueden usarse como
ejemplo son:
Nmeros
Debe decidirse si se pueden indexar nmeros y en caso de ser la respuesta afirmativa que
tipo de nmeros son idexables y cuales no lo son. Debe considerarse que en caso de indexarse los
nmeros el tamao del lxico, que debe manejarse en memoria, se incrementa sustancialmente
por lo que es frecuente que los nmeros no se indexen.
- 47 -
Consultas puntuales
Q: Roma
La resolucin de una consulta puntual es trivial con el uso de un ndice invertido, se accede
al lxico cargado en memoria y se realiza una bsqueda binaria del trmino en cuestin, luego se
recuperan los punteros correspondientes al trmino y a partir de ellos los documentos en los
cuales se puede encontrar el trmino.
Uso de cache:
Es altamente probable que los trminos que los usuarios busquen no sean absolutamente
aleatorios sino que existan trminos que son mucho mas buscados que otros, el sistema puede
llevar una estadstica sobre la cantidad de veces que los trminos son consultados de forma tal de
mantener un cache con los punteros de los trminos mas populares, de esta forma se evita el tener
que buscar el trmino en el diccionario y el recuperar y decodificar los punteros correspondientes
al mismo.
Consultas booleanas
Q: Roma AND Paris
Una consulta booleana utiliza una combinacin de AND, OR, NOT y parentesis en la
consulta.
ORs
- 48 -
La operacin a realizar en este caso implica tomar la lista de documentos de cada uno de
los trminos involucrados en la consulta y luego realizar una union entre estas listas. El orden en
el cual se realicen las operaciones no es importante debido a que todos los documentos van a
formar parte del resultado final sin importar el orden en el cual se los agregue.
ANDs
Q: ((T1 AND (T2 OR T3)) AND T4) AND T5 AND (T6 OR T7)
Indicar la estrategia de resolucin de la consulta si las frecuencias de los trminos son:
Term
Freq
T1
982
T2
671
T3
445
T4
1103
T5
931
T6
567
T7
443
NOTs:
- 49 -
Cuando uno de los trminos es negado en la consulta la lista de documentos en los cuales
el trmino aparece se convierte en la lista de documentos en los cuales el trmino NO aparece.
Cuando la operacin es un AND se procede como siempre con la salvedad de que en lugar de una
interseccin se debe hacer una diferencia de conjuntos (sacar de la lista mas corta aquellos
documentos que aparecen en la lista de documentos del trmino negado). Cuando la consulta es
un OR debe usarse un negativo de la lista de documentos del trmino negado, esta lista se
consigue haciendo la diferencia entre la lista de TODOS los documentos de la coleccin y la lista
del trmino negado.
Comodines
Q1: papa*nia
Q2: pa?al
Las consultas que utilizan comodines afectan la bsqueda de los trminos en el lxico ya
que no se conoce el trmino en su totalidad sino que deben buscarse los trminos que cumplan
con la mscara indicada. Existen varias tcnicas que pueden ayudar a la resolucin de consultas
con comodines.
- 50 -
N-Gramas
La primera solucin a estudiar implica no almacenar palabra en el ndice sino N-gramas,
cada palabra es dividida en una cantidad N de caracteres llamados n-gramas. Por ejemplo la
palabra sacar se divide en los digramas $s,sa,ac,ca,ar,r$ (el $ es un caracter especial de
comienzo-fin de trmino). Se almacenan todos los n-gramas haciendo que cada n-grama apunte a
los trminos del lxico que contienen el n-grama.
De esta forma si queremos buscar algo de la forma sac*r podemos hacer una consulta
booleana conjuntiva de:
$s AND sa AND ac AND r$
A los trminos que obtengamos como resultado de esta consulta se los deber examinar
para ver que realmente correspondan con la consulta ya que pueden haber matcheado trminos
que no concuerdan con lo buscado. Siguiendo el ejemplo anterior, la palabra satisfacer sera
devuelta por la consulta conjuntiva ya que se representa con los digramas $s, sa, ac y r$ (entre
otros) pero definitivamente no corresponde con sac*r por lo que deber ser descartada.
Finalmente, con los trminos obtenidos luego de filtrar los que no corresponden se
obtendrn (por medio de una disyuntiva) aquellos documentos donde aparecen y ese ser el
resultado de la consulta
La utilizacin de N-gramas implica necesitar alrededor de un 50% de espacio adicional al
del diccionario. Por ejemplo, la utilizacin de tri-gramas para TREC necesit de un 55% de
espacio adicional en disco y redujo el tiempo promedio necesario para una consulta con
wildcards de 6 segundos (fuerza bruta) a solo 0.05 segundos. La utilizacin de n-gramas debe
decidirse en funcin de la relacin espacio-tiempo con la que se trabaje.
Lexico rotado
Otra solucin posible para resolver consultas con wildcards que insume aun mas espacio
que el uso de n-gramas es el uso de lxico rotados. Para la palabra labor, lo que se guardara es
$labor,abor$l,bor$la,or$lab,r$labo
Cada rotacin es una entrada que apunta al trmino que la genera. Una consulta de tipo
labo*r implicara rotar el string hasta dejar el asterisco al final y luego buscar en el ndice todas
las entradas cuyos primeros caracteres sean r$labo.
Consultas con dos wildcards como por ejemplo *abo* pueden resolverse fcilmente, ya
- 51 -
que al rotar quedando los dos asteriscos al final solo se buscan rotaciones que empiecen con:
abo (o bien $abo segn como se interprete el asterisco inicial). En cambio no se pueden
resolver consultas del estilo ar*le*, o con mas de dos wildcards.
El lexico rotado es aun mas eficiente que los n-gramas para resolver consultas con
comodines pero requiere aun mas espacio, en promedio el uso de lexico rotado cuadriplica el
espacio del diccionario del archivo invertido.
- 52 -
Doc1,Doc2,....,DocN, Ft1,Ft2,....,Ftn,Pos1,Pos2,Pos3,...,PosN,Pos1,Pos2...
La forma en la cual se comprimen punteros y posiciones puede ser la misma
o distinta segn el caso.
Ejemplo:
Q: africa mia
Se recuperan los documentos en los que aparece africa y en los que aparece mia, se
realiza una interseccion y luego se analizan las posiciones en las cuales aparece africa y mia
en cada documento.
Africa:
D1,3,5,7,24,D2,2,45,128,D3,4,45,67,87,123
Mia:
D1,2,6,24,D2,5,43,133,D3,3,5,68,142
A continuacion por cada documento recuperado se obtiene la frecuencia del trmino en el
mismo y la lista de posiciones, a estas listas de posiciones se las normaliza restando la posicion
del trmino en la frase. Luego se hace una entre las posiciones en las cuales aparecen las palabras
. El proceso de normalizacion de las posiciones asegura que las palabras aparezcan en el
documento en el mismo orden indicado en la frase. Si la frase tuviera varias palabras por tratarse
de intersecciones se debe comenzar siempre con la palabra de la frase que menos veces aparece
en el documento que se esta analizando. Si al final de la interseccin la lista contiene una o mas
posiciones se concluye que la frase existe en el documento y la cantidad de veces que la frase
aparece es igual al nmero de elementos de la lista.
Ejemplo:
Frase: satanico dr no
Documento a analizar: D3
satanico (D3) = Freq5 = 23,45,67,87,191
dr (D3) = Freq8 = 12,46,64,88,110,192,211,314
no (D3) = Freq3 = 47,193,202
Normalizando las listas:
satanico = 23,45,67,87,191
dr = 11,45,63,87,109,191,210,313
- 53 -
no = 45,191,200
Ahora se intersectan primero no con satanico dando por resultado:
45,191
Y a este resultado lo intersectamos con dr resultando en:
45,191
Es decir que la frase aparece 2 veces en el documento 3, una en la posicion
45 y otra vez en la posicion 191.
Consultas ranqueadas
Q: Roma Paris Londres
Q: frutas mango^2 tropicales
Q: futbol +argentina -maradona
En una consulta ranqueada el usuario ingresa una lista de palabras y el sistema responde
con los N documentos mas relevantes para la lista de palabras indicadas aun cuando algunas
palabras no figuren en ningn documento. Por ejemplo, indice,inversion,compresion,consulta
es una buena lista de palabras para que este apunte figure al tope del ranking de documentos
relevantes.
Este tipo de consulta es muy cmoda para el usuario ya que con una lista de palabras puede
definirse el estilo de los documentos que se quieren buscar, refinando la lista a buscar y
consultando los documentos que se devuelven en las consultas puede tenerse un acceso muy
cmodo y practico a la informacin almacenada. Un buen ejemplo de este tipo de consulta lo
constituyen los buscadores de informacin en la Web, dada una lista de palabras es muy atractivo
poder obtener una lista con los sites mas relevantes para la lista de palabras consultada.
Estudiaremos a continuacin basndonos en este ejemplo mtodos para resolver consultas
ranqueadas de forma tal que la respuesta que recibe el usuario sea la que el usuario espera recibir
(lo cual nunca es fcil). Tomando como documentos a cada lnea y como trminos a cada
palabra, tenemos cinco trminos (Alberto, Bartolo, Cesar, Demian y Ernesto, que llamaremos
a,b,c,d y e) distribuidos en 5 documentos.
- 54 -
Coordinate Matching.
Esta aproximacin es la mas sencilla y puede resolverse usando un ndice invertido
tradicional, la forma en la cual se calcula el puntaje de cada documento es contando simplemente
cuantas de las palabras de la consulta contiene el documento. Por ejemplo para la consulta
(Ernesto, Alberto, Cesar) los puntajes son:
Documento
1
2
3
4
5
Puntaje
2
2
1
2
2
Con lo cual los documentos mas relevantes son el uno, el dos, el cuatro y el cinco con igual
puntaje.
Esta tcnica podra verse tambin de una forma vectorial utilizando vectores de tantas
dimensiones como trminos hay. El puntaje de la consulta para cada documento sera el producto
interno entre 2 vectores, el primero el vector de la consulta que tiene un 1 en la componente i si
el termino i se encuentra en la consulta y un 0 en el caso contrario; el segundo el vector de cada
documento que tiene un 1 en la componente i si el trmino i se encuentra en el documento y un 0
si no. Para el ejemplo, el vector de la consulta (Q) y los de cada documento(Di) son:
Q=(1,0,1,0,1)
D1=(1,0,1,0,0)
D2=(1,1,0,1,1)
D3=(1,1,0,1,0)
D4=(1,1,0,1,1)
D5=(1,1,0,1,1)
Como ejemplo, el puntaje del documento 2 para dicha consulta es
D2 . Q = (1,1,0,1,1) . (1,0,1,0,1) = 1+0+0+0+1 = 2
Es importante ver que en esta forma vectorial los trminos que aparezcan en las consultas y
que no existan en ningn documento se ignorarn, por ende la consulta Alberto Cesar Ernesto
Rolo se vera igual en forma vectorial aunque en la practica implicara mas accesos a disco para
ver que el termino Rolo no est en ningn documento
- 55 -
Producto Interno.
Para resolver el primer problema sera bueno que en el archivo invertido en la entrada de
cada trmino se indique no solo los nmeros de documentos donde dicho trmino aparece sino
tambin la cantidad de veces que aparece dicho trmino (frecuencia del trmino en el
documento)
Un entrada del archivo invertido para el texto del ejemplo sera de la forma.
Demian;(1,0)(2,1);(3,1);(4,2);(5,1)
Obviamente no se guardara directamente as sino con pares distancia-frecuencia (sabiendo
que para los trminos donde no aparece su frecuencia es 0). Con este tipo de ndice se podra
cambiar el vector de cada documento indicando en lugar de unos y ceros la cantidad de veces que
aparece cada trmino en l. Para el ejemplo sera:
D1=(2,0,1,0,0)
D2=(2,1,0,1,1)
D3=(1,1,0,1,0)
D4=(3,4,0,2,1)
D5=(1,2,0,1,1)
Si hacemos el producto interno con nuestra consulta, que sigue siendo (1,0,1,0,1),
obtenemos.
D1 = (2,0,1,0,0) . (1,0,1,0,1) = 3
D2 = (2,1,0,1,1) . (1,0,1,0,1) = 3
D3 = (1,1,0,1,0) . (1,0,1,0,1) = 1
D4 = (3,4,0,2,1) . (1,0,1,0,1) = 4
- 56 -
D5 = (1,2,0,1,1) . (1,0,1,0,1) = 2
Por ende los puntajes son:
Documento
1
2
3
4
5
Puntaje
3
3
1
4
2
El documento mas relevante es ahora el 4 pero esto ocurre simplemente porque el mismo
contiene muchas palabras y, como todava se favorecen a los documentos largos, logra obtener
mas puntaje que el resto. Sin embargo, el primer problema se pudo solucionar y se ve que el
documento 2 ahora tiene mas puntaje que el 5.
wt=log 10
N
ft
Siendo N la cantidad de objetos del universo y ft la frecuencia del objeto t dentro del
universo. Si se aplica la ley de Zipf a nuestro problema en lugar de asignarle a cada trmino en el
vector de documentos un nmero de acuerdo a la cantidad de veces que ocurre asignmosle un
nmero que exprese la importancia del trmino multiplicada por la cantidad de veces que ocurre.
A este nmero lo llamaremos wtd que se calcular como
wtd = ftd wt
wtd = ftd *log 10
N
ft
Siendo:
ftd: La frecuencia del trmino dentro del documento.
N: La cantidad de documentos en total.
ft: La frecuencia del trmino (cantidad de documentos donde aparece)
Usando este esquema el peso de cada trmino es:
- 57 -
Peso(A) = log(5/5) = 0
Peso(B) = log(5/4) = 0.1
Peso(C) = log(5/1) = 0.7
Peso(D) = log(5/4) = 0.1
Peso(E) = log(5/3) = 0.2
0;0;0.7;0;0)
0;0.1;0;0.1;0.2)
0;0.1;0;0.1;0)
0;0.4;0;0.2;0.2)
0;0.2;0;0.1;0.2)
Puntaje
0.7
0.2
0
0.2
0.2
Logramos con esto que el primer documento sea el ms relevante (cosa que queramos ya
que en l aparece un termino muy importante) pero todava nos falta corregir el ltimo punto ya
que se ve que los documentos largos con gran cantidad de palabras siguen siendo teniendo
ventaja sobre otros documentos mas chicos (se ve ya que el documento 4 tiene el mismo puntaje
que el 5 pese a que tiene muchos mas terminos que no importan para la consulta). Una solucin
practica consiste en dividir el resultado del producto interno por la longitud del documento.
Hasta el momento calculamos el puntaje de un documento como el producto interno entre
el vector del documento D y el vector consultas Q. Como el calculo del puntaje de cada
- 58 -
documento se hace en funcin de dos vectores pasemos a ver todo el problema desde el punto de
vista algebraico.
P Q , D =
wqiwdi2
Esta medida en realidad indica cuan distintos son los vectores por lo que para el puntaje lo
correcto sera calcular el recproco. La distancia euclidiana sufre del problema inverso al mtodo
del producto interno, tiende a perjudicar a los documentos largos ya que el vector consulta es en
general de mdulo chico.
cos
X *Y
X *Y
- 59 -
cos =
XiYi
Xi 1 Yi 2
QD
cos =
QD
1
=
WqiWdi
WqWd
Wdi 2
Wq= Wqi 2
Wd =
N
fti
N
Qi
ti
Un cambio que se ve es que ahora en el vector de la consulta (Q) se tienen en cuenta los
pesos de cada trmino en vez de poner unos y ceros. Esto es porque ahora se estn comparando
angulos y el angulo entre el vector de un documento que tuviera justamente los trminos que
busco y el vector de la consulta con unos y ceros no sera de 0 grados (que dara el puntaje mas
alto que puede tener un documento). Esta modificacin al vector de consulta es necesaria para
que los angulos el vector de consulta y documentos que deban tener un buen puntaje sea ms
reducido. Entonces, el vector Q ser
Q=(
0;0;0.7;0;0.2 )
Para utilizar el mtodo se deber primero calcular la norma de cada vector como la raiz
cuadrada de la suma del cuadrado de cada componente. Como ejemplo para el documento 4 su
norma es 0 20 . 4 20 20 . 2 20 . 2 2 = 0.2 = 0.49
Las normas son:
|D1| = 0.7
|D4|=0.49
|D2|= 0.24
|D5|= 0.3
|D3|=0.14
|Q| = 0.73
Igualmente se ve que como en todos los clculos de puntaje se esta dividiendo por la
norma de Q, que no vara de documento en documento, esto podra no hacerse y en cambio
- 60 -
utilizar como puntaje el valor del coseno del ngulo multiplicado por la norma de Q. Las
posiciones de los documentos seran las mismas pero en este apunte igualmente se dividir por la
norma de Q para evitar confusiones ya que sera raro que el mtodo del coseno diera un valor
mayor a 1 como puntaje
Con los vectores de los documentos (son los mismos que en el producto interno
mejorado), el vector de la consulta calculado previamente y las normas de cada vector, se puede
determinar el puntaje de cada termino como el producto interno del vector del documento y el
vector de la consulta dividido por la norma del vector de la consulta y del vector del documento.
Por ejemplo para el documento 4 su puntaje es D1 . Q / (|D1| * |Q|) = 0.04 / ( 0.49 * 0.73) = 0.11.
Los puntajes de cada termino son:
Documento
1
2
3
4
5
Puntaje
0.96
0.23
0
0.11
0.18
- 61 -
sino simplemente los 4 primeros podemos proceder en forma mas eficiente. Un mtodo que
permite hacer esto consiste en utilizar un heap hasta que queden ordenados los primeros n
elementos. Este mtodo requiere un 10% del esfuerzo que se requiere en hacer un sort completo.
El cuello de botella sigue estando en la necesidad de calcular el coseno para todos los
documentos de la coleccin, si la cantidad de documentos es lo suficientemente grande la
cantidad de calculos a efectuar puede ser demasiado grande. Existen formas de evitar calcular
todos los cosenos que tiene como desventaja la incorporacin de algo de ruido en los
resultados, es decir que ocasionalmente se puede devolver como relvante a un documento que no
lo es.
Metodo de preprocesamiento
Por cada trmino calcular los n documentos mas cercanos al mismo, es decir tratar cada
termino como una consulta en la cual solo se busca dicho termino y calcular los n
documentos mas cercanos. El resultado es la lista de documentos preferidos de cada trmino.
Luego cuando se procesa una consulta involucrando mas de un trmino realizar la unin
entre los documentos preferidos de los terminos que aparecen en la consulta y computar los
cosenos unicamente para estos documentos. Finalmente elegir los n cosenos mas grandes.
Ademas de la posibilidad de resultar en falsos documentos relevantes este metodo tiene el
problema de requerir demasiado preprocesamiento ya que el computo de los n documentos mas
cercanos a cada trmino puede ser una tarea demasiado costosa. El mtodo probabilstico reduce
el tiempo de pre-procesamiento requerido.
Mtodo probabilstico
- 62 -
Una variante de este mtodo es asociar cada documento seguidor a mas de un lider. Otra
variante es para cada consulta calcular los b lideres mas cercanos en lugar de solo el mas
cercano.
Reduccin de las dimensiones
Como hemos visto tanto las consultas como los documentos se consideran vectores ndimensionales para el calculo del coseno. Una variante para acelerar el computo de los cosenos
consiste en reducir la dimension de los vectores. Existen dos mtodos basados en este enfoque: la
proyeccin aleatoria y el mtodo LSI.
Proyeccin aleatoria
- 63 -
realiza lo siguiente:
Se comienza con la matriz A de MxN que representa la matriz de trminos x documentos.
Se encuentra una matriz de proyeccin ortogonal aleatoria de KxM a la cual llamamos R.
Se calcula W = RxA
La jesima columna de W es ahora el vector correspondiente al documento j pero en K
dimensiones.
Este mtodo insume KxMxN multiplicaciones en total por lo que se lo considera un
mtodo costoso. Pese a ello este mtodo que es bastante novedoso funciona bastante bien ya que
luego de la proyeccin las distancias relativas entre los vectores tiende a mantenerse por lo que
es posible calcular los cosenos en mucho menos tiempo con valores extremadamente similares.
Evaluacion de consultas
Una vez que tenemos diseado un sistema para resolver consultas sobre una coleccin de
datos es necesario establecer parmetros que permitan evaluar que tan bien o mal el sistema
resuelve determinadas consultas. Esto es especialmente til para las consultas ranqueadas en las
cuales el orden en el cual aparecen los resultados es fundamental para la calidad del resultado de
la bsqueda.
Existen ciertos parmetros y tcnicas estandarizadas que permiten evaluar la eficiencia de
un sistema de bsqueda.
Precision:
La precision se define como la cantidad de documentos relevantes recuperados sobre el
total de documentos recuperados.
Recall:
El recall se define como la cantidad de documentos relevantes recuperados sobre el total de
documentos relevantes.
Ejemplo sobre un total de 10 documentos de los cuales 5 son relevantes, el siguiente
cuadro muestra los valores de precision-recall segun cuales son los documentos devueltos.
Rel?
1
2
Precision
Y
Recall
100%
20%
50%
20%
- 64 -
Rel?
Precision
Recall
33%
20%
50%
40%
60%
40%
50%
40%
42%
40%
50%
60%
55%
80%
50%
100%
10
Como leer el cuadro: La primer fila indica los valores de precision y recall si se devuelve
un solo documento, el cual es relevante (precision 100%), recall=20%. La segunda fila muestra
lo que pasa si se devuelven dos documentos (el primero relevante y el segundo no). Etc. Cuando
se devuelven todos los documentos de la coleccin el recall es siempre 100%.
El recall es una funcin creciente de acuerdo a la cantidad de documentos devueltos
miesntras que el valor de la precision va variando.
Para evaluar la eficiencia de un mtodo de resolucin de consultas se suele utilizar una
medida llamada Precisin interpolada basicamente consiste en tomar el valor de la precisin
para 11 valores fijos de recall (0%, 10%, 20%, ...., 100%) y luego calcular el promedio. Este
valor suele ser un buen indicador de la eficiencia de un mtodo de bsqueda.
Otro mtodo muy utilizado consiste en medir la precisin para un cierto nmero de
documentos recuperados fijo, este mtodo es muy usado en buscadores web midiendo por
ejemplo la precisin para los primeros n resultados. A este mtodo se lo llama precisin fija.
- 65 -
En este mtodo los ndices una vez construidos son estticos, es decir que no aceptan
modificaciones, para procesar las altas, bajas y modificaciones se utilizan archivos auxiliares
llamados diferenciales o segmentos. Un ndice puede estar formado por varios segmentos.
Periodicamente se realiza una reconstruccin de los ndices principales a partir de los
diferenciales o segmentos.
Analicemos las distintas operaciones sobre los documentos y la forma en la cual se
manejaran utilizando segmentos.
Baja de un documento
Para dar de baja un documento el enfoque mas usado consiste en utilizar un vector de
documentos eliminados, alcanza con un vector de n bits para n documentos. En este vector
se marca con 1 o 0 cada documento segn este borrado o no. Cuando se resuelve una consulta se
procede como si todos los documentos estuvieran activos y al resultado final se lo filtra
utilizando el vector de documentos borrados. Este enfoque es muy rpido ya que para borrar un
documento solo hace falta cambiar un bit. Adems es muy sencillo realizar un undelete.
Cuando el ndice es reorganizado es necesario ignorar los documentos borrados.
Alta de documentos
Al dar de alta uno mas documentos es necesario crear un segmento es decir que
basicamente se crea un nuevo ndice para los documentos a agregar, es conveniente agrupar
varios documentos a agregar antes de realizar la operacion ya que de lo contrario creariamos
tantos ndices como documentos se agreguen.
Para procesar las consultas se realizan las mismas sobre cada uno de los segmentos del
ndice, cada segmento responde a una cierta cantidad de documentos. Luego el resultado de la
consulta surge de hacer una union o bien un merge (consulta ranqueada) de los resultados de las
consultas sobre cada segmento.
En casos en los cuales se cuenta con varios equipos o procesadores para realizar las
bsquedas el uso de segmentos es entonces una ventaja ya que se pude buscar en paralelo sobre
cada segmento.
En el proceso de reorganizacin es necesario mergear todos los segmentos en uno.
Modificacin de un documento
La modificacin de un documento se procesa en este esquema como una baja seguida de
un alta de un nuevo documento, si existen varios documentos modificados y varios a dar de alta
es conveniente agrupar todas las altas y modificaciones de forma tal de que se cree un nico
segmento nuevo para procesar las operaciones.
- 66 -
Reorganizacin
La reorganizacin es necesaria cuando la cantidad de segmentos hace que las consultas
evidencien un cierto deterioro. La reorganizacin tiene como objetivo mergear la informacin de
todos los segmentos en un nico segmento. Basicamente consiste en un merge entre todos los
segmentos usando los trminos como claves. Al realizar el merge los documentos borrados
marcados en el vector de documentos borrados (hay un vector por segmento) se ignoran. Ademas
es posible que exista la necesidad de renumerar los documentos si los mismos se numeran desde
0 o 1 en cada segmento. Si los numeros de documento son nicos esto no es necesario.
Signature files
Otra forma de implementar un ndice para un archivo de texto es utilizando signature-files.
Un signature-file es un archivo que contiene una entrada por documento, en cada una de estas
entradas se almacena un signature correspondiente al documento, que surge de los trminos que
lo integran. Uno de los parmetros a definir es el tamao del signature, que puede ser de 32 bits,
64 bits, 128 bits etc.
Para construir el signature de un documento se debe contar con una cantidad M de
funciones de hash que devuelvan valores entre 0 y N-1, donde N es el tamao en bits del
signature file. Lo que se hace es hashear cada trmino del documento con cada una de dichas
funciones y setear en 1 el bit que se encuentra en la posicin de lo que devuelve cada funcin.
Como ejemplo, utilizando signatures de 16 bits, si se utilizan 3 funciones para hashear el termino
a y devuelven los valores 0, 9 y 2 el signature de dicho termino es 1010 0000 0100 0000.
Finalmente se hace un OR entre los signature de cada trmino del documento y con ello se
obtiene lo que ser el signature del documento. Puede darse que haya colisiones entre los valores
que devuelven las funciones de hash para un termino, en cuyo caso en vez de setear en 1 N bits
se setear una cantidad menor.
Por ejemplo, si tenemos el documento haba una vez una vaca fea, hasheamos cada
trmino del documento con tres funciones de hashing, hacemos MOD 16 de los tres valores
devueltos por las funciones y seteamos los bits correspondientes.
haba =
0100 0000 1000 0100
una = 0001 0000 0000 1000
- 67 -
vez =
una =
vaca =
fea =
Como se ve en los trminos una, vez y vaca hubo colisiones por lo que no hay 3 bits
seteados en 1 (o sea, dos o mas de las funciones devolvieron el mismo valor, por lo que la
cantidad de bits en 1 es menor a la cantidad de funciones de hashing utilizadas). El valor del
signature del documento que surge de hacer el OR entre todos los anteriores es: 0111 0101 1010
1110 (notar que es innecesario hashear mas de una vez un mismo trmino, como una en el
ejemplo, ya que el resultado es el mismo)
La forma en la cual se utiliza un signature file para resolver consultas es distinta de la
forma en la cual se resuelven con un ndice invertido; al buscar un trmino se debe hashearlo con
todas las M funciones de hash y obtener su signature. Luego se debe recorrer el signature de cada
documento buscando aquellos que tienen encendidos los bits que se encuentran encendidos en el
signature del trmino. Para efectuar esto bastara con hacer un AND binario entre el signature del
trmino y el signature del documento, y se buscaran aquellos en los cuales el resultado de dicho
AND sea el mismo signature del trmino. Estos documentos son candidatos a contener el trmino
ya que no es obligatorio que los tengan pues un mismo bit puede ser encendido por varios
trminos, por lo que luego se deber hacer una bsqueda dentro de los documentos candidatos
para responder la consulta. Sin embargo, los otros documentos se pueden descartar porque es
seguro que no contendrn el trmino buscado.
Otras consultas con conectores lgicos AND y OR son particularmente complejas con
signature-files ya que la lgica a utilizar debe ser ternaria (Si, No, Puede ser) el problema surge
cuando la mayora de los documentos quedan caratulados como puede-ser y hay que buscar el o
los trminos dentro del texto.
La ventaja principal de los signature-files reside en que ocupan muy poco espacio y que
dicho espacio puede ser elegido en el momento de la creacin por un valor conveniente.
Signature
- 68 -
1
2
3
4
5
0110000101000010
0100001000101010
1101000011001011
1101000001000100
0100111000010011
Como se ve se necesitarn 16 bit slices que son:
Slice
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Valor
00110
11111
10000
00110
00001
00001
01001
10000
00100
10110
01000
00001
01100
00010
11101
00101
Si queremos buscar un cierto trmino lo que se hace es hashearlo con las M funciones y
luego recuperar nicamente los slices que correspondan con los valores devueltos por ellas. Por
ejemplo si para un trmino las funciones dan como resultado 0,1 y 3 recuperamos los slices:
00110, 11111 y 00110. Con esto lo que tenemos son los bits 0, 1 y 3 de cada documento, que son
los que realmente nos interesan. Los documentos que pueden llegar a tener el termino buscado
son aquellos que tienen esos 3 bits encendidos con lo que si se hace un And de los slices se
obtendr una tira de bits donde un 1 en la posicin i indica que el documento i puede tener a
dicho termino y un 0 indica que el documento i no tiene a dicho termino. Siguiendo el ejemplo,
haciendo un AND entre los 3 slices se obtiene 00110 con lo cual los documentos a chequear son
los documentos 2 y 3 (los dos bits en uno). De esta forma solo se hacen solamente tres accesos
al disco (uno por cada funcin de hashing).
Los signature-files implementados usando bit-slices son una opcin interesante para
construir ndices al ocupar poco espacio y poder manejarse en forma eficiente usando bit-slices.
Una combinacin de signature-files y archivos invertidos puede generar un ambiente muy
propicio para resolver diversas consultas. La utilizacin de signature-files como nico mtodo de
indexacin de archivos de texto es dudosa ya que la resolucin de consultas se hara muy
trabajosa e ineficiente, sistemas implementados en base a signature-files son famosos por tardar
horas en la resolucin de algunas consultas simples.
Finalmente, en la construccin de un signature-file se debe especificar un tamao para los
- 69 -
signatures, este parmetro puede ser aprovechado para aumentar la eficiencia del signature file.
Se buscar que la cantidad promedio de unos y ceros sea similar, ya que una mayor proporcin
de ceros con respecto a unos indica que el signature podra ser reducido de tamao sin perder
mucha efectividad; y en el caso contrario una mayor proporcin de unos con respecto a ceros
indica que es probable que se hayan producido muchas colisiones y por ende que una gran parte
de los documentos candidatos a contener un termino finalmente no lo contendrn, por lo que se
puede necesitar aumentar el tamao del slice para disminuir las colisiones y evitarse de recorrer
dichos documentos
Bitmaps
Un bitmap es una forma de ndice muy particular, para construir un bitmap que sirva para
un archivo de texto tenemos que tener una entrada por trmino (igual que en un archivo
invertido), pero lo que se guarda para cada trmino es un vector de N bits (siendo N la cantidad
de documentos del texto) donde cada bit es 0 o 1 segn se encuentre o no el trmino en el
documento. Por ejemplo tomando cada lnea como documento y cada palabra como termino:
Pedro y Pablo.
Pedro corre.
Pablo respira.
Pedro corre y respira.
Pedro corre Pedro.
El bitmap correspondiente es:
Termino
pedro
y
pablo
corre
respira
1
1
1
1
0
0
2
1
0
0
1
0
3
0
0
1
0
1
4
1
1
0
1
1
5
1
0
0
1
0
Los bitmaps son excepcionalmente cmodos cuando se los utiliza para resolver consultas,
por ejemplo para las consultas booleanas basta con operar haciendo Ors y ANDs de los bitmaps
de los trminos buscados para obtener los documentos que son resultado de la consulta. El
problema es que son un tanto extravagantes en cuanto al espacio que consumen, para TREC por
ejemplo un bitmap ocupara unos 40 giga-bytes, aproximadamente 20 veces mas que el texto que
indexa. Por ello si se usan bitmaps debe usrselos comprimidos.
Compresin de bitmaps.
Cada entrada en un ndice del tipo bitmap tiene la particular caracterstica de estar formada
por algunos unos y una enorme cantidad de ceros, para comprimir este tipo de informacin
puede usarse un rbol de derivacin binaria.
- 70 -
- 71 -
hay un grupo que tiene unos que se debe leer y es 0010, luego un grupo de cuatro ceros, luego el
0011 y luego el 1000 luego cuatro ceros, el 0100 y despus 9 grupos de cuatro ceros.
En el ejemplo se agrupaba un bit cada cuatro, en las aplicaciones reales suele usarse un
factor de 8 que comprime mas y es mas fcil de implementar ya que cada byte representa 8 bytes
y as sucesivamente.
En este caso comprimimos 64 bits en 28, en general el nivel de compresin de este mtodo
es de alrededor del 75%, con lo cual nuestro bitmap gigante pasa a ocupar unos 5 giga-bytes,
como puede verse es mucho mas de lo que ocupa el archivo invertido y al comprimir el bitmap ya
no es tan fcil operar con el para realizar consultas, Los sistemas de manejo de textos en general
no suelen utilizar bitmaps debido al enorme costo que insume almacenarlos.
- 72 -