Sur cette page, il est possible de voir le statut de la dernière compilation nocturne. Si ce statut indique une compilation réussie, la procédure pour obtenir et compiler les sources est la suivante :

Créer un répertoire de travail :

mkdir ~/solr-4.0

Se placer dans ce répertoire et récupérer les sources :

cd ~/solr-4.0
svn checkout http://svn.apache.org/repos/asf/lucene/dev/trunk

Compiler les sources :

cd ~/solr-4.0/modules
ant compile
cd ~/solr-4.0/lucene
ant dist
cd ~/solr-4.0/modules
ant dist

Le tour est joué !

* créer un répertoire de travail

mkdir /tmp/solr

* copier solr.war dans /tmp/solr

* extraire le contenu de solr.war et effacer solr.war

cd /tmp/solr
jar -xvf solr.war
rm solr.war

* remplacer dans /tmp/solr/WEB-INF/lib tous les fichiers lucene-…-2.9.0.jar par leurs équivalents en version 2.9.3.

* astuce pour les utilisateurs de mac os, il faut supprimer les fichiers cachés « .DS_Store » qui ont été créés dans chaque répertoire

find . -name .DS* -print -exec rm -rf {} \;

* reconstruire solr.war

jar cvf solr.war .

Pour consulter la liste des évolutions et corrections depuis Lucene 2.9.0, vous pouvez consulter le « Lucene Change Log« .

A lire ici

A lire sur  ARTICLE GALLERY

Erik Hatcher est un développeur de logiciels open-source. Avant Lucene et Solr, il a participé à de nombreux projets comme Ant, Tapestry et plusieurs sous-projet Jakarta.

Lisez son interview sur The Bitsource

Dans cet article, je présente une solution afin de générer un nuage de tags (ou nuage de mots clefs) à partir d’un flux de données textuelles. Pour l’exemple, il s’agit de titres d’articles stockés dans un fichier texte.

Le but est d’afficher les mots ou expressions de 2 ou 3 termes les plus fréquents dans les titres. Tous les termes ou expressions ne sont pas à conserver dans le nuage de tag. Une des étapes consiste en un filtrage selon des règles définies dans fichiers de règles : suppression des mots vides (je, le, pour, …), suppression des expressions commençant ou se terminant par un mot vide (”ne mange”, “termes les”, …), suppression des nombres, …

Les étapes nécessaires à la mise en œuvre de cette solution sont :

• Etape 1 : indexation des titres dans Lucene
• Etape 2 : extraction des termes ou expressions de l’index
• Etape 3 : filtrage des termes ou expressions
• Etape 4 : affichage du nuage en PHP

Les 3 premières étapes sont réalisées en java avec Lucene et donne comme résultat un fichier de termes ou expressions retenues dans le nuage de tags avec leur fréquence d’apparition.

La 4ème étape est réalisée en PHP et exploite le fichier résultat des étapes précédentes afin de mettre en forme le nuage de tags.

Pourquoi utiliser Lucene (étapes 1 et 2) ?

La génération du nuage de tags nécessite 2 étapes que Lucene est à même de réaliser : analyser et découper le texte servant à générer le nuage de tags et indiquer la fréquence d’apparition de chaque mot ou expression.

