Dans le cadre d'enseignements en DUT Informatique à Nantes, je propose le projet suivant à un groupe d'étudiants de 2ème année. Ce projet démarre en Novembre 2009 et se terminera en Avril-Mai 2010.

Titre: Fouille d'opinions sur Twitter et représentation graphique de l'évolution temporelle des opinions

Sujet: Le Web 2.0 en tant qu'espace d'expression libre a littéralement dopé l'intérêt pour la fouille d'opinions automatique. A travers les blogs et les différents sites de réseaux sociaux (Twitter, Facebook, etc.), les internautes partagent leurs centres d'intérêts, affirment leur personnalité, voire cherchent à médiatiser leurs opinions pour influer sur leurs communautés. La richesse informationnelle contenue sur ces différents supports, la volonté de mesurer, voire de prédire, l'évolution de l'opinion générale a fait naître des besoins applicatifs nouveaux. Les industriels ayant un fort besoin relationnel avec leurs clients (SNCF, EDF), les nouvelles technologies sensibles aux modes (téléphones portables, ordinateurs), la politique, les médias ou les sociologues sont les principaux utilisateurs finaux de ces systèmes.

Apopsis est un outil, développé au sein de la plateforme UIMA/Ecplise, permettant de détecter au sein d'un texte les différents passages exprimant une opinion, de catégoriser leur polarité axiologique (positive ou négative), leur rôle discursif (appréciation, jugement, accord, désaccord, etc.), la stratégie énonciative du locuteur (assume t-il sa subjectivité ou cherche t-il à la dissimuler ?) et enfin de rechercher les sujets ciblés par les opinions exprimées. Il a notamment été utilisé dans plusieurs scénarios de tests applicatifs à échelle réelle pour mesurer, par exemple, l'évolution de l'opinion des internautes à propos de Raymond Domenech entre juillet 2008 et juillet 2009.

