Kitabı oku: «Desarrollo de motores de búsqueda utilizando herramientas open source»

Capítulo 2
APACHE LUCENE

Apache Lucene (http://lucene.apache.org) es una librería para la recuperación de información que permite añadir funcionalidades de búsqueda a cualquier aplicación realizada en Java. En los últimos años, se ha convertido en la librería de referencia para implementar herramientas de recuperación de información, llegando a ser casi un estándar. Es importante destacar que Lucene no es una herramienta de búsqueda en sí misma, ya que no proporciona una interfaz de usuario, sino una librería más a bajo nivel que proporciona funcionalidades de recuperación de información que se pueden añadir a cualquier aplicación.

Apache Lucene ha sido ampliamente usada por su utilidad en la implementación de motores de búsqueda y es útil para cualquier aplicación que requiera indexado y búsqueda de textos. A pesar de que Lucene está desarollada en Java, podemos encontrar implementaciones en otros lenguajes, que podemos ver en http://cwiki.apache.org/lucene-java/LuceneImplementations.

Entre los principales objetivos de este capítulo podemos destacar:

• Comprender la arquitectura a nivel de clases e interfaces que proporciona Lucene.

• Conocer y comprender la funcionalidad de los componentes básicos de un motor de búsqueda basado en Apache Lucene.

• Comprender el concepto de índice invertido de Apache Lucene.

• Conocer el proceso de tokenización y búsqueda en Apache Lucene.

2.1 INTRODUCCIÓN A APACHE LUCENE

Apache Lucene permite a los desarrolladores integrar funciones de indexación y búsqueda de información textual dentro de sus proyectos. También permite la búsqueda de texto completo, es decir, permite buscar en un conjunto de documentos de texto uno o más términos definidos por el usuario. Para poder utilizar Lucene, es necesario seguir una serie de pasos o fases para conseguir realizar búsquedas efectivas: indexación y búsqueda.

• Indexación: el proceso de indexación consiste en analizar y extraer de entre toda la información disponible la verdaderamente relevante. Posteriormente, con esa información se crea el índice a partir del cual se realizarán las búsquedas. El índice es una estructura de datos que permite acceso rápido a la información (algo similar a lo que podría ser el índice de un libro).

• Búsqueda: el proceso de búsqueda consiste en consultar el índice para obtener los documentos donde aparecen unas determinadas palabras o una determinada expresión de consulta.

En la base de la arquitectura de Lucene se encuentra el concepto de documento (Document) que contiene campos (Fields) de texto. Esta flexibilidad permite a Lucene ser independiente del formato del fichero. Lucene soporta la indexación de textos que se encuentran en muchos tipos de documentos, como documentos PDF, páginas HTML y documentos de Microsoft Word.

El índice es el elemento más importante en el proceso de búsqueda con Lucene y se considera el corazón de un motor de búsqueda, ya que en él se almacenan todos los términos de todos los documentos. Se trata de un tipo de índice invertido, que consiste principalmente en una tabla donde se guarda la posición de cada término. No obstante, para poder crear un índice, primero es necesaria la extracción de todos los términos de todos los documentos —proceso que cada usuario o desarrollador puede configurar individualmente—. En la configuración, los desarrolladores establecen qué campos quieren incluir en el índice.

Los objetos con los que Lucene trabaja son documentos de cualquier tipo. Estos documentos contienen una serie de campos e incluyen información relativa a la información que queremos almacenar (como el nombre del autor, el título del documento o el nombre del archivo). Cada campo tiene una designación y un valor único, de forma que, al crear el índice, el usuario puede decidir qué metadatos quiere incluir.

En la indexación de los documentos, tiene lugar también un proceso que se conoce como tokenización. Para una máquina, un documento es ante todo un conjunto de información. Incluso cuando se pasa del nivel de los bits al de contenido legible para los humanos, un documento sigue estando compuesto por una serie de signos: letras, puntuación, espacios, etc.

A partir de estos datos, se crean los segmentos de tokenización y, posteriormente, los términos (en su mayoría palabras) que finalmente van a poder buscarse. La forma más sencilla de ejecutar este tipo de tokenización es ir separando en tokens cada vez que se encuentre un espacio en blanco. Sin embargo, este método pierde su utilidad cuando un término está compuesto por varias palabras separadas, como puede ser el caso de “sin embargo”. Para solucionarlo, se recurre a diccionarios adicionales que se pueden implementar también en el código Lucene.

La principal ventaja que aporta este motor de búsqueda es que devuelve los resultados de la búsqueda ordenados en función de la similitud con los términos de búsqueda introducidos por el usuario.

Lucene, primero, crea un índice invertido para los documentos en una colección. Como vimos, un índice invertido consiste en una lista alfabética de todas las palabras que aparecen en los documentos de texto. Cada entrada en esta lista contiene punteros que hacen referencia a todos los documentos que contienen cada palabra. De esta forma, cuando un usuario busca una palabra, el algoritmo se coloca en la posición apropiada en el índice y devuelve los documentos a los que se hace referencia.

La indexación invertida es una técnica rápida y fiable para generar índices de búsqueda, incluso para grandes cantidades de datos. Por ejemplo, una colección de textos que contiene 1 000 documentos con un promedio de 200 palabras cada uno, tendría un total de aproximadamente 200 000 palabras. Si la búsqueda de una palabra tuviera que pasar por toda la colección, el algoritmo tendría que hacer 200 000 comparaciones de palabras.

Por el contrario, el índice invertido contiene una sola entrada para cada palabra. El número de entradas dependerá de los documentos a indexar pero, por regla general, el tamaño de un índice invertido casi siempre estará por debajo del número total de palabras. Por ejemplo, si tenemos una colección de documentos de 200 000 palabras, esto podría generar un índice invertido de 10 000 palabras.

Otra de las ventajas de usar un índice invertido es que es más fácilmente escalable, ya que el número de palabras diferentes (el vocabulario) crece de forma más lenta que el número total de palabras. En algún momento, los nuevos documentos añadidos a la colección generarán muy pocas o ninguna entrada nueva en el índice, ya que las entradas existentes en el índice recibirán más referencias (punteros) para las palabras correspondientes a los nuevos documentos.

De esta forma, la frecuencia real de las palabras en un documento o una colección de documentos se acercará a la distribución descrita por la Ley de Zipf a medida que la colección de documentos se hace más grande.

La Ley de Zipf (https://es.wikipedia.org/wiki/Ley_de_Zipf) describe una distribución estadística de frecuencias de palabras presentes en todos los idiomas donde la probabilidad de que una palabra aparezca en un documento es inversamente proporcional a la frecuencia de aparición de cada una de las palabras. Dicha ley establece que la palabra más frecuente de un texto aparece el doble de veces que la siguiente más frecuente, tres veces más que la tercera más frecuente, cuatro veces más que la cuarta más frecuente, y así sucesivamente.

De esta forma, en términos matemáticos, la ley afirma que si se ordenan todas las palabras por frecuencia de uso, la segunda más frecuente aparece 1/2 veces el número de veces que aparece la más frecuente; la tercera, 1/3 veces; y, en general, la que ocupa la posición n aparece 1/n veces que la más frecuente.

2.2 MÓDULOS Y FUNCIONALIDADES DE APACHE LUCENE

Lucene permite indexar y realizar búsquedas sobre cualquier conjunto de datos que se puedan extraer de un texto, independientemente de cuál sea la fuente, el formato o el idioma. Esto permite que se puedan indexar y buscar datos almacenados en ficheros contenidos en páginas web o en servidores remotos, documentos almacenados en sistemas de archivos locales, ficheros de texto, documentos de Word, XML, HTML, archivos PDF o cualquier otro formato del que se pueda extraer información textual.

La búsqueda de texto es un proceso que consiste en encontrar términos en un índice para acceder a los documentos en los que aparecen. Tanto la recolección de datos como la generación de documentos son tareas específicas de cada aplicación y que, por lo tanto, Lucene no implementa. Además, tampoco proporciona ningún tipo de interfaz, por lo que cada aplicación deberá generar las suyas propias. Entre los módulos que aporta Lucene podemos destacar:

• Análisis de documentos (Analyze Document): Lucene proporciona diferentes analizadores que permiten controlar este proceso y ofrece la posibilidad de personalizar los analizadores que encontramos por defecto o crear uno nuevo combinando sus funcionalidades para tokenizar y filtrar los tokens, de manera que el proceso de creación de tokens puede ser personalizado.

• Indexado de documentos (Index Document): módulo que permite añadir los documentos al índice. Lucene almacena los documentos en una estructura de índice invertido, lo que hace más eficiente el almacenamiento del índice en el disco y agiliza las búsquedas.

• Construcción de la consulta (Build Query): cuando un usuario utiliza una aplicación de búsqueda, generalmente lo hace a través de un formulario web en el que introduce una consulta que el navegador envía al servidor web que contiene el motor de búsqueda. Una vez recibida, se debe transformar en una Query del motor de búsqueda; este proceso es el que engloba el módulo de “Construcción de la consulta”.

• Ejecución de la consulta (Run Query): es el proceso de consultar el índice de búsqueda y recuperar los documentos que coinciden con la Query solicitada. Lucene encapsula este paso, proporcionando una API para realizarlo de forma sencilla; aunque también permite personalizarlo, de forma que se pueda realizar el filtrado y ordenamiento de los resultados.

• Interpretación de resultados (Render Results): consiste en generar una lista de resultados que el usuario pueda entender y utilizar de forma sencilla. Esta lista se genera a partir de la lista interna de identificadores de documentos ordenados que concuerdan con una consulta.

El proceso de análisis comienza con la tokenización del texto, es decir, con la extracción de cadenas o palabras que lo componen, y que se conocen como tokens. Para generar los tokens, se aplican al texto diferentes procesos, como la extracción de palabras, la eliminación de los signos de puntuación, la normalización (paso a minúsculas), el stemming (reducción de las palabras a su forma raíz) o la lematizacion (la transformación de las palabras a su forma básica). Los tokens, combinados con el nombre de su campo asociado, forman los términos.

La aproximación de Lucene se basa en combinar diferentes modelos de espacio vectorial y booleano, y ofrece la posibilidad de decidir cuál de ellos usar a la hora de realizar una consulta. La fase de ejecución de la consulta termina cuando Lucene devuelve una lista de documentos que se debe transformar en una salida que el usuario pueda comprender y analizar.

Para la indexación y recuperación del contenido textual de los documentos que gestiona bastaría con utilizar alguno de los analizadores que proporciona por defecto Lucene. Pero si se quieren potenciar las búsquedas de modo que no se produzca demasiado ruido en los resultados y se encuentren documentos similares, hay que conseguir que los documentos estén lo más normalizados posible.

El proceso de normalización de los documentos se puede realizar utilizando alguna de las librerías que facilitan los siguientes procesos:

• Eliminación de stopwords: son palabras de uso frecuente que no se tienen en cuenta ni en el proceso de indexación ni en el de búsqueda.

• Stemming: es un método para obtener la cadena raíz —no necesariamente léxica— de una palabra, mediante el que las palabras se reducen a su raíz lingüística o a su stem. El proceso de stemming es muy útil para el inglés, aunque para el castellano no siempre se puede aplicar porque el stem de una palabra no tiene por qué coincidir con su raíz léxica.

Al analizar los datos de los que forma parte el proceso de tokenización, Lucene también ejecuta un proceso de normalización. Esto significa que los términos se convierten a una forma estandarizada, de modo que, por ejemplo, todas las mayúsculas se escriben en minúscula. Además, Apache Lucene introduce una clasificación mediante una serie de algoritmos (por ejemplo, a través de la medida TD-IDF), con la que es posible obtener los resultados más relevantes.

Lucene se encarga de construir y gestionar lo que se denomina índice invertido, una estructura de datos especializada que permite emparejar documentos de texto con términos de consulta del usuario. Las características principales de estos motores son:

• Escalables: capaces de distribuir el trabajo (indexación y procesado de consultas) entre múltiples servidores en un clúster.

• Listo para ser desplegado: ambas soluciones vienen con ejemplos prácticos para levantar un servicio con el mínimo esfuerzo.

• Optimizados para búsquedas: son rápidos, muy rápidos, capaces de ejecutar consultas complejas en decenas de milisegundos.

• Grandes volúmenes de datos: están diseñados para almacenar índices de millones de documentos.

• Centrados en texto: la principal ventaja que aporta es la posibilidad de manejar textos, extrayendo su estructura implícita al índice del motor para mejorar la búsqueda.

• Resultados ordenados por relevancia: dependiendo de la consulta del usuario, se le devuelven documentos clasificados en base a dicha consulta por orden de relevancia.

Dado que Lucene subdivide los documentos en campos de texto y los clasifica de forma lógica, la búsqueda de texto completo con Lucene funciona de forma muy precisa y responde bien al encontrar resultados relevantes para textos y documentos similares. Mientras reconozca un texto, el formato (texto plano, PDF, HTML u otros) es lo de menos porque, en lugar de indexar archivos, Lucene trabaja con texto y metadatos, aunque los archivos se han de extraer de la biblioteca de todas las formas posibles.

Para ello, el equipo de Lucene ha desarrollado el proyecto Apache Tika (https://tika.apache.org/index.html), que es una herramienta para el análisis, traducción e indexación de textos. La herramienta lee texto y metadatos de diferentes tipos de archivos y, posteriormente, extrae el texto y lo pone a disposición para su tratamiento posterior. Esta herramienta consta de un analizador (parser) y un detector. El analizador examina los textos y estructura el contenido en una jerarquía ordenada, mientras que el detector tipifica el contenido (por ejemplo, reconociendo el tipo de archivo y el tipo de contenido a partir de los metadatos).

Entre las funciones y características más importantes de Lucene podemos destacar:

• Indexación rápida, tanto en fases como por lotes (hasta 150 GB por hora, según sus desarrolladores).

• Uso económico de la memoria RAM.

• Escrito por completo en Java y, por lo tanto, multiplataforma (las variantes en lenguajes de programación alternativos son Apache Lucy y Lucene.NET).

• Interfaz para plugins.

• Búsqueda por campos de texto (categorías como contenido, título, autor, palabra clave), también para varios al mismo tiempo.

• Clasificación por campos de texto.

• Listado de los resultados de la búsqueda según similitud o relevancia.

2.3 ARQUITECTURA DE APACHE LUCENE

El proceso de indexación que utiliza Apache Lucene requiere analizar los objetos implicados en dicho proceso (figura 2.1):

Figura 2.1 Arquitectura de Apache Lucene.

• Directory. El directorio representa la ubicación de un índice de Lucene. Es una clase abstracta que permite a sus subclases almacenar el índice como mejor consideren. Podríamos obtener una implementación concreta para almacenar archivos en un directorio dentro del sistema de archivos, y pasar dicho objeto a su vez al constructor de IndexWriter.

• IndexWriter. IndexWriter es el componente central del proceso de indexación. Esta clase crea un nuevo índice o abre uno existente, y añade, elimina o actualiza documentos en el índice. Puede pensar en IndexWriter como en un objeto que le da acceso de escritura al índice pero que no le permite realizar búsquedas. IndexWriter necesita un lugar para almacenar su índice, y para eso sirve la clase Directory.

• Analyzer. Antes de indexar el texto, este se pasa por un analizador. El analizador, especificado en el constructor IndexWriter, se encarga de extraer esos tokens del texto y eliminar aquellas palabras que no sean relevantes. Analyzer es una clase abstracta y Lucene viene con varias implementaciones de la misma. Algunas de estas implementaciones se ocupan de omitir las stopwords y otras se encargan de la conversión de tokens a letras minúsculas. Para un desarrollador que integra Lucene en una aplicación, en ocasiones, la elección de los analizadores es un elemento crítico del diseño de la aplicación.

• Document. Un documento representa una colección de campos. Un documento es, simplemente, un contenedor para múltiples campos donde el campo es la clase que contiene el contenido textual que posteriormente se indexará en el índice. Los campos de un documento representan el documento o metadatos asociados con ese documento. Los metadatos (autor, título, tema y fecha de modificación) se indexan y se almacenan por separado como campos de un documento.

• Field. Cada documento en un índice contiene uno o más campos con un determinado nombre, incorporados en una clase llamada Field (campo). Cada campo tiene un nombre y un valor correspondiente, y un conjunto de opciones que controlan cómo Lucene indexará el valor del campo. Un documento puede tener más de un campo con el mismo nombre. En este caso, los valores de los campos se añaden, durante el proceso de indexación, en el orden en que se añadieron al documento.

Lucene, en principio, solo trata con texto y números. De esta forma, el núcleo de Lucene maneja los tipos java.lang.String para cadenas texto y java. io.Reader para lectura de ficheros y los tipos numéricos nativos (como int o float). Aunque varios tipos de documentos se pueden indexar y hacer búsquedas, procesarlos no es tan sencillo como procesar contenido puramente textual o numérico.

En nuestro indexador, para cada archivo de texto que encontramos creamos una nueva instancia de la clase Documento, la rellenamos con campos y metadatos y, finalmente, añadimos ese documento al índice, indexando finalmente el archivo.

La biblioteca Lucene ofrece posibilidades prácticamente ilimitadas para desarrollar sus propias aplicaciones de búsqueda. El proceso de desarrollo se centra en los dos pasos clave para buscar por índice invertido: primero indexar documentos y posteriormente realizar búsquedas sobre los índices creados.

La clase Java org.apache.lucene.index.IndexWriter es responsable de crear y modificar índices. El constructor de la clase org.apache.lucene.index.IndexWriter acepta dos argumentos: un objeto de la clase org.apache. lucene.store.Directory, que representa un directorio donde almacenar los documentos, y otro objeto tipo configuración de la clase org.apache.lucene.index.IndexWriterConfig.

Posteriormente, con el método IndexWriter.addDocument() podemos añadir un documento al índice. El método close() guarda los cambios en el directorio indicado y cierra los archivos temporales que pudieran quedar abiertos.

Un documento consta de un número de campos que Lucene define con la clase org.apache.lucene.document.Field. Estos campos no siguen un esquema definido, ya que cada documento dentro de un índice puede contener campos de diferentes tipos y contenidos. En la práctica, los campos sirven para clasificar el contenido y hacer que se pueda buscar por separado. Los desarrolladores usan el método add() para añadir este contenido a un objeto del tipo Document. Para los casos más comunes, Lucene proporciona una serie de subclases apropiadas para diferentes tipos de datos, como TextField, IntField y DoubleField.

El siguiente ejemplo crea un documento y lo almacena en el índice utilizando el método addDocument() del objeto IndexWriter:

/* Creando un objeto IndexWriter * /

Analyzer analyzer = new EnglishAnalyzer(VERSION. Lucene_40);

IndexWriterConfig config = new IndexWriterConfig(analyzer);

Directory dir = FSDirectory.open(new File(“/home/user/lucene/index”));

IndexWriter writer = new IndexWriter(dir, config);

/* Nuestro documento a almacenar*/

Field textField = new TextField(“text”, “My document”, Field.Store.YES);

Document documento = new Document();

documento.add(textField);

/* Añadir el documento al índice*/

writer.addDocument(documento);

writer.close();

En el código anterior vemos cómo se configura el objeto IndexWriterConfig, donde se ha utilizado un objeto de la clase org.apache.lucene.analysis. Analyzer, que se encarga del análisis de los textos que se van añadiendo al índice. En el ejemplo anterior se ha empleado el analizador para textos en inglés con la clase org.apache.lucene.analysis.en.EnglishAnalyzer.

2.3.1 Proceso de tokenización y búsqueda en Apache Lucene

El analizador comentado desempeña un papel importante para la estructura del índice porque, entre otras cosas, se encarga del proceso de “tokenización”, es decir, de la división del texto en los componentes representados por sus propios tokens de entrada en el índice invertido.

Este proceso es una tarea bastante compleja porque debe diferenciar correctamente entre signos de puntuación y caracteres especiales como partes de un token (como en una dirección web o de correo electrónico) y caracteres independientes (como un punto al final de una oración).

Además, existen numerosas formas de optimizar el índice en el análisis; por ejemplo, se pueden eliminar palabras como “y” —que son bastante frecuentes pero de poca importancia— con la ayuda de los filtros que se encuentran en org.apache.lucene.analysis.TokenFilter.

Los analizadores y tokenizadores son componentes importantes del proceso de indexación porque determinan qué puede buscar un usuario. Para ayudar a evitar cualquier confusión de los diferentes algoritmos de análisis y tokenización, cuando se realiza una consulta sobre alguno de los índices normalmente se lleva acabo utilizando el mismo analizador que el empleado para indexar los documentos.

String queryString = new String(“texto_buscar”);

int maxHits = 100;

/* Crear los objetos IndexReader y IndexSearcher */

Analyzer analyzer = new EnglishAnalyzer(VERSION. Lucene_40);

Directory dir = FSDirectory.open(new File(“/home/user/lucene/index”));

IndexReader reader = DirectoryReader.open(dir);

IndexSearcher searcher = new IndexSearcher(reader);

/* Crear y ejecutar una query */

StandardQueryParser parser = new StandardQueryParser(analyzer);

Query query = parser.parse(queryString);

TopDocs topdocs = searcher.search(query, maxHits);

/* Leer los documentos que se han encontrado */

ScoreDoc[] docs = topdocs.scoreDocs;

for (ScoreDoc documento : docs){

System.out.println(documento.doc+»\t»+documento.score);

}

reader.close();

En el ejemplo anterior, en primera instancia creamos los objetos IndexReader e IndexSearchers. La clase org.apache.lucene.index.IndexReader es responsable de leer un índice a partir de un objeto de la clase org.apache.lucene.index. DirectoryReader, que contiene el directorio donde se encuentra almacenado nuestro índice. El constructor de la clase org.apache.lucene.search.Index-Searcher recibe dicho objeto IndexReader como parámetro en su constructor.

Respecto al proceso de búsqueda, la clase IndexSearcher será la encargada de ejecutar las consultas de búsqueda utilizando un objeto IndexReader. Un objeto de la clase org.apache.lucene.queryparser.flexible.standard. StandardQueryParser genera dichos objetos de consulta a partir de una cadena de consulta y un analizador. Alternativamente, los desarrolladores pueden implementar su propio analizador de consultas para construir los diferentes tipos de consultas y objetos de búsqueda de forma personalizada.

Las búsquedas pasan por el método search() del objeto IndexSearcher. El resultado se almacena en un objeto de la clase org.apache.lucene.search. TopDocs, que contiene los documentos encontrados, así como información sobre el número de documentos y la relevancia de cada uno de ellos.

2.4 TRABAJAR CON APACHE LUCENE

Antes de crear un índice y empezar a trabajar con Lucene, es necesario descargar el framework y crear un proyecto para empezar a trabajar. Lucene está disponible en la página web http://lucene.apache.org, en concreto dentro de la sección Apache Lucene Core (http://lucene.apache.org/core). En la sección Download encontrará disponible para descargar la última versión disponible. Una vez descargado el archivo, lo descomprimimos en una carpeta y extraemos los ficheros que vamos a necesitar para incorporarlos a nuestro proyecto.

2.4.1 Configuración del entorno

Lucene está construido en Java, por lo que es necesario disponer de un sistema operativo compatible con Java con el JDK instalado. Se recomienda usar una versión del JDK compatible con la última versión de Lucene (figura 2.2). Una forma de incluir Lucene en un proyecto de Java es a través de un repositorio Maven. Aquí hay una descripción de dependencia de Maven de muestra para incluir en la biblioteca lucene-core. Puede encontrar el repositorio oficial de Lucene en http://mvnrepository.com/artifact/org.apache.lucene.

Figura 2.2 Librería de Apache Lucene en el repositorio de Java.

Para configurar Lucene en Maven, es necesario añadir la siguiente configuración en el fichero de dependencias pom.xml del proyecto. La versión con la que vamos a trabajar es la publicada en el repositorio de Maven, la 8.6.3.

https://mvnrepository.com/artifact/org.apache.lucene/lucene-core/8.6.3

<!-- https://mvnrepository.com/artifact/org.apache.lucene/lucene-core -->

<dependency>

<groupId>org.apache.lucene</groupId>

<artifactId>lucene-core</artifactId>

<version>8.6.3</version>

</dependency>

Los pasos para crear un proyecto desde Eclipse son:

• Creamos un nuevo proyecto haciendo clic en File -> New-> Maven Project (figura 2.3).

Figura 2.3 Crear nuevo proyecto con Maven desde Eclipse.

• Introducimos un nombre para el artefecto y definimos la versión (figura 2.4).

Figura 2.4 Nombre y versión del artefacto Maven.

El siguiente paso consiste en añadir en el fichero pom.xml las dependencias correspondientes a la API de Lucene.

También podríamos configurar el proyecto añadiendo las librerías al Build Path y haciendo clic en Add External Archives. Podríamos añadir las siguientes librerías (figura 2.5):

Figura 2.5 Librerías para el Java Build Path.

2.4.2 Crear un índice

El núcleo de un motor de búsqueda basado en Lucene es el índice. Por eso, el primer paso es crear una clase en Java para la indexación. La creación de un índice constituye el punto de partida para el trabajo con Lucene. Una vez generado, se le irá añadiendo la información relevante de los distintos documentos seleccionados para el análisis.

Antes de empezar con el ejemplo, vamos a crear una clase en un proyecto de Eclipse. Para ello, haga clic con el botón derecho sobre el nombre del proyecto y, en el menú desplegable, haga clic en New>Class. En la ventana emergente, en este ejemplo escribiremos “LuceneCrearIndice”, seleccionando también las casillas “Public static void main” e “Inherited abstract method”.

El programa que se muestra a continuación, LuceneCrearIndice.java, construye un índice, para lo cual simplemente crea un objeto de la clase IndexWriter que busca e indexa los documentos que se encuentran en una carpeta específica.

En esta clase creamos nuestro índice, junto con las funciones para generar un documento en el índice. En este caso, empleamos la clase IndexWriter del paquete org.apache.lucene.index, que se configura con un objeto de la clase ClasicAnalyzer. Lucene ofrece diferentes clases para análisis; todas ellas se encuentran dentro del paquete org.apache.lucene.analysis.

El siguiente código lo podemos encontrar en el fichero LuceneCrearIndice. java dentro del repositorio:

En el código anterior tendríamos que modificar la rutas por otras que apunten a nuestro equipo. Para cada archivo encontrado en dicha carpeta creamos un objeto tipo Document; estos serán los objetos que realmente se indexarán en el índice. A esta variable le añadimos objetos de tipo Field, que son los campos que queremos indexar y a través de los cuales podremos realizar búsquedas.

Lucene proporciona la clase FSDirectory para indicarle la ruta donde crear el índice en el sistema de archivos. El parámetro indexPath representa la ubicación del directorio; si no existe el directorio, Lucene lo creará de forma automática.

Directory directory = FSDirectory.open(Paths. get(indexPath));

Lucene indexa objetos tipo Document propios de la API de Lucene. Recorre el directorio buscando archivos con extensión txt y con permisos de lectura. En este caso, a cada variable Document le añadimos dos variables Field: una con el nombre del archivo y otra con su contenido. Una vez añadidos los campos a la variable Document, el documento se añade al índice con la instrucción indice.add(doc).

En el ejemplo anterior, lo que hemos hecho ha sido indexar tantos documentos como teníamos en la ruta definida en la variable directorioDocumentos. Esta podría ser la salida:

Indexing /home/linux/documentos/java.txt

Indexing /home/linux/documentos/python.txt

Indexing /home/linux/documentos/php.txt

Indexing /home/linux/documentos/lucene.txt

Indexing /home/linux/documentos/golang.txt

El número de documentos indexados es 5

Al crear el índice, Lucene genera los segmentos para ir añadiendo documentos; cada segmento es un índice completamente independiente a partir del cual realizar búsquedas por separado.

2.4.3 Crear y escribir documentos en un índice

El siguiente código muestra un ejemplo de cómo añadir un documento a un índice. Para ello, primero se inicializan una serie de objetos de las clases Analyzer, Directory, IndexWriterConfig e IndexWriter. Una vez que se obtiene un objeto IndexWriter, se crea un nuevo documento de la clase Document con un TextField personalizado. Por último, el documento se añade al IndexWriter a través del método addDocument(doc).

El ejemplo lo podemos encontrar en el fichero LuceneCrearIndiceDocumentos.java:

Hemos visto cómo se obtiene un IndexWriter inicializado con los objetos Analyzer e IndexWriterConfig. El comportamiento de inicialización predeterminado funciona bien la mayoría de las veces. Sin embargo, puede haber situaciones en las que necesite un control más preciso durante la secuencia de inicialización. Por ejemplo, cuando el comportamiento predeterminado crea un nuevo índice y no existe un índice previo. Esto puede no ser ideal en un entorno de producción donde siempre debe existir un índice.

La clase IndexWriter expone el método addDocument(doc) que le permite añadir un documento al índice. IndexWriter añadirá dicho documento al índice especificado por el directorio. Además, es importante realizar la llamada al método indexWriter.close() al final para que se confirmen todos los cambios, y cerrar el índice para que ningún otro proceso pueda escribir sobre el mismo.

Para que los documentos queden registrados en el índice, además, hay que aplicar el método commit() del objeto IndexWriter; así, los cambios quedarán reflejados en el índice. Al final, el objetivo es añadir documentos al índice a través del objeto IndexWriter, cuya documentación podemos encontrar en:

https://lucene.apache.org/core/8_6_3/core/org/apache/lucene/index/IndexWriter.html

En el código anterior hemos utilizado el método addDocument() para añadir documentos a un índice. Este método proporciona dos constructores (uno donde se pasa por un parámetro un objeto Document y otro donde, además, se pasa por el parámetro un objeto Analyzer):

• addDocument(Document): este método permite añadir el documento utilizando el analizador predeterminado para la tokenización que se indicó al crear el IndexWriter.

• addDocument(Document, Analyzer): permite añadir el documento utilizando el analizador proporcionado para la tokenización. Para que las búsquedas funcionen correctamente, necesita el analizador empleado en el momento de la búsqueda para “hacer coincidir” los tokens producidos por los analizadores en el momento de la indexación.

2.5 REALIZAR BÚSQUEDAS EN APACHE LUCENE

Tras revisar el proceso de indexación de documentos en Lucene, continuamos con la implementación del proceso de búsqueda. Hay que tener en cuenta que la indexación es un proceso necesario para que los textos puedan buscarse.

Si consideramos un escenario de búsqueda donde ya tenemos un índice construido y funcionando en nuestro clúster, el objetivo será buscar todos aquellos documentos relacionados con el índice de Lucene que coincidan con un término de búsqueda. Lucene tiene la capacidad de obtener documentos con solo introducir el término Lucene en el índice, y devolver todos los documentos relacionados. Un término en Lucene contiene dos elementos: el valor y el campo en el que aparece.

2.5.1 Obtención de un IndexSearcher

Para realizar una búsqueda concreta necesitamos apoyarnos en la clase IndexSearcher, que proporciona la base para realizar búsquedas sobre el índice. La clase IndexSearcher es la puerta de entrada para buscar en un índice, en lo que respecta a Lucene. Un IndexSearcher toma un objeto IndexReader y realiza una búsqueda a través de este objeto.

IndexReader se comunica con el índice físicamente y devuelve los resultados. A continuación, se describe un fragmento de código que muestra cómo obtener un objeto de la clase IndexSearcher:

Directory directory = getDirectory();

IndexReader indexReader = DirectoryReader. open(directory);

IndexSearcher indexSearcher = new IndexSearcher(indexReader);

Para que los usuarios puedan realizar búsquedas y obtener lo que buscan, deben introducir un término o términos de búsqueda como parámetro de entrada. Dicho término recibe el nombre de Query (consulta) en el contexto de Apache Lucene. Esta entrada no solo debe estar formada por una palabra o conjunto de ellas, sino que también puede contener comodines y operadores booleanos como AND, OR o + y -, entre otros.

Esta consulta la vamos a construir con un objeto de la clase QueryParser, una clase dentro de Lucene que permite traducir la entrada en una solicitud de búsqueda concreta para el motor de búsqueda. Los desarrolladores también pueden configurar QueryParser de modo que se adapte exactamente a las necesidades del usuario. A continuación, pasamos a analizar cómo realizar una búsqueda. Para ello, necesitamos crear un objeto Query con un QueryParser.

2.5.2 Proceso de búsqueda con IndexSearcher

Antes de comenzar una búsqueda, necesitamos obtener un objeto de la clase IndexSearcher para facilitar la consulta de un índice determinado. IndexSearcher proporciona varios métodos de búsqueda para consultar datos y devolver objetos del tipo TopDocs como resultado.

TopDocs representa los resultados de una búsqueda y contiene una matriz de ScoreDoc que contiene el identificador de cada documento (DocId) y la puntuación (score) de cada documento que coincida con los criterios de búsqueda.

Hay que tener en cuenta que TopDocs contiene identificadores de documentos (DocId), pero no contiene ningún contenido del documento. La recuperación del contenido del documento deberá basarse en las clases IndexReader o FieldCache. Un IndexSearcher requiere un IndexReader como entrada a su constructor para inicializar. Veamos un fragmento de código simple para ver cómo se configura IndexSearcher:

Path path = Paths.get(“/home/linux/documentos”);

Directory directorio = FSDirectory.open(path);

IndexReader indexReader = DirectoryReader.open(directorio);

IndexSearcher indexSearcher = new IndexSearcher(indexReader);

Primero, configuramos un objeto de clase Directory para poder pasarlo a un DirectoryReader, que es básicamente un IndexReader. Luego, pasamos el DirectoryReader a IndexSearcher para su inicialización. Hay que tener en cuenta que IndexReader realiza una instantánea del contenido del índice en un instante de tiempo. Por lo tanto, si se actualiza el índice, debemos asegurarnos de volver a abrir el IndexReader y el IndexSearcher para que los últimos cambios aparezcan en el índice para la búsqueda.

Ahora que tenemos un IndexSearcher, estamos listos para continuar con las consultas. Para comenzar, necesitaremos construir un objeto Query para pasar al método de búsqueda de IndexSearch. Hay un par de formas de construir una consulta. QueryParser proporciona la utilidad para interpretar texto y convertirlo en una consulta.

Si fuera necesario utilizar modificadores de búsqueda, hay una sintaxis a seguir con el fin de formar una cadena de consulta. Por defecto, una frase de búsqueda devolverá cualquier documento que tenga coincidencias en cualquiera de los términos de la consulta. Mostraremos el funcionamiento de QueryParser en la próxima sección.

2.5.3 Crear consultas con Lucene QueryParser

Lucene admite un potente motor de consultas que permite una amplia gama de tipos de consulta. El siguiente paso para realizar búsquedas es crear objetos de consulta con la clase QueryParser. QueryParser es una clase que analiza una cadena de consulta y proporciona la utilidad para convertir la entrada de texto en objetos.

El método principal de la clase QueryParser es parse(String) (figura 2.6). En la siguiente imagen vemos un extracto de la documentación en formato JavaDoc de Lucene para esta clase: https://lucene.apache.org/core/8_6_3/queryparser/index.html

Figura 2.6 Extracto del JavaDoc de la clase QueryParser.

Ahora que tenemos un objeto de consulta, estamos listos para ejecutar una búsqueda. Hay que tener en cuenta que, por defecto, Lucene ordena los resultados según su relevancia y dispone de un mecanismo de puntuación que asigna una puntuación a cada documento que coincida con los criterios de búsqueda. Esta puntuación es responsable del orden de clasificación en los resultados de búsqueda.

El siguiente código lo podemos encontrar en el fichero LuceneBuscarDocumentos.java:

import java.nio.file.Path;

import java.nio.file.Paths;

import org.apache.lucene.analysis.Analyzer;

import org.apache.lucene.analysis.core.WhitespaceAnalyzer;

import org.apache.lucene.document.Document;

import org.apache.lucene.index.DirectoryReader;

import org.apache.lucene.index.IndexReader;

import org.apache.lucene.queryparser.classic.QueryParser;

import org.apache.lucene.search.IndexSearcher;

import org.apache.lucene.search.Query;

import org.apache.lucene.search.ScoreDoc;

import org.apache.lucene.search.TopDocs;

import org.apache.lucene.store.Directory;

import org.apache.lucene.store.FSDirectory;

Path path = Paths.get(“/home/linux/documentos”);

Directory directorio = FSDirectory.open(path);

Analyzer analyzer = new WhitespaceAnalyzer();

IndexReader indexReader = DirectoryReader.open(directorio);

IndexSearcher indexSearcher = new IndexSearcher(indexReader);

QueryParser parser = new QueryParser(“texto”,analyzer);

Query query = parser.parse(“Python”);

int hitsPerPage = 10;

TopDocs docs = indexSearcher.search(query, hitsPerPage);

ScoreDoc[] hits = docs.scoreDocs;

int end = (int) Math.min(docs.totalHits.value, hitsPerPage);

System.out.print(“Total de documentos: “ + docs.totalHits);

System.out.print(“\nResultados: “);

for (int i = 0; i < end; i++) {

Document d = indexSearcher.doc(hits[i].doc);

System.out.println(“\tDocumento: “ + d.get(“nombre”)+” Texto: “ + d.get(“texto”));

}

En el fragmento de código anterior, utilizamos la clase QueryParser para generar un objeto del tipo Query. El objeto QueryParser puede aceptar cualquier texto como primer parámetro y convertirlo en una consulta. Hay que tener en cuenta que también tenemos que proporcionar un analizador (Analyzer) a QueryParser como segundo parámetro.

Esto se hace para poder aplicar el mismo tratamiento de análisis de texto que en el proceso de indexación y garantizar de esta forma la precisión de la búsqueda.

Una vez definido el objeto de búsqueda, podríamos obtener los documentos con el método search y recorrerlos con el siguiente bucle:

TopDocs topDocs = indexSearcher.search(query, hitsPerPage);

for (ScoreDoc scoreDoc : topDocs.scoreDocs) {

Document documento = new Document();

documento = indexReader.document(scoreDoc.doc);

System.out.println(scoreDoc.score + “: “ + documento.getField(“nombre”).stringValue()+ “ “+ documento.getField(“texto”).stringValue());

}

Puede pensar en IndexSearcher como en una clase que abre un índice en modo de solo lectura. Requiere una instancia de la clase Directory que contenga el índice creado previamente y, luego, ofrece una serie de métodos de búsqueda. El método search acepta como parámetros un objeto Query y un número entero —que indica el número de documentos a devolver— y devuelve un objeto TopDocs.

En la ejecución del programa LuceneBuscarDocumentos.java vemos el número de documentos obtenidos para la cadena de búsqueda Python, junto con la puntuación de cada documento (figura 2.7):

Figura 2.7 Ejecución del programa LuceneBuscarDocumentos.java.

2.5.4 Sintaxis de las consultas en Apache Lucene

La mayoría de los motores de búsqueda no solo se limitan a la búsqueda de un solo término. Con determinados métodos es posible encadenar términos, buscar frases o excluir palabras concretas. Apache Lucene también ofrece estas posibilidades a través de Lucene Query Syntax, que permite buscar expresiones complejas, incluso en diferentes campos.

• Un solo término: Lucene asume que el término introducido está escrito correctamente. Si el usuario introduce un error ortográfico, obtendrá un resultado negativo al buscar por este término.

• Frase: las frases son secuencias de palabras establecidas. En este caso, no solo son importantes los términos individuales introducidos, sino también el orden en que aparecen.

• Consulta con comodines: en la consulta puede reemplazar uno o más caracteres con diferentes marcadores de posición. Los caracteres comodines pueden usarse tanto al final como en la mitad de un término, pero nunca al principio. Por ejemplo, el asterisco sustituye a un número infinito de caracteres.

• Consulta de expresiones regulares: con las expresiones regulares puede buscar al mismo tiempo varios términos que comparten una serie de similitudes. A diferencia de los comodines, con estos marcadores se definen exactamente aquellas expresiones con las cuales quiere coincidir.

• Consulta Fuzzy Searching: este tipo de consulta se utiliza cuando se quiere tener tolerancia a errores. Se emplea la distancia de Damerau-Levenshtein, fórmula que evalúa las similitudes para establecer cuán grande puede ser la desviación. Use la virgulilla para indicarlo. Se admiten distancias de 0 a 2. Ejemplo: Coche~1.

• Búsquedas de proximidad: cuando quiera permitir una aproximación en las frases, utilice también la virgulilla. Por ejemplo, puede especificar que desea buscar dos términos incluso si hay 5 palabras entre ellos. Ejemplo: “Coche rojo”~5.

• Búsquedas por rango: en este tipo de consulta se busca entre dos términos en un área concreta. La clasificación funciona de acuerdo con un orden lexicográfico. Se recurre a los corchetes para indicar un área de inclusión y a las llaves para indicar un área de exclusión (en ambos casos determinadas por los dos términos indicados en la búsqueda). Estos términos están delimitados con “TO” (a, hacia).

• Boosting: Lucene ofrece la oportunidad de dar más relevancia en la búsqueda a determinados términos o frases, lo que influye en la clasificación de los resultados. Para indicar este parámetro de búsqueda se utiliza el acento circunflejo seguido del valor al que se le quiera dar más relevancia. Ejemplo: Coche^2 rojo.

• Operadores booleanos: los operadores lógicos sirven para establecer conexiones entre términos en una consulta. Los operadores han de estar siempre escritos en mayúsculas, para que Lucene no los considere términos de búsqueda normales. Entre los principales operadores podemos destacar:

− AND: con el operador AND, ambos términos deben estar presentes en el documento para que este se muestre como resultado. En lugar del término AND se pueden usar también los símbolos &&. Ejemplo: Coche && rojo.

− OR: con el operador OR, situado entre dos términos de búsqueda, se indica que para que se muestre un documento como resultado al menos uno de los términos indicados ha de aparecer en él. Además de OR, se puede usar el símbolo ||. Ejemplo: Coche || rojo.

− +: el signo más se utiliza para establecer un caso específico del operador OR. Si se coloca el símbolo directamente delante de una palabra, se establece que dicho término debe aparecer, mientras que el otro es opcional. Ejemplo: +Coche rojo.

− NOT: el operador NOT excluye ciertos términos o frases de la búsqueda. También podemos utilizar un signo de exclamación o colocar un signo menos justo antes del término que se desea excluir. Ejemplo: Coche rojo NOT azul.

• Agrupar términos: utiliza los paréntesis para agrupar términos dentro de una consulta. Es de gran utilidad para crear entradas más complejas; por ejemplo, para vincular un término con otros dos que se rijan por un criterio de búsqueda diferente: Coche AND (rojo OR azul).

• Escapar caracteres especiales: si necesitamos utilizar como términos de búsqueda aquellos caracteres que se emplean en la sintaxis de Lucene, podemos combinarlos mediante una barra invertida. Así, podremos insertar, por ejemplo, un signo de interrogación en una consulta de búsqueda sin que el analizador lo interprete como un comodín. Para ello, es necesario escapar este carácter con la barra invertida: “¿Dónde está mi coche\?”.

2.6 BÚSQUEDA DE INFORMACIÓN CON APACHE LUCENE

La búsqueda de documentos constituye la funcionalidad principal proporcionada por Lucene. Para ello, aporta múltiples clases y métodos para la representación de consultas y para realizar búsquedas en el índice de aquellos documentos que son relevantes y cumplen con los criterios de la búsqueda. El código que se muestra a continuación, LuceneBuscador.java, es un ejemplo de cómo buscar en un índice utilizando Lucene.

El siguiente código lo podemos encontrar en el fichero LuceneBuscador.java:

En el código anterior podemos ver que hay dos clases importadas por Lucene que son las más importantes: IndexSearcher y QueryParser. Index-Searcher realiza la búsqueda en el índice y QueryParser es responsable de transformar la consulta de búsqueda a un tipo de información que el motor pueda entender. Las tres clases más importantes que proporcionan métodos relacionados con la búsqueda de documentos indexados son IndexSeacher, Query y TopDocs:

• IndexSeacher: es el corazón del proceso de búsqueda a través del cual se pueden realizar consultas (Query) que devuelven resultados (TopDocs).

• Query: es una clase abstracta que permite definir la consulta sobre la que queremos realizar la búsqueda. Nos permite buscar a partir de los campos (Field) de los documentos.

• TopDocs: contiene una lista con los documentos que cumplen las condiciones de la búsqueda.

La clase LuceneBuscador constituye la base para cualquier búsqueda en un índice de documentos (figura 2.8). En esta se crea un objeto del tipo IndexSearcher, y se pasa como parámetro al constructor el directorio donde se encuentra el índice de documentos. El método más importante de esta clase es el método search(), que devuelve todos aquellos documentos que cumplen con las condiciones de la búsqueda.

La clase Query y su clase hija QueryParser permiten analizar gramaticalmente la consulta con el método parse(). Para crear el objeto del tipo QueryParser, partimos del campo en el que deseamos buscar dentro del índice junto con el analizador gramatical.

Posteriormente, aplicamos el método parse() a la consulta y obtenemos un objeto de tipo Query, que es el que debemos usar en la búsqueda. Una vez que se obtiene una Query, se le pasa como argumento al método search(), y se realiza la búsqueda.

El método search() devuelve un objeto de tipo TopDocs, que representa una colección ordenada de documentos. El orden se determina por la relevancia de la Query en cada documento. De esta manera, se obtienen en primer lugar aquellos documentos que se ajustan mejor a las expectativas de la búsqueda.

Figura 2.8 Ejecución del programa LuceneBuscador.java.

En la salida vemos, para cada documento, donde aparece el término de búsqueda, la puntuación correspondiente:

Total de documentos: 3 hits

Puntuacion:0.24604079/python.txt

Puntuacion:0.22728294/lucene.txt

Puntuacion:0.22728294/golang.txt

2.7 BÚSQUEDA EN MÚLTIPLES ÍNDICES DE LUCENE

Algunas aplicaciones necesitan mantener índices de Lucene separados, pero permiten que una sola búsqueda devuelva resultados combinados de todos los índices. A veces, dicha separación se realiza por cuestiones de rendimiento o por temas de permisos; por ejemplo, si diferentes desarrolladores o grupos mantienen el índice para diferentes colecciones de documentos. Otras veces se puede hacer debido al alto volumen; por ejemplo, un sitio de noticias puede considerar implementar un nuevo índice para cada nuevo mes y, luego, elegir en qué meses buscar.

Para estos casos, Lucene proporciona las clases MultiReader para buscar en múltiples índices. Con la clase MultiReader podemos realizar búsquedas en varios índices con los resultados combinados en un orden específico.

El uso de MultiReader es comparable al uso de IndexSearcher, excepto en que el resultado devuelto es una matriz de objetos IndexReaders para buscar, en lugar de un solo directorio. El siguiente ejemplo muestra cómo buscar en dos índices de forma separada.

El siguiente código lo podemos encontrar en el fichero LuceneMultiSearcher.java:

2.8 HERRAMIENTAS DE ADMINISTRACIÓN DE LUCENE

Para poder ver y realizar búsquedas en el propio índice existen un par de herramientas: Luke y Limo. Con ellas podemos monitorizar para ver si todo ha ido bien al crear el índice.

Luke (https://code.google.com/p/luke) es una herramienta de diagnóstico. Puede acceder a un índice existente y permite modificar y ver el contenido de varias formas:

• Buscar por número de documento o por término.

• Ver todos los documentos.

• Recuperar una lista de términos.

• Optimizar el índice.

Para utilizarla, solo necesitamos descargar el fichero jar y ejecutarlo. Al abrirlo, debemos indicarle cuál es la ruta del índice que hemos creado con Lucene. Una vez hecho esto, nos indicará todos los documentos que se han indexado, el número de términos, el ranking y otras estadísticas.

Limo (http://limo.sourceforge.net) es otra herramienta open source que debe su nombre a Lucene Index Monitor. Se trata de una aplicación web que proporciona información básica acerca de los índices utilizados por el motor de búsqueda de Lucene. Para instalar y utilizar Limo solo es necesario tener un contenedor de Servlets como Tomcat y copiar el fichero war al directorio /web-app. Bastaría con entrar en http://localhost:8080/limo-0.61/ para realizar búsquedas en nuestro índice.

2.9 HERRAMIENTAS DE BÚSQUEDA QUE USAN APACHE LUCENE

A continuación, analizamos algunos proyectos que usan Lucene a bajo nivel para realizar las búsquedas.

2.9.1 Krugle

La herramienta que ofrece Krugle.org permite la búsqueda de código en los repositorios y proyectos open source. Krugle utiliza Lucene para la indexación y búsqueda de código fuente de forma inteligente (figuras 2.9 y 2.10).

Krugle.org proporciona un motor de búsqueda de código fuente que cataloga continuamente más de 5000 proyectos de código abierto (incluidos Lucene y sus proyectos adyacentes bajo el paraguas de Apache Lucene), lo que le permite buscar dentro del código fuente.

https://opensearch.krugle.org/document/search/#query=lucene&qtype=basic

Figura 2.9 Búsqueda de código fuente en Krugle.

Una búsqueda de Lucene muestra coincidencias no solo del código fuente de Lucene, sino también de los muchos proyectos de código abierto que usan Lucene.

Figura 2.10 Proyectos y código fuente en Krugle.

Como vemos, se trata de un servicio que se puede integrar con otras herramientas a nivel empresarial, con el objetivo de crear un catálogo único y completo de código fuente, metadatos del proyecto e información de la organización asociada a los proyectos a nivel de desarrollo y análisis del código fuente.

Este análisis podría ayudar a los proyectos a aumentar la reutilización del código, reducir los costes de mantenimiento, mejorar el análisis de impacto y monitorizar la actividad de desarrollo en equipos grandes y distribuidos.

2.9.2 Google Dataset Search

Google Dataset Search (https://datasetsearch.research.google.com/) es un servicio que permite indexar cualquier contenido procedente de los sitios web que hayan seguido las directrices de Google a la hora de etiquetar y estructurar sus conjuntos de datos.

Entre las nuevas funcionalidades de Dataset Search se encuentra la posibilidad de filtrar los resultados en función del tipo de contenidos deseados (tablas, imágenes, texto) y de acceder al Dataset gratuitamente (figura 2.11).

Figura 2.11 Resultados de búsqueda en Google Dataset Search.

Además, un punto a favor de esta herramienta frente a la clásica búsqueda en Google es que los conjuntos de datos se muestran con una serie de etiquetas que permiten una rápida vista de pájaro de los contenidos disponibles en cada caso. Entre ellas figuran rango de fechas, fuente, descripción, área abarcada y última fecha de actualización.