diff --git a/liaSoap.py b/liaSoap.py index 942c785..aa02eb6 100644 --- a/liaSoap.py +++ b/liaSoap.py @@ -8,25 +8,24 @@ from spyne.protocol.soap import Soap11 from spyne.server.wsgi import WsgiApplication from processor.Orkis import Orkis -class HelloWorldService(ServiceBase): +class getPhonService(ServiceBase): @srpc(Unicode, _returns=Unicode) - def say_hello(name): - orkis=Orkis(name) + def get_phon(string): + orkis=Orkis(string) orkis.getDico() return str(orkis) -application = Application([HelloWorldService], - tns='spyne.examples.hello', +application = Application([getPhonService], + tns='lia.tools.phon', in_protocol=Soap11(), out_protocol=Soap11() ) - +wsgi_app = WsgiApplication(application) if __name__ == '__main__': # You can use any Wsgi server. Here, we chose # Python's built-in wsgi server but you're not # supposed to use it in production. from wsgiref.simple_server import make_server - wsgi_app = WsgiApplication(application) server = make_server('0.0.0.0', 8000, wsgi_app) server.serve_forever() diff --git a/test/functional/data.txt b/test/functional/data.txt new file mode 100644 index 0000000..c14eafa --- /dev/null +++ b/test/functional/data.txt @@ -0,0 +1,115 @@ +Nous proposons dans cet article une méthode non supervisée pour l’identification et +la modélisation de concepts associés à une recherche d’information. Nous utilisons l’alloca- +tion de Dirichlet latente (LDA), un modèle génératif probabiliste, pour détecter les concepts +implicites de la requête en utilisant les documents obtenus par un processus de retour de perti- +nence simulé (ou documents de +feedback +). Notre approche estime automatiquement le nombre +de concepts ainsi que le nombre de documents de +feedback +sans aucun apprentissage préalable +ni paramétrage. Les concepts implicites sont pondérés afin de refléter leur importance relative +par rapport à la requête et sont utilisés pour modifier l’ordre des documents renvoyés à l’utili- +sateur. Nous utilisons quatre sources d’information générales de natures différentes (web, jour- +nalistique, encyclopédique) à partir desquelles les documents de +feedback +sont extraits. Nous +comparons différentes approches état-de-l’art sur deux collections +ad-hoc +de TREC, et les ré- +sultats montrent que l’utilisation de concepts implicites identifiés par notre méthode améliore +significativement les performances de recherche documentaire. +ABSTRACT. +In this paper we introduce an unsupervised method for mining and modeling la- +tent search concepts. We use Latent Dirichlet Allocation (LDA), a generative probabilistic +topic model, to exhibit highly-specific query-related topics from pseudo-relevant feedback doc- +uments. Our approach automatically estimates the number of latent concepts as well as the +needed amount of feedback documents, without any prior training step. Latent concepts are +then weighted to reflect their relative adequacy and are further used to automatically reformu- +late the initial user query. We also explore the use of different types of sources of information for +modeling the latent concepts. For this purpose, we use four general sources of information of +various nature (web, news, encyclopedic) from which the feedback documents are extracted. We +evaluate our approach over two large ad-hoc TREC collections, and results show that it signif- +icantly improves document retrieval effectiveness while best results are achieved by combining +latent concepts modeled from all available sources. +Le but de la Recherche d’Information (RI) est de satisfaire le besoin d’information +d’un utilisateur, généralement en proposant des documents ou des passages provenant +d’une collection cible. Ce besoin est habituellement représenté par une requête com- +posée de quelques mots-clés, qui est soumise au système de recherche d’information. +Le système cherche alors les documents qui contiennent les mots-clés, afin de fournir +à l’utilisateur une liste de documents ordonnée en fonction de leur pertinence esti- +mée par rapport à la requête. Seulement, un besoin d’information complet peut être +trop complexe pour être exprimé en quelques mots, ou l’utilisateur peut ne pas avoir +le vocabulaire ou les compétences nécessaires pour formuler efficacement la requête. +Ingwersen (1994) dit en effet que la formulation d’une requête par un utilisateur est la +représentation de son état cognitif actuel concernant un besoin d’information. Une re- +quête peut ne pas être correctement formulée si l’utilisateur cherche des informations +sur une thématique pour laquelle il n’a pas de connaissances. Ainsi, sans contexte ad- +ditionnel, le système de recherche d’information peut manquer des nuances ou des +détails que l’utilisateur n’a pas fourni dans la requête. Ce contexte peut prendre la +forme d’un modèle des intérêts de l’utilisateur basé sur son historique personnel (ou +ses interactions sociales), ou peut être composé d’éléments extraits de documents si- +milaires représentant les thèmes de la recherche (Finkelstein +Ce deuxième type de contexte est plus généralement connu sous le nom de « re- +cherche d’information conceptuelle » et a reçu beaucoup d’attention au cours de ces +dernières années L’idée générale est d’étendre les requêtes avec des +ensembles de mots ou de multi-mots extraits de documents de +feedback. L’ensemble de feedback est composé de documents qui sont pertinents ou pseudo-pertinents par +rapport à la requête initiale, et qui sont à même de contenir des informations impor- +tantes sur le contexte de la recherche. Les mots exprimant le plus d’information par +rapport à la requête sont traités comme des concepts implicites. Ils sont alors utilisés +pour reformuler la requête. Le problème avec cette approche est que chaque mot re- +présente un concept spécifique. Seulement un concept représente une notion et peut +être vu comme un ensemble de connaissances. Stock (2010) donne une définition qui +suit cette direction en affirmant qu’un concept est défini comme une classe contenant +des objets possédant certaines propriétés et attributs. +L’objectif du travail présenté dans cet article est de représenter avec précision les +concepts sous-jacents associés à une requête, améliorant indirectement les informa- +tions contextuelles liées à la recherche documentaire. Nous introduisons ainsi une +méthode entièrement non supervisée qui permet de détecter les concepts implicites +liés à une requête donnée et d’améliorer les performances d’un système de recherche +documentaire en incorporant ces concepts à la requête initiale. Pour chaque requête, +les concepts implicites sont extraits d’un ensemble réduit de documents de +initialement récupérés par le système. Ces documents de +ous estimons la similarité entre deux modèles conceptuels en calculant les simi- +larités entre toutes les paires de concepts des deux modèles. Seulement, deux modèles +différents sont générés à partir de documents différents, ils ne partagent donc pas le +même espace probabiliste. Les distributions de probabilités ne sont donc pas compa- +rables, le calcul de similarité ne peut se faire qu’en prenant en compte les mots des +concepts. Les concepts sont donc ramenés à de simples sacs de mots, et nous utilisons +une mesure de similarité basée sur la fréquence inverse des mots dans les documents +de la collection. +La figure 1 présente des histogrammes traçant le nombre de requêtes en fonction +du nombre de concepts implicites estimé et du nombre de documents de +feedback +,et +ce pour les deux collections. On voit que le comportement est relativement identique +sur les deux collections. Entre deux et trois concepts sont identifiés pour la grande +majorité des requêtes. De même ces concepts sont généralement identifiés au sein d’un +nombre assez réduit de documents, entre deux et quatre pour les deux collections. +Il est toutefois intéressant de noter la différence entre le nombre de documents de utilisés par les ressources Web et Wikipédia. On peut voir en effet que 2 +ou 3 articles Wikipédia suffisent pour un très grand nombre de requêtes, alors qu’un +plus grand nombre est nécessaire pour la ressource Web. Ce comportement est très +cohérent avec la nature même de Wikipédia, où les articles sont rédigés dans le but +d’être très précis et de ne pas trop s’éparpiller. Il est d’ailleurs fréquent qu’un article +devenu trop conséquent soit coupé en plusieurs autres articles traitant chacun un sujet +très spécifique. +Des idées empruntées à la physique ont déjà été utilisées dan +s l’analyse de textes. Les exemples +plus notables sont l’approche entropique de (Shannon, 1948 +), les travaux de (Zipf, 1935; Zipf, +1949) et de (Mandelbrot, 1953) où les auteurs font des consid +érations thermodynamiques d’éner- +gie et de température dans leurs études sur la Statistique Te +xtuelle. Dernièrement se sont servi des notions de polarisation des système +orientations sémantiques des mots (désirable ou indésirable) à partir de mots amorce. La sortie +de ce système est une liste de mots indiquant leurs orientati +ons estimés selon l’approximation +du champ moyen. Dans notre travail, nous avons utilisé diffé +remment la notion de spin des mots dans les documents. À +partir de cet image, on aperçoit le document comme un matéria +ux composé d’un ensemble de +unités en interaction dont l’énergie peut être calculée. No +us avons étudié les problèmes du Trai- +tement Automatique de la Langue Naturelle (TALN) en utilisa +nt la notion d’énergie textuelle. diff --git a/test/functional/testLiaSoap.py b/test/functional/testLiaSoap.py new file mode 100644 index 0000000..60354ec --- /dev/null +++ b/test/functional/testLiaSoap.py @@ -0,0 +1,51 @@ +from suds.client import Client +import time +import threading + + ### TODO : Tester en parallele x4 un million de fois pour voir ### +url = 'http://lrc2-kija.univ-avignon.fr:8000/?wsdl' +client = Client(url) +filename = "data.txt" +file = open(filename, "r") +nb_times=4 +# Exp 1 +debut =time.time() +contents = file.read().decode("utf8").encode("ascii", errors='ignore').rstrip() +client.service.get_phon(contents) +duree= time.time()- debut +print (" Exper 1 : " + str(duree)) +# Exp 2 +debut =time.time() +file.seek(0) +lines = file.readlines() +for line in lines: + line = line.decode("utf8").encode("ascii", errors='ignore').rstrip() + if line is not None: + try: + client.service.get_phon(line) + except: + continue +duree= time.time()- debut +print (" Exper 2 line by line 1 corpus : " + str(duree)) +##Exp 3 +debut = time.time() +file.seek(0) +contents = file.read().decode("utf8").encode("ascii", errors='ignore').rstrip() +tabs=[] +i=0 +while i <= nb_times : + tabs.append(contents) + i+=1 +client.service.get_phon("".join(tabs)) +duree= time.time()- debut +print ("Exper 3 2pow4 time the content in once shot " + str(duree)) +# EXP 4 +#debut = time.time() +#contents = file.read().decode("utf8").encode("ascii", errors='ignore').rstrip() +#def envoie(datas): +# client.service.get_phon(datas) +#i =0 +#threadTab= [] +#while i <= nb_times: +# threadTab.append(threading.Thread(None, envoie, None,contents,None)) +#duree = time.time() - debut diff --git a/webtagger.py b/webtagger.py deleted file mode 100644 index 0bb4b52..0000000 --- a/webtagger.py +++ /dev/null @@ -1,37 +0,0 @@ -# -*- coding: utf-8 -*- -import subprocess -import os -import json -from lxml import etree -from flask import Flask, request, render_template -from processor.LiaTools import * -from processor.Orkis import Orkis -from flaskext.enterprise import Enterprise -from time import ctime -app = Flask(__name__) -enterprise = Enterprise(app) - -@app.route("/") -def docs(): - return render_template('index.html') - -@app.route("/tagger",methods=['POST']) -def cleaner(): - # Receive String from post parametre Raw text - dirtyString= request.values[u'string'] - # Charging Processor et check if they are okay ( aim is to dynamic charge later ) - orkisProc = Orkis(dirtyString) - # Processing - # Adding lemm of each words cause we went ther phonem too - taggedTable= orkisProc.getDico() - # Returning a row text to be parse client side - return unicode(taggedTable) - -class OrkisService(enterprise.SOAPService): - @enterprise.soap(returns=enterprise._sp.String) - def get_phon(self): - return ctime() - -if __name__ == '__main__': - app.debug = True - app.run(host='0.0.0.0')