Le projet consiste, au sein de la plate-forme UIMA et de l'outil Apopsis, a développer plusieurs composants additionnels pour permettre la fouille d'opinions sur le réseau social Twitter (http://www.twitter.com). L'API (http://apiwiki.twitter.com/) de Twitter permet notamment de collecter librement et automatiquement les messages postés par ses utilisateurs. Parmis les tâches suggérées et non-limitées, le projet consistera selon l'aspiration du groupe à :

• Constituer automatiquement un corpus en collectant les données textuelles à partir de Twitter (réalisation d'un CollectionReader avec UIMA),
• Utiliser et apporter des améliorations à Apopsis pour l'annotation des opinions sur ce type de données (gestion du langage sms, correction orthographique, gestion des smileys et d'expressions d'opinions typiques de Twitter, etc),
• Visualisation automatique des annotations d'opinions permettant de visualiser graphiquement l'évolution de l'opinion des internautes sur un sujet donné,
• Déploiement sous forme de service web.

Outils: Eclipse, UIMA, Langage JAVA, XML

Cet article présente un exemple simple d'utilisation de l'API de Yahoo!Search BOSS dans une chaîne de traitements UIMA. Par ailleurs, les sources du composant fr.univ.nantes.lina.uima.YahooSearch reprenant une partie du tutoriel présenté ci-dessous sont disponibles ici : http://uima-fr.org/download/uima-YahooSearch-v1.jar .

Yahoo!Search BOSS (Build your Own Search Service) est un service permettant de construire et d'exécuter des requêtes vers le moteur de recherche Yahoo!. L'utilisation de ce service est gratuite et illimitée après l'obtention d'une clé d'identification. L'API (Java) de Yahoo!Search BOSS permet, en réponse à une requête, d'obtenir un flux de réponses en XML (voir exemple). Le parsing de ce flux de texte format XML permet notamment de récupérer les champs d'informations suivants :

• nombre de résultats d'une requête
• URL des sites proposés
• Résumés des sites proposés
• etc.

Un certain nombre de paramètres supplémentaires (proposition de variations orthographiques, filtre sur une langue particulière, filtre sur des noms de domaines particuliers, etc) font de ce service un outil intéressant pour des tâches de traitement automatique des langues.

Nous décrivons ci-dessous un exemple de scénario très simple pour intégrer ce service dans un composant d'analyse UIMA.

Scénario exemple

Nous disposons d'un composant UIMA capable de reconnaître les entités nommées dans les documents textuels, et en particulier des noms de personnes. Le Type Personne est associé à cette information. Dans les exemples ci-dessous "Jacques Chirac" et "Barack Obama" sont annotés et sont une information de type Personne.

Jacques Chirac explique qu'il n'est devenu gaulliste qu'en 1958 Le président américain Barack Obama a lancé mardi un appel à une action mondiale

Dans notre scénario, nous souhaitons estimer la "popularité" de ces personnes en comptabilisant le nombre de documents du web indexé qui parlent de ces personnes. L'attribut popularité est ajouté au type Personne denotre type system

__''Composant d'annotation utilisant Yahoo!Search : PopularityAnnotation ''__

Le fonctionnement de ce composant se scinde en quatres étapes principales :

• 1- La récupération de l'index des annotations Personne contenues dans le document analysé
• 2- La création/envoie de la requête à Yahoo!Search BOSS
• 3- L'analyse des résultats XML retournés par le service
• 4- La modification de l'annotation Personne courante

1- Récupérer l'index des annotations Personne

ré-écriture de la méthode process de la classe PopularityAnnotation :

public void process(JCas jcas) throws AnalysisEngineProcessException {
  //récupération des annotations de type Personne
  AnnotationIndex idxPersonne=(AnnotationIndex) jcas.getAnnotationIndex(Personne.type);
  while (idxPersonne.hasNext()){
    Personne p = (Personne) idxPersonne.next();
    ...
  }
}

2- Création/Envoie de la requête à Yahoo!Search BOSS

Pour chaque annotation Personne, c'est le texte couvert par l'annotation qui nous intéresse et que l'on souhaite rechercher sur Yahoo!Search

while (idxPersonne.hasNext()){
  Personne p = (Personne) idxPersonne.next();
  String nomPersonne=p.getCoveredText();
  //Certains caractères spéciaux nécessitent d'être encodés pour respecter le protocole HTTP
  nomPersonne=URLEncoder.encode(nomPersonne, "UTF-8");

  // la variable bossID (String) est votre clé d'identification
  String maRequete = "http://boss.yahooapis.com/ysearch/web/v1/"+nomPersonne+"?appid="+bossID+"&format=xml";
  
  // envoie de la requête
  HttpClient  client = new HttpClient();
  GetMethod method = new GetMethod(maRequete);
  nt statusCode = client.executeMethod(method);
  if (statusCode != HttpStatus.SC_OK) {
    System.err.println("Method failed: " + method.getStatusLine());
  }

InputStream rstream = null;

// Réception de la réponse
rstream = method.getResponseBodyAsStream();
Document response = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(rstream);
...
}

NB : Quelques imports sont nécessaire dans l'entête de la classe PopularityAnnotation pour envoyer des requêtes et parser le document XML réceptionné :

import java.io.InputStream;
import java.net.URLEncoder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathFactory;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpStatus;
import org.apache.commons.httpclient.methods.GetMethod;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;

3- Analyse des résultats XML

Une fois le document XML réponse donné par Yahoo, il reste à le parser pour accéder aux champs d'informations qui nous intéressent. Ici, seul le nombre de résultats de la requête nous intéresse.

while (idxPersonne.hasNext()){
  ...
  // Réception de la réponse
  rstream = method.getResponseBodyAsStream();
  Document response = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(rstream);

  //Accès au champ de valeur @totalhits avec XPath
  XPathFactory factory = XPathFactory.newInstance();
  XPath xPath=factory.newXPath();
  NodeList nodes = (NodeList)xPath.evaluate("/ysearchresponse/resultset_web", response, XPathConstants.NODESET);
  int nodeCount = nodes.getLength();
  String totalhits="";
  for (int i = 0; i < nodeCount; i++) {
    totalhits = (String)xPath.evaluate("@totalhits", nodes.item(i), XPathConstants.STRING);
  }
}

Le schéma du flux XML est détaillé ici.

4- Modification de l'annotation Personne courante

Le nombre de documents indexés par Yahoo! contenant le nom de la personne courante est stockée dans la variable totalhits, il ne reste plus qu'à modifier l'annotation ...

while (idxPersonne.hasNext()){
  ...
  //modification de l'annotation
  Personne p.setPopularity(totalhits);
}