Lucene utilise des analyzers afin d’indexer le texte. Ces analyzers ont pour rôle principal de découper le texte en « token ». Selon les analyzers utilisés les tokens sont séparés par des espaces, des ponctuations, des caractères spéciaux (#, @, …), des chiffres, …

Par exemple, pour la phrase suivante : « Parcours du Tour de France », les tokens seraient sans doute : « parcours », « du », « tour », « de » et « France ».

Dans notre nuage de tags, nous ne voulons pas uniquement des mots simples, mais également des expressions de 2 ou 3 mots. Il nous faut donc extraire toutes les combinaisons possibles de tokens de 1, 2 ou 3 mots, c’est-à-dire : « parcours », « du », « tour », « de », « France », « parcours du », « du tour », « tour de », « de France », « parcours du tour », « du tour de » et « tour de France »

Un analyzer permettant de faire cela est disponible non pas dans la distribution standard de Lucene, mais à l’adresse suivante : http://issues.apache.org/jira/browse/LUCENE-400. Inutile de récupérer cet analyzer, j’en fournie les sources modifiés afin de fonctionner avec Lucene 2.3.2

Pour une présentation plus complète de Lucene, voir mon article « Introduction à Lucene« .

Pourquoi filtrer les termes ou expressions (étape 3) ?

Dans l’exemple indiqué ci-dessus, les termes ou expressions obtenues sont : « parcours », « du », « tour », « de », « France », « parcours du », « du tour », « tour de », « de France », « parcours du tour », « du tour de » et « tour de France ». On remarque immédiatement des éléments que l’on ne souhaite pas voir apparaître dans le nuage : « du », « de », « parcours du », « du tour », « tour de », « de France » et « du tour de ». Il s’agit des mots-vides ou expression commençant ou se terminant par un mot-vide. Il reste donc les éléments suivants : « parcours », « France », « parcours du tour » et « tour de France ».

Nous pousserons le nettoyage jusqu’à supprimer les mots simples ou expressions apparaissants déjà dans une expression constituée de plus de mots. En effet, imaginons des données à analyser contenant une ou plusieurs fois les expressions suivantes : « tour de France », « tour d’Italie » et « tour d’Espagne », mais jamais ou peu de fois les mots « tour », « France », « Italie » et « Espagne » hors de ces expressions. Sans ce nettoyage, le nuage de tags contiendrait certainement « tour », « Italie », « France » et « Espagne » (très fréquents) et sans doute mais sans certitude « tour de France », « tour d’Italie » et « tour d’Espagne » (moins fréquents). Le nuage de tags serait alors complètement faux.

Ainsi nettoyé, le nuage devient « parcours du tour » et « tour de France » et est beaucoup plus pertinent que ce que nous avions obtenu avant le filtrage.

L’algorithme de nettoyage utilisant un fichier de règles est adapté de l’algorithme décrit dans l’article « Lucene Tag Cloud Generator » de Richard Friedman.

Le fichier de règles est principalement constituer de la liste des mots vides mais commence par 5 paramètres pouvant être désactivés (en mettant les lignes en commentaires avec un #). Il s’agit de :

• -smallwords : pour retirer les mots de 3 caractères ou moins
• -numbers : pour retirer les nombres
• -dashes : pour retirer les mots contenant un tiret (« – »)
• -period : pour retirer les mots contenant un point
• -include : pour retirer les mots ou expressions incluent dans une autre expression. J’ai mis cette option pour le principe, mais en la désactivant les résultats sont généralement très décevants.

Code source des étapes 1, 2 et 3

Le code source java est disponible ici sous forme d’un projet Eclipse. Il contient les fichiers suivants :

• NGramAnalyzerWrapper.java et NGramFilter.java (analyzer Lucene)
• TagCloud.java (classe principale avec l’algorithme de filtrage)
• input.txt (les données exemples à analyser)
• rules.txt (le fichier de règles)

Pour lancer l’analyse d’un fichier de données, l’usage est le suivant :

Usage: org.apache.demo.TagCloud -input [inputfile] -output [outputfile] -rules [rulesfile] -count [count] -boost [boost] -minfreq [minfreq] -maxterm [maxterm]
 
    input    - input file with data to be clouded
    output   - output file with cloud data
    rules    - rules file
    count    - max number of items within the cloud (default = 1000)
    boost    - boost value for multi-terms tags (default = 1)
    minfreq  - minimum frequence for a ngram (default = 2)
    maxterms - maximum number of terms in expressions in the cloud (default = 3)
 
Example: java org.apache.demo.TagCloud -input /tmp/input.txt –output /tmp/output.txt -rules /tmp/rules.txt -count 100 -boost 1 -minfreq 3 -maxterm 4

Etape 4 : affichage du nuage en PHP

La mise en forme du nuage de tags utilise le fichier généré par le programme précédent. Une classe PHP réalise cette mise en forme (lecture du fichier et génération du code html) et une feuille de style définie les styles d’affichage.

La classe PHP est une adaptation du code proposé dans l’article « Tagcloud Font Distributor« .

Le code source disponible ici est constitué des fichiers suivants :

• cloud_tag.inc.php : la classe de génération du nuage de tags en html
• tagcloud.css : la feuille de styles pour l’affichage de nuage de tags
• cloud_tag_display.php : un script d’exemple utilisant la classe et la feuille de styles.

Résultats

Voici quelques exemples de résultats obtenus à partir du fichier de données exemple et en faisant varier quelques paramètres.

Exemple 1 : paramètres par défaut

Exemple 2 : paramètres par défaut sauf boost = 3

On remarque un plus grand nombre d’expressions de plus de 1 mot

Exemple 3 : paramètres par défaut sauf maxterm = 5 et boost = 5

On remarque des expressions jusqu’à 5 mots et presque plus de mots seuls

Stratégies de mise à jour du nuage de tags

La stratégie de mise à jour du nuage de tags dépend de plusieurs paramètres :

• type de données (presse, forums, …)
• la fréquence de mise à jour des données (chaque seconde, une fois par heure, une fois par jour, …)
• le dynamisme que l’on veut donner au nuage

Par exemple, pour des données peu changeantes et en faible quantité, on peut choisir de créer le nuage sur les données des 30 derniers jours avec régénération du nuage une fois par jour. Par contre, pour des données très changeantes comme un site de presse avec des données nouvelles toutes les secondes, on peut choisir de générer le nuage sur les données de la dernière journée voir des dernières heures avec régénération du nuage chaque heure voir chaque quart d’heure.

Conclusions

Je pense que des règles de filtrage basées sur des expressions régulières pourraient être ajoutées. Par exemple, une simple règle indiquant de ne pas accepter les mots avec des points ou des tirets remplacerait les règles « -dashes » et « -period », une autre remplacerait « -number ». On pourrait mettre en place un grand nombre de règles supplémentaires comme par exemple le rejet des dates.

Je suis ouvert à toutes suggestions afin d’améliorer de la solution proposée.

Il s’agit bien d’une librairie avec laquelle il n’est pas fourni d’outils permettant l’indexation de données en quelques clics de souris et quelques paramétrages. Il faut donc en passer par du code Java afin de mettre en place une solution sur mesure de recherche plein-texte.

Principe

Lucene indexe et retrouve des « documents ». Par document, on ne parle pas de fichiers Excel, Word, PDF ou HTML, mais d’une structure de données constituée de champs. Un champ est une donnée possédant un nom (titre, auteur, date de publication, contenu, ..) et à laquelle est associé du texte. C’est ce texte qui est indexé, recherchable et affichable. Les documents indexés sont regroupés au sein d’une collection de documents appelée « index ». Un index peut contenir plusieurs centaines, milliers ou millions de documents et il est possible de créer autant d’index différents que le nécessite votre ou vos applications. Physiquement, un index est un répertoire (que vous spécifiez) hébergeant un nombre variable de fichiers (ça c’est l’affaire de Lucene).

Si le texte qui est à indexé est contenu dans des fichiers Excel, Word, PDF ou HTML, c’est de votre ressort d’en extraire de contenu textuel qui sera indexé. Il est possible d’utiliser par exemple pdftotext pour les fichiers PDF, Antiword pour les fichiers Microsoft Word ou tout simplement la boite à outils Tika qui permet l’extraction du contenu d’un grand nombre de format de fichiers.

Obtenir et utiliser Lucene

La version actuelle de Lucene est la 2.9 et est disponible ici. La fichier lucene-x.x.x.zip est suffisant, mais le fichier lucene-x.x.x-src.zip avec les sources devient vite intéressant lorsque l’on veut étendre les possibilités de lucene et disposer d’exemples de code.

Dans la suite de cet article nous allons voir un exemple minimaliste illustrant comment indexer et rechercher des données. Cet exemple nous permet d’introduire les concepts de base de Lucene : document, field, analyzer, query, hits, …

La première chose à faire afin de pouvoir développer des classes Java utilisant Lucene, c’est de créer un projet dans votre environnement de développement et d’y inclure la librairie principale de Lucene : lucene-core-x.x.x.jar. J’utilise pour ma part Eclipse. A noter qu’un bug dans Sun Java 1.6 a posé problème avec Lucene (détails ici), ce bug a été corrigé à partir de la version 1.6.0_10-rc-b28.

Un peu de pratique

L’exemple qui suit est constitué d’une unique classe LuceneIntroduction.java dont voici le projet Eclipse complet dans un fichier zip.

Squelette de la classe

Le code suivant constitue le squelette de la classe. Il déclare les packages nécessaires et la méthode main qui exécute successivement une méthode pour l’indexation et une méthode pour la recherche.

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.*;
import org.apache.lucene.index.IndexWriter;
 
import org.apache.lucene.search.Query;
import org.apache.lucene.search.Hits;
import org.apache.lucene.search.Hit;
import org.apache.lucene.queryParser.QueryParser;
import org.apache.lucene.search.IndexSearcher;
 
import java.io.File;
import java.util.*;
 
public class LuceneIntroduction {
  static final String INDEX_DIR = "c:\\temp\\index_test";
  public static void main(String[] args) {
    if (!index())
      System.exit(1);
    if (!searchAndDisplay("titi"))
      System.exit(1);
    if (!searchAndDisplay("bla"))
      System.exit(1);
  }
  // ...
}

Indexer des données

L’indexation de données met en oeuvre 4 classes Lucene.

Le code suivant créer un index et ajoute 3 documents dans cet index. La méthode createDocument est plus particulièrement dédiée à la création d’un objet Document Lucene constitué de 3 champs : id, titre et texte.

public static boolean index () {
 
  File dir = new File (INDEX_DIR);
 
  if (dir.exists()) {
    System.out.println("Impossible de créer l'index dans le répertoire '"
                       + INDEX_DIR
                       + "', veuillez le supprimer d'abord.");
    return false;
  }	
 
  try {
    // Création de l'index
    IndexWriter writer = new IndexWriter(INDEX_DIR,
                                         new StandardAnalyzer(),
                                         true);
 
    // Création et indexation d'un premier document
    Document doc = createDocument ("1", "Titre 1", "bla bla");
    writer.addDocument(doc);
 
    // Création et indexation d'un second document
    doc = createDocument ("2", "Titre 2", "titi tutu");
    writer.addDocument(doc);
 
    // Création et indexation d'un troisième document
    doc = createDocument ("3", "Titre 3", "bla bla titi tutu");
    writer.addDocument(doc);
 
    // Fermeture de l'index
    writer.close();
 
  } catch (Exception e) {
    e.printStackTrace();
    return false;
  }	    
 
  return true;
}
 
private static Document createDocument (String id, String titre,
                                        String texte) {
 
  // Créer un document vide
  Document doc = new Document();
 
  // Créer le champ id
  doc.add(new Field ("id", id,
                     Field.Store.YES, Field.Index.UN_TOKENIZED));
 
  // Créer le champ titre
  doc.add(new Field ("titre", titre,
                     Field.Store.YES, Field.Index.TOKENIZED));
 
  // Créer le champ texte
  doc.add(new Field ("texte", texte,
                     Field.Store.NO, Field.Index.TOKENIZED));
 
  return doc;
}

On remarque que l’analyzer utilisé est spécifié au constructeur de l’objet IndexWriter. Et qu’un ensemble d’attributs importants sont spécifiés au constructeur de l’objet Field.

Le premier attribut est le mode de stockage de la donnée associée au champ : Field.Store.YES (stocké) ou Field.Store.NO (non stocké). Pour être indexé, une donnée ne doit pas forcément être stockée. On stockera un titre et un auteur par exemple car il doivent pouvoir être récupérés afin d’être affichés dans une liste de résultats. La totalité du texte d’un document PDF de 100 pages ne sera pas stocké mais juste indexé.

Le second attribut est le mode d’indexation de la donnée associée au champ : Field.Index.NO (non indexé), Field.Index.TOKENIZED (indexé avec découpage en mots), Field.Index.UN_TOKENIZED (indexé sans découpage en mots).

Rechercher

La recherche met en oeuvre 6 classes Lucene.

Le code suivant recherche les documents correspondant au critère et les affiche.

public static boolean searchAndDisplay (String criteria) {
 
  try {
    IndexSearcher searcher = new IndexSearcher(INDEX_DIR);
    QueryParser parser = new QueryParser("texte", new StandardAnalyzer());
    Query query = parser.parse(criteria);
    Hits hits = searcher.search(query);
 
    System.out.println("Résultats pour '" + criteria + "': " + hits.length());
    Iterator iter = hits.iterator();
    while(iter.hasNext()) {
      Hit hit = iter.next();
      Document doc = hit.getDocument();
      System.out.println(doc.get("titre"));
    }
  }
  catch (Exception e) {
    e.printStackTrace();
    return false;
  }	    	    
 
return true;
}

Résultat de l’exécution

Résultats pour 'titi': 2
Titre 2
Titre 3
Résultats pour 'bla': 2
Titre 1
Titre 3

Et si mes applications ne sont pas écrites en Java ?

Si vous acceptez de ne pas utiliser la toute dernière version de Lucene, vous pouvez utiliser une version portée dans votre langage de programmation préféré. Il existe de nombreux portages : Perl, Python, Ruby, C, C++, .NET, Common Lisp et PHP (recherche uniquement).

Si comme moi vous préférez utiliser la version originale Java en permanente évolution grâce à sa grande communauté de développeurs, voici ma suggestion : les Services Web.

Vous avez écrit une application Web dont l’interface est en PHP et les données sont dans une base SQL. Vous n’avez pas le choix, il faut développer votre moteur de recherche avec Java. Par contre, il faut également interfacer ce moteur de recherche avec votre application PHP pour lancer les recherches et afficher les résultats.

Pour la partie indexation des données il n’est pas nécessaire de s’interfacer avec le PHP, une application Java autonome peut être développée. Par contre, pour la recherche il faut interfacer le code PHP avec le code Java. La solution consiste en la mise en place de Services Web écrits en Java et fonctionnants sous Tomcat. Il n’est pas nécessaire de se lancer dans des Services Web au standard SOAP, le standard REST est largement suffisant. En gros une requête HTTP est envoyée à une servlet qui elle même retourne des résultats au format XML. Cette méthode permet d’interfacer la recherche Java/Lucene à tous types d’applications (WEB ou non WEB) et écrites dans n’ importe quel langage.

Extensions de Lucene

L’exemple présenté est comme je l’ai déjà dit « minimaliste ». Les possibilités offertes par Lucene sont très larges et se rapprochent des moteurs de recherche les plus puissants. En effet, il existe de nombreuses extensions fournies dans la distribution : analyzers avancées, corrections orthographiques, mise en évidence des termes recherchés dans les résultats, …

En voici la présentation dans la Sandbox Lucene

Utilitaires

Voici deux utilitaires intéressants en phase de développement.

Luke – outils de monitoring et de consultation des index

Limo – outils de monitoring des index

Documentation

La documentation est disponible ici. En plus de la javadoc, on y trouve une FAQ, un Wiki et différents articles intéressants.

jGuru fournit une FAQ Lucene intéressante.

Et enfin, il existe un livre en anglais basé sur une déjà ancienne version 1.4 : Lucene in Action (2004). La second édition du livre doit être disponible prochainement.

Support et assistance

Lucene est un projet open source, il n’existe pas de support à proprement parlé, mais il existe une mailing-list et un forum très actifs qui permettent d’obtenir de l’aide et des suggestions pour les problèmes les plus pointus.

Projets utilisant Lucene

Solr

eXtensible Text Framework (XTF)

Hibernate Search

June 16, 2009

In Washington, DC, yesterday (June 15, 2009), I learned that In-Q-Tel, the investment arm of the US intelligence community, has given a salute to open source. Lucid Imagination, a commercial open source company dedicated to supporting Apache Lucene and SOLR search technologies, received a strategic investment from In-Q-Tel.

Article d’origine