Commit 44c17c42360e2e98b06235928db740cbdad99242
1 parent
127210d9ee
Exists in
soap
Accents Ok
Showing 5 changed files with 68 additions and 66 deletions Inline Diff
liaSoap.py
| 1 | from spyne.application import Application | 1 | from spyne.application import Application |
| 2 | from spyne.decorator import srpc | 2 | from spyne.decorator import srpc |
| 3 | from spyne.service import ServiceBase | 3 | from spyne.service import ServiceBase |
| 4 | from spyne.model.primitive import Integer | 4 | from spyne.model.primitive import Integer |
| 5 | from spyne.model.primitive import Unicode | 5 | from spyne.model.primitive import Unicode |
| 6 | from spyne.model.complex import Iterable | 6 | from spyne.model.complex import Iterable |
| 7 | from spyne.protocol.soap import Soap11 | 7 | from spyne.protocol.soap import Soap11 |
| 8 | from spyne.protocol.http import HttpRpc | 8 | from spyne.protocol.http import HttpRpc |
| 9 | from spyne.protocol.xml import XmlDocument | 9 | from spyne.protocol.xml import XmlDocument |
| 10 | from spyne.server.wsgi import WsgiApplication | 10 | from spyne.server.wsgi import WsgiApplication |
| 11 | from processor.Orkis import Orkis | 11 | from processor.Orkis import Orkis |
| 12 | import logging | 12 | import logging |
| 13 | logging.basicConfig() | 13 | logging.basicConfig() |
| 14 | class getPhonService(ServiceBase): | 14 | class getPhonService(ServiceBase): |
| 15 | @srpc(Unicode, _returns=Unicode) | 15 | @srpc(Unicode, _returns=Unicode) |
| 16 | def get_phon(string): | 16 | def get_phon(string): |
| 17 | orkis=Orkis(string) | 17 | orkis=Orkis(string) |
| 18 | orkis.getDico() | 18 | orkis.getDico() |
| 19 | print(unicode(orkis)) | 19 | #print(unicode(orkis)) |
| 20 | return unicode(orkis) | 20 | return unicode(orkis) |
| 21 | 21 | ||
| 22 | application = Application([getPhonService], | 22 | application = Application([getPhonService], |
| 23 | tns='lia.tools.phon', | 23 | tns='lia.tools.phon', |
| 24 | in_protocol=Soap11(), | 24 | in_protocol=Soap11(encoding='UTF-8'), |
| 25 | out_protocol=Soap11() | 25 | out_protocol=Soap11(encoding='UTF-8') |
| 26 | ) | 26 | ) |
| 27 | wsgi_app = WsgiApplication(application) | 27 | wsgi_app = WsgiApplication(application) |
| 28 | if __name__ == '__main__': | 28 | if __name__ == '__main__': |
| 29 | # You can use any Wsgi server. Here, we chose | 29 | # You can use any Wsgi server. Here, we chose |
| 30 | # Python's built-in wsgi server but you're not | 30 | # Python's built-in wsgi server but you're not |
| 31 | # supposed to use it in production. | 31 | # supposed to use it in production. |
| 32 | from wsgiref.simple_server import make_server | 32 | from wsgiref.simple_server import make_server |
| 33 | 33 | ||
| 34 | server = make_server('127.0.0.1', 9000, wsgi_app) | 34 | server = make_server('127.0.0.1', 9000, wsgi_app) |
| 35 | server.serve_forever() | 35 | server.serve_forever() |
| 36 | 36 |
processor/LiaTools.py
| 1 | import subprocess | 1 | import subprocess |
| 2 | import os | 2 | import os |
| 3 | from BaseProcessor import baseProcessor | 3 | from BaseProcessor import baseProcessor |
| 4 | import nltk | 4 | import nltk |
| 5 | import re | 5 | import re |
| 6 | 6 | ||
| 7 | class Tagger(baseProcessor): | 7 | class Tagger(baseProcessor): |
| 8 | """ a calling to lia_tagg class""" | 8 | """ a calling to lia_tagg class""" |
| 9 | def clean(self,dirtyString): | 9 | def clean(self,dirtyString): |
| 10 | """ Clean string for using it into lia_tagg | 10 | """ Clean string for using it into lia_tagg |
| 11 | 11 | ||
| 12 | Change text to iso and clean it one word by line and separate sentences with <s> </s>""" | 12 | Change text to iso and clean it one word by line and separate sentences with <s> </s>""" |
| 13 | p=subprocess.Popen([os.environ["LIA_TAGG"]+'/script/lia_clean'],stdin=subprocess.PIPE,stdout=subprocess.PIPE) | 13 | p=subprocess.Popen([os.environ["LIA_TAGG"]+'/script/lia_clean'],stdin=subprocess.PIPE,stdout=subprocess.PIPE) |
| 14 | (cleanString, err) = p.communicate(input=dirtyString.encode('iso8859-1','backslashreplace')) | 14 | (cleanString, err) = p.communicate(input=dirtyString.encode('iso8859-1')) |
| 15 | return cleanString | 15 | return cleanString.decode("iso8859-1").encode("utf8") |
| 16 | 16 | ||
| 17 | def tagg(self,cleanString): | 17 | def tagg(self,cleanString): |
| 18 | """POS Tagg and lemm a string which come from clean""" | 18 | """POS Tagg and lemm a string which come from clean""" |
| 19 | p2=subprocess.Popen([os.environ["LIA_TAGG"]+'/script/lia_tagg+lemm','-guess'],stdin=subprocess.PIPE,stdout=subprocess.PIPE) | 19 | p2=subprocess.Popen([os.environ["LIA_TAGG"]+'/script/lia_tagg+lemm','-guess'],stdin=subprocess.PIPE,stdout=subprocess.PIPE) |
| 20 | (taggedString,err) =p2.communicate(input=cleanString) | 20 | (taggedString,err) =p2.communicate(input=cleanString.decode("utf8").encode('iso8859-1')) |
| 21 | # This is used beceause lia_tagg deal with iso8859 only | 21 | # This is used beceause lia_tagg deal with iso8859 only |
| 22 | return taggedString.decode('iso8859').encode("utf8") | 22 | return taggedString.decode('iso8859-1').encode("utf8") |
| 23 | 23 | ||
| 24 | def lemm(self,cleanString): | 24 | def lemm(self,cleanString): |
| 25 | """ use the pos tagger to lemm word and return lemm only""" | 25 | """ use the pos tagger to lemm word and return lemm only""" |
| 26 | taggedString = self.tagg(cleanString) | 26 | taggedString = self.tagg(cleanString) |
| 27 | # sub the string to get only lemm ( cut markup and origin word ) Can be Delete with better use of lia_tagg | 27 | # sub the string to get only lemm ( cut markup and origin word ) Can be Delete with better use of lia_tagg |
| 28 | sub = re.sub(r' </s>','',re.sub(r'<s> ',''," ".join([ x.rstrip().split().pop(2) for x in taggedString.rstrip().split("\n") if x]))) | 28 | sub = re.sub(r' </s>',u'', re.sub(r'<s> ','',u" ".join([ x.rstrip().split().pop(2) for x in taggedString.rstrip().split(u"\n") if x]))) |
| 29 | return sub | 29 | return sub |
| 30 | |||
| 30 | def isReady(self): | 31 | def isReady(self): |
| 31 | """ Check if the Tagger can be used ( depends on LIA_TAGG )""" | 32 | """ Check if the Tagger can be used ( depends on LIA_TAGG )""" |
| 32 | os.environ["LIA_TAGG"] | 33 | os.environ["LIA_TAGG"] |
| 33 | return True | 34 | return True |
| 34 | 35 | ||
| 35 | class Phoner(baseProcessor): | 36 | class Phoner(baseProcessor): |
| 36 | """ a class which call the lia phoner """ | 37 | """ a class which call the lia phoner """ |
| 37 | def clean(self,dirtyString): | 38 | def clean(self,dirtyString): |
| 38 | p=subprocess.Popen([os.environ["LIA_PHON_REP"]+'/script/lia_nett'],stdin=subprocess.PIPE,stdout=subprocess.PIPE) | 39 | p=subprocess.Popen([os.environ["LIA_PHON_REP"]+'/script/lia_nett'],stdin=subprocess.PIPE,stdout=subprocess.PIPE) |
| 39 | (cleanString, err) = p.communicate(input=dirtyString.encode('iso8859-1','backslashreplace')) | 40 | (cleanString, err) = p.communicate(input=dirtyString.decode("utf8").encode('iso8859-1')) |
| 40 | return cleanString | 41 | return cleanString.decode("iso8859-1").encode("utf8") |
| 41 | def phon(self,cleanString): | 42 | def phon(self,cleanString): |
| 42 | p2=subprocess.Popen([os.environ["LIA_PHON_REP"]+'/script/lia_lex2phon'],stdin=subprocess.PIPE,stdout=subprocess.PIPE) | 43 | p2=subprocess.Popen([os.environ["LIA_PHON_REP"]+'/script/lia_lex2phon'],stdin=subprocess.PIPE,stdout=subprocess.PIPE) |
| 43 | (taggedString,err) =p2.communicate(input=cleanString) | 44 | (taggedString,err) =p2.communicate(input=cleanString) |
| 44 | # This is used beceause lia_phon deal with iso8859 only | 45 | # This is used beceause lia_phon deal with iso8859 only |
| 45 | # We reconverte the output to utf8 back | 46 | # We reconverte the output to utf8 back |
| 46 | return taggedString.decode('iso8859').encode("utf8") | 47 | return taggedString.decode('iso8859-1').encode("utf8") |
| 47 | def isReady(self): | 48 | def isReady(self): |
| 48 | os.environ["LIA_PHON_REP"] | 49 | os.environ["LIA_PHON_REP"] |
| 49 | return True | 50 | return True |
| 50 | 51 | ||
| 51 | class StopWord(baseProcessor): | 52 | class StopWord(baseProcessor): |
| 52 | def isReady(self): | 53 | def isReady(self): |
| 53 | return True | 54 | return True |
| 54 | def RemoveStopList(self,rowstring): | 55 | def RemoveStopList(self,rowstring): |
| 55 | """ Remove from set of word (splited String ) each words in the stoplist and join all of the other in a string """ | 56 | """ Remove from set of word (splited String ) each words in the stoplist and join all of the other in a string """ |
| 56 | return u" ".join(unicode(value) for value in list(set(rowstring.split()) - set(nltk.corpus.stopwords.words("french")))) | 57 | return u" ".join(unicode(value) for value in list(set(rowstring.split()) - set(nltk.corpus.stopwords.words("french")))) |
| 57 | 58 |
processor/Orkis.py
| 1 | # -*- coding: utf-8 -*- | 1 | # -*- coding: utf-8 -*- |
| 2 | from BaseProcessor import baseProcessor | 2 | from BaseProcessor import baseProcessor |
| 3 | import nltk | 3 | import nltk |
| 4 | import re | 4 | import re |
| 5 | from LiaTools import * | 5 | from LiaTools import * |
| 6 | class Orkis(baseProcessor): | 6 | class Orkis(baseProcessor): |
| 7 | """ Processor for Orkis """ | 7 | """ Processor for Orkis """ |
| 8 | def __init__(self,dirtyString): | 8 | def __init__(self,dirtyString): |
| 9 | self.lem=u"" | 9 | self.lem=u"" |
| 10 | self.tagger=Tagger() | 10 | self.tagger=Tagger() |
| 11 | self.dico ={} | 11 | self.dico ={} |
| 12 | self.string=dirtyString | 12 | self.string=dirtyString |
| 13 | print(dirtyString) | ||
| 13 | def isReady(self): | 14 | def isReady(self): |
| 14 | self.tagger.isReady() | 15 | self.tagger.isReady() |
| 15 | def __unicode__(self): | 16 | def __unicode__(self): |
| 16 | string = u"" | 17 | string = u"" |
| 17 | for word in self.dico: | 18 | for word in self.dico: |
| 18 | string += ( unicode(word.decode("utf-8")))+unicode (u";") | 19 | string += word+u";" |
| 19 | for lemWord in self.dico[word][0]: | 20 | for lemWord in self.dico[word][0]: |
| 20 | string += (unicode(lemWord.decode("utf-8"))+ unicode(u" ")) | 21 | string += lemWord + u" " |
| 21 | string+=u"\n" | 22 | string+=u"\n" |
| 22 | return string | 23 | return string |
| 23 | def clean(self): | 24 | def clean(self): |
| 24 | stopword=StopWord() | 25 | stopword=StopWord() |
| 25 | self.string=stopword.RemoveStopList(self.string) | 26 | self.string=stopword.RemoveStopList(self.string) |
| 26 | def insertLem(self): | 27 | def insertLem(self): |
| 27 | self.lem=u"" | 28 | self.lem=u"" |
| 28 | self.cleanString=self.tagger.clean(self.string).rstrip() | 29 | self.cleanString=self.tagger.clean(self.string).rstrip() |
| 29 | taggedString=self.tagger.tagg(self.cleanString).rstrip() | 30 | taggedString=self.tagger.tagg(self.cleanString).rstrip().decode("utf8") |
| 30 | self.tableLem = taggedString.rstrip().split("\n") | 31 | self.tableLem = taggedString.split(u"\n") |
| 31 | for line in taggedString.rstrip().split("\n"): | 32 | for line in taggedString.rstrip().split(u"\n"): |
| 32 | table = line.rstrip().split(" ") | 33 | table = line.rstrip().split(u" ") |
| 33 | print("table2" + table[2]) | 34 | #print(u"table2" + table[2]) |
| 34 | if not table[2].isspace(): | 35 | if not table[2].isspace(): |
| 35 | if not table[0] in self.dico : | 36 | if not table[0] in self.dico : |
| 36 | self.dico[table[0]]=[set(),set()] | 37 | self.dico[table[0]]=[set(),set()] |
| 37 | self.dico[table[0]][0].add(table[2]) | 38 | self.dico[table[0]][0].add(table[2]) |
| 38 | self.lem = self.lem +"\n"+ table[2] | 39 | self.lem = self.lem +u"\n"+ table[2] |
| 39 | def getDico(self): | 40 | def getDico(self): |
| 40 | self.clean() | 41 | self.clean() |
| 41 | self.insertLem() | 42 | self.insertLem() |
| 42 | self.table=[] | 43 | self.table=[] |
| 43 | for i,v in self.dico.iteritems(): | 44 | for i,v in self.dico.iteritems(): |
| 44 | if not re.match(r".s>",i): | 45 | if not re.match(r".s>",i): |
| 45 | list=[] | 46 | list=[] |
| 46 | list.append(i) | 47 | list.append(i) |
| 47 | for indice in v[0]: | 48 | for indice in v[0]: |
| 48 | list.append(indice) | 49 | list.append(indice) |
| 49 | ligne= " ".join(list) | 50 | ligne= " ".join(list) |
| 50 | self.table.append(ligne) | 51 | self.table.append(ligne) |
| 51 | return "\n".join(self.table) | 52 | return u"\n".join(self.table) |
| 52 | 53 |
test/functional/data.txt
| 1 | Nous proposons dans cet article une méthode non supervisée pour l’identification et | 1 | Nous proposons dans cet article une méthode non supervisée pour l identification et |
| 2 | la modélisation de concepts associés à une recherche d’information. Nous utilisons l’alloca- | 2 | la modélisation de concepts associés à une recherche d information. Nous utilisons l alloca- |
| 3 | tion de Dirichlet latente (LDA), un modèle génératif probabiliste, pour détecter les concepts | 3 | tion de Dirichlet latente (LDA), un modèle génératif probabiliste, pour détecter les concepts |
| 4 | implicites de la requête en utilisant les documents obtenus par un processus de retour de perti- | 4 | implicites de la requête en utilisant les documents obtenus par un processus de retour de perti- |
| 5 | nence simulé (ou documents de | 5 | nence simulé (ou documents de |
| 6 | feedback | 6 | feedback |
| 7 | ). Notre approche estime automatiquement le nombre | 7 | ). Notre approche estime automatiquement le nombre |
| 8 | de concepts ainsi que le nombre de documents de | 8 | de concepts ainsi que le nombre de documents de |
| 9 | feedback | 9 | feedback |
| 10 | sans aucun apprentissage préalable | 10 | sans aucun apprentissage préalable |
| 11 | ni paramétrage. Les concepts implicites sont pondérés afin de refléter leur importance relative | 11 | ni paramétrage. Les concepts implicites sont pondérés afin de refléter leur importance relative |
| 12 | par rapport à la requête et sont utilisés pour modifier l’ordre des documents renvoyés à l’utili- | 12 | par rapport à la requête et sont utilisés pour modifier l ordre des documents renvoyés à l utili- |
| 13 | sateur. Nous utilisons quatre sources d’information générales de natures différentes (web, jour- | 13 | sateur. Nous utilisons quatre sources d information générales de natures différentes (web, jour- |
| 14 | nalistique, encyclopédique) à partir desquelles les documents de | 14 | nalistique, encyclopédique) à partir desquelles les documents de |
| 15 | feedback | 15 | feedback |
| 16 | sont extraits. Nous | 16 | sont extraits. Nous |
| 17 | comparons différentes approches état-de-l’art sur deux collections | 17 | comparons différentes approches état-de-l art sur deux collections |
| 18 | ad-hoc | 18 | ad-hoc |
| 19 | de TREC, et les ré- | 19 | de TREC, et les ré- |
| 20 | sultats montrent que l’utilisation de concepts implicites identifiés par notre méthode améliore | 20 | sultats montrent que l utilisation de concepts implicites identifiés par notre méthode améliore |
| 21 | significativement les performances de recherche documentaire. | 21 | significativement les performances de recherche documentaire. |
| 22 | ABSTRACT. | 22 | ABSTRACT. |
| 23 | In this paper we introduce an unsupervised method for mining and modeling la- | 23 | In this paper we introduce an unsupervised method for mining and modeling la- |
| 24 | tent search concepts. We use Latent Dirichlet Allocation (LDA), a generative probabilistic | 24 | tent search concepts. We use Latent Dirichlet Allocation (LDA), a generative probabilistic |
| 25 | topic model, to exhibit highly-specific query-related topics from pseudo-relevant feedback doc- | 25 | topic model, to exhibit highly-specific query-related topics from pseudo-relevant feedback doc- |
| 26 | uments. Our approach automatically estimates the number of latent concepts as well as the | 26 | uments. Our approach automatically estimates the number of latent concepts as well as the |
| 27 | needed amount of feedback documents, without any prior training step. Latent concepts are | 27 | needed amount of feedback documents, without any prior training step. Latent concepts are |
| 28 | then weighted to reflect their relative adequacy and are further used to automatically reformu- | 28 | then weighted to reflect their relative adequacy and are further used to automatically reformu- |
| 29 | late the initial user query. We also explore the use of different types of sources of information for | 29 | late the initial user query. We also explore the use of different types of sources of information for |
| 30 | modeling the latent concepts. For this purpose, we use four general sources of information of | 30 | modeling the latent concepts. For this purpose, we use four general sources of information of |
| 31 | various nature (web, news, encyclopedic) from which the feedback documents are extracted. We | 31 | various nature (web, news, encyclopedic) from which the feedback documents are extracted. We |
| 32 | evaluate our approach over two large ad-hoc TREC collections, and results show that it signif- | 32 | evaluate our approach over two large ad-hoc TREC collections, and results show that it signif- |
| 33 | icantly improves document retrieval effectiveness while best results are achieved by combining | 33 | icantly improves document retrieval effectiveness while best results are achieved by combining |
| 34 | latent concepts modeled from all available sources. | 34 | latent concepts modeled from all available sources. |
| 35 | Le but de la Recherche d’Information (RI) est de satisfaire le besoin d’information | 35 | Le but de la Recherche d Information (RI) est de satisfaire le besoin d information |
| 36 | d’un utilisateur, généralement en proposant des documents ou des passages provenant | 36 | d un utilisateur, généralement en proposant des documents ou des passages provenant |
| 37 | d’une collection cible. Ce besoin est habituellement représenté par une requête com- | 37 | d une collection cible. Ce besoin est habituellement représenté par une requête com- |
| 38 | posée de quelques mots-clés, qui est soumise au système de recherche d’information. | 38 | posée de quelques mots-clés, qui est soumise au système de recherche d information. |
| 39 | Le système cherche alors les documents qui contiennent les mots-clés, afin de fournir | 39 | Le système cherche alors les documents qui contiennent les mots-clés, afin de fournir |
| 40 | à l’utilisateur une liste de documents ordonnée en fonction de leur pertinence esti- | 40 | à l utilisateur une liste de documents ordonnée en fonction de leur pertinence esti- |
| 41 | mée par rapport à la requête. Seulement, un besoin d’information complet peut être | 41 | mée par rapport à la requête. Seulement, un besoin d information complet peut être |
| 42 | trop complexe pour être exprimé en quelques mots, ou l’utilisateur peut ne pas avoir | 42 | trop complexe pour être exprimé en quelques mots, ou l utilisateur peut ne pas avoir |
| 43 | le vocabulaire ou les compétences nécessaires pour formuler efficacement la requête. | 43 | le vocabulaire ou les compétences nécessaires pour formuler efficacement la requête. |
| 44 | Ingwersen (1994) dit en effet que la formulation d’une requête par un utilisateur est la | 44 | Ingwersen (1994) dit en effet que la formulation d une requête par un utilisateur est la |
| 45 | représentation de son état cognitif actuel concernant un besoin d’information. Une re- | 45 | représentation de son état cognitif actuel concernant un besoin d information. Une re- |
| 46 | quête peut ne pas être correctement formulée si l’utilisateur cherche des informations | 46 | quête peut ne pas être correctement formulée si l utilisateur cherche des informations |
| 47 | sur une thématique pour laquelle il n’a pas de connaissances. Ainsi, sans contexte ad- | 47 | sur une thématique pour laquelle il n a pas de connaissances. Ainsi, sans contexte ad- |
| 48 | ditionnel, le système de recherche d’information peut manquer des nuances ou des | 48 | ditionnel, le système de recherche d information peut manquer des nuances ou des |
| 49 | détails que l’utilisateur n’a pas fourni dans la requête. Ce contexte peut prendre la | 49 | détails que l utilisateur n a pas fourni dans la requête. Ce contexte peut prendre la |
| 50 | forme d’un modèle des intérêts de l’utilisateur basé sur son historique personnel (ou | 50 | forme d un modèle des intérêts de l utilisateur basé sur son historique personnel (ou |
| 51 | ses interactions sociales), ou peut être composé d’éléments extraits de documents si- | 51 | ses interactions sociales), ou peut être composé d éléments extraits de documents si- |
| 52 | milaires représentant les thèmes de la recherche (Finkelstein | 52 | milaires représentant les thèmes de la recherche (Finkelstein |
| 53 | Ce deuxième type de contexte est plus généralement connu sous le nom de « re- | 53 | Ce deuxième type de contexte est plus généralement connu sous le nom de « re- |
| 54 | cherche d’information conceptuelle » et a reçu beaucoup d’attention au cours de ces | 54 | cherche d information conceptuelle » et a reçu beaucoup d attention au cours de ces |
| 55 | dernières années L’idée générale est d’étendre les requêtes avec des | 55 | dernières années L idée générale est d étendre les requêtes avec des |
| 56 | ensembles de mots ou de multi-mots extraits de documents de | 56 | ensembles de mots ou de multi-mots extraits de documents de |
| 57 | feedback. L’ensemble de feedback est composé de documents qui sont pertinents ou pseudo-pertinents par | 57 | feedback. L ensemble de feedback est composé de documents qui sont pertinents ou pseudo-pertinents par |
| 58 | rapport à la requête initiale, et qui sont à même de contenir des informations impor- | 58 | rapport à la requête initiale, et qui sont à même de contenir des informations impor- |
| 59 | tantes sur le contexte de la recherche. Les mots exprimant le plus d’information par | 59 | tantes sur le contexte de la recherche. Les mots exprimant le plus d information par |
| 60 | rapport à la requête sont traités comme des concepts implicites. Ils sont alors utilisés | 60 | rapport à la requête sont traités comme des concepts implicites. Ils sont alors utilisés |
| 61 | pour reformuler la requête. Le problème avec cette approche est que chaque mot re- | 61 | pour reformuler la requête. Le problème avec cette approche est que chaque mot re- |
| 62 | présente un concept spécifique. Seulement un concept représente une notion et peut | 62 | présente un concept spécifique. Seulement un concept représente une notion et peut |
| 63 | être vu comme un ensemble de connaissances. Stock (2010) donne une définition qui | 63 | être vu comme un ensemble de connaissances. Stock (2010) donne une définition qui |
| 64 | suit cette direction en affirmant qu’un concept est défini comme une classe contenant | 64 | suit cette direction en affirmant qu un concept est défini comme une classe contenant |
| 65 | des objets possédant certaines propriétés et attributs. | 65 | des objets possédant certaines propriétés et attributs. |
| 66 | L’objectif du travail présenté dans cet article est de représenter avec précision les | 66 | L objectif du travail présenté dans cet article est de représenter avec précision les |
| 67 | concepts sous-jacents associés à une requête, améliorant indirectement les informa- | 67 | concepts sous-jacents associés à une requête, améliorant indirectement les informa- |
| 68 | tions contextuelles liées à la recherche documentaire. Nous introduisons ainsi une | 68 | tions contextuelles liées à la recherche documentaire. Nous introduisons ainsi une |
| 69 | méthode entièrement non supervisée qui permet de détecter les concepts implicites | 69 | méthode entièrement non supervisée qui permet de détecter les concepts implicites |
| 70 | liés à une requête donnée et d’améliorer les performances d’un système de recherche | 70 | liés à une requête donnée et d améliorer les performances d un système de recherche |
| 71 | documentaire en incorporant ces concepts à la requête initiale. Pour chaque requête, | 71 | documentaire en incorporant ces concepts à la requête initiale. Pour chaque requête, |
| 72 | les concepts implicites sont extraits d’un ensemble réduit de documents de | 72 | les concepts implicites sont extraits d un ensemble réduit de documents de |
| 73 | initialement récupérés par le système. Ces documents de | 73 | initialement récupérés par le système. Ces documents de |
| 74 | ous estimons la similarité entre deux modèles conceptuels en calculant les simi- | 74 | ous estimons la similarité entre deux modèles conceptuels en calculant les simi- |
| 75 | larités entre toutes les paires de concepts des deux modèles. Seulement, deux modèles | 75 | larités entre toutes les paires de concepts des deux modèles. Seulement, deux modèles |
| 76 | différents sont générés à partir de documents différents, ils ne partagent donc pas le | 76 | différents sont générés à partir de documents différents, ils ne partagent donc pas le |
| 77 | même espace probabiliste. Les distributions de probabilités ne sont donc pas compa- | 77 | même espace probabiliste. Les distributions de probabilités ne sont donc pas compa- |
| 78 | rables, le calcul de similarité ne peut se faire qu’en prenant en compte les mots des | 78 | rables, le calcul de similarité ne peut se faire qu en prenant en compte les mots des |
| 79 | concepts. Les concepts sont donc ramenés à de simples sacs de mots, et nous utilisons | 79 | concepts. Les concepts sont donc ramenés à de simples sacs de mots, et nous utilisons |
| 80 | une mesure de similarité basée sur la fréquence inverse des mots dans les documents | 80 | une mesure de similarité basée sur la fréquence inverse des mots dans les documents |
| 81 | de la collection. | 81 | de la collection. |
| 82 | La figure 1 présente des histogrammes traçant le nombre de requêtes en fonction | 82 | La figure 1 présente des histogrammes traçant le nombre de requêtes en fonction |
| 83 | du nombre de concepts implicites estimé et du nombre de documents de | 83 | du nombre de concepts implicites estimé et du nombre de documents de |
| 84 | feedback | 84 | feedback |
| 85 | ,et | 85 | ,et |
| 86 | ce pour les deux collections. On voit que le comportement est relativement identique | 86 | ce pour les deux collections. On voit que le comportement est relativement identique |
| 87 | sur les deux collections. Entre deux et trois concepts sont identifiés pour la grande | 87 | sur les deux collections. Entre deux et trois concepts sont identifiés pour la grande |
| 88 | majorité des requêtes. De même ces concepts sont généralement identifiés au sein d’un | 88 | majorité des requêtes. De même ces concepts sont généralement identifiés au sein d un |
| 89 | nombre assez réduit de documents, entre deux et quatre pour les deux collections. | 89 | nombre assez réduit de documents, entre deux et quatre pour les deux collections. |
| 90 | 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 | 90 | 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 |
| 91 | ou 3 articles Wikipédia suffisent pour un très grand nombre de requêtes, alors qu’un | 91 | ou 3 articles Wikipédia suffisent pour un très grand nombre de requêtes, alors qu un |
| 92 | plus grand nombre est nécessaire pour la ressource Web. Ce comportement est très | 92 | plus grand nombre est nécessaire pour la ressource Web. Ce comportement est très |
| 93 | cohérent avec la nature même de Wikipédia, où les articles sont rédigés dans le but | 93 | cohérent avec la nature même de Wikipédia, où les articles sont rédigés dans le but |
| 94 | d’être très précis et de ne pas trop s’éparpiller. Il est d’ailleurs fréquent qu’un article | 94 | d être très précis et de ne pas trop s éparpiller. Il est d ailleurs fréquent qu un article |
| 95 | devenu trop conséquent soit coupé en plusieurs autres articles traitant chacun un sujet | 95 | devenu trop conséquent soit coupé en plusieurs autres articles traitant chacun un sujet |
| 96 | très spécifique. | 96 | très spécifique. |
| 97 | Des idées empruntées à la physique ont déjà été utilisées dan | 97 | Des idées empruntées à la physique ont déjà été utilisées dan |
| 98 | s l’analyse de textes. Les exemples | 98 | s l analyse de textes. Les exemples |
| 99 | plus notables sont l’approche entropique de (Shannon, 1948 | 99 | plus notables sont l approche entropique de (Shannon, 1948 |
| 100 | ), les travaux de (Zipf, 1935; Zipf, | 100 | ), les travaux de (Zipf, 1935; Zipf, |
| 101 | 1949) et de (Mandelbrot, 1953) où les auteurs font des consid | 101 | 1949) et de (Mandelbrot, 1953) où les auteurs font des consid |
| 102 | érations thermodynamiques d’éner- | 102 | érations thermodynamiques d éner- |
| 103 | gie et de température dans leurs études sur la Statistique Te | 103 | gie et de température dans leurs études sur la Statistique Te |
| 104 | xtuelle. Dernièrement se sont servi des notions de polarisation des système | 104 | xtuelle. Dernièrement se sont servi des notions de polarisation des système |
| 105 | orientations sémantiques des mots (désirable ou indésirable) à partir de mots amorce. La sortie | 105 | orientations sémantiques des mots (désirable ou indésirable) à partir de mots amorce. La sortie |
| 106 | de ce système est une liste de mots indiquant leurs orientati | 106 | de ce système est une liste de mots indiquant leurs orientati |
| 107 | ons estimés selon l’approximation | 107 | ons estimés selon l approximation |
| 108 | du champ moyen. Dans notre travail, nous avons utilisé diffé | 108 | du champ moyen. Dans notre travail, nous avons utilisé diffé |
| 109 | remment la notion de spin des mots dans les documents. À | 109 | remment la notion de spin des mots dans les documents. À |
| 110 | partir de cet image, on aperçoit le document comme un matéria | 110 | partir de cet image, on aperçoit le document comme un matéria |
| 111 | ux composé d’un ensemble de | 111 | ux composé d un ensemble de |
| 112 | unités en interaction dont l’énergie peut être calculée. No | 112 | unités en interaction dont l énergie peut être calculée. No |
| 113 | us avons étudié les problèmes du Trai- | 113 | us avons étudié les problèmes du Trai- |
| 114 | tement Automatique de la Langue Naturelle (TALN) en utilisa | 114 | tement Automatique de la Langue Naturelle (TALN) en utilisa |
| 115 | nt la notion d’énergie textuelle. | 115 | nt la notion d énergie textuelle. |
| 116 | 116 |
test/functional/testLiaSoap.py
| 1 | from suds.client import Client | 1 | from suds.client import Client |
| 2 | import time | 2 | import time |
| 3 | import threading | 3 | import threading |
| 4 | 4 | ||
| 5 | ### TODO : Tester en parallele x4 un million de fois pour voir ### | 5 | ### TODO : Tester en parallele x4 un million de fois pour voir ### |
| 6 | url = 'http://127.0.0.1:9000/?wsdl' | 6 | url = 'http://127.0.0.1:9000/?wsdl' |
| 7 | client = Client(url) | 7 | client = Client(url) |
| 8 | filename = "data.txt" | 8 | filename = "data.txt" |
| 9 | file = open(filename, "r") | 9 | file = open(filename, "r") |
| 10 | nb_times=4 | 10 | nb_times=4 |
| 11 | # Exp 1 | 11 | # Exp 1 |
| 12 | debut =time.time() | 12 | debut =time.time() |
| 13 | contents = file.read().decode("utf8").encode("ascii", errors='ignore').rstrip() | 13 | contents = file.read().decode("utf8").rstrip() |
| 14 | res =client.service.get_phon(contents) | 14 | res =client.service.get_phon(contents) |
| 15 | print(res) | 15 | print(res) |
| 16 | duree= time.time()- debut | 16 | duree= time.time()- debut |
| 17 | print (" Exper 1 : " + str(duree)) | 17 | print (" Exper 1 : " + str(duree)) |
| 18 | # Exp 2 | 18 | # Exp 2 |
| 19 | #debut =time.time() | 19 | #debut =time.time() |
| 20 | #file.seek(0) | 20 | #file.seek(0) |
| 21 | #lines = file.readlines() | 21 | #lines = file.readlines() |
| 22 | #for line in lines: | 22 | #for line in lines: |
| 23 | # line = line.decode("utf8").encode("ascii", errors='ignore').rstrip() | 23 | # line = line.decode("utf8").encode("ascii", errors='ignore').rstrip() |
| 24 | # if line is not None: | 24 | # if line is not None: |
| 25 | # try: | 25 | # try: |
| 26 | # client.service.get_phon(line) | 26 | # client.service.get_phon(line) |
| 27 | # except: | 27 | # except: |
| 28 | # continue | 28 | # continue |
| 29 | #duree= time.time()- debut | 29 | #duree= time.time()- debut |
| 30 | #print (" Exper 2 line by line 1 corpus : " + str(duree)) | 30 | #print (" Exper 2 line by line 1 corpus : " + str(duree)) |
| 31 | ###Exp 3 | 31 | ###Exp 3 |
| 32 | #debut = time.time() | 32 | #debut = time.time() |
| 33 | #file.seek(0) | 33 | #file.seek(0) |
| 34 | #contents = file.read().decode("utf8").encode("ascii", errors='ignore').rstrip() | 34 | #contents = file.read().decode("utf8").encode("ascii", errors='ignore').rstrip() |
| 35 | #tabs=[] | 35 | #tabs=[] |
| 36 | #i=0 | 36 | #i=0 |
| 37 | #while i <= nb_times : | 37 | #while i <= nb_times : |
| 38 | # tabs.append(contents) | 38 | # tabs.append(contents) |
| 39 | # i+=1 | 39 | # i+=1 |
| 40 | #client.service.get_phon("".join(tabs)) | 40 | #client.service.get_phon("".join(tabs)) |
| 41 | #duree= time.time()- debut | 41 | #duree= time.time()- debut |
| 42 | #print ("Exper 3 2pow4 time the content in once shot " + str(duree)) | 42 | #print ("Exper 3 2pow4 time the content in once shot " + str(duree)) |
| 43 | # EXP 4 | 43 | # EXP 4 |
| 44 | #debut = time.time() | 44 | #debut = time.time() |
| 45 | #contents = file.read().decode("utf8").encode("ascii", errors='ignore').rstrip() | 45 | #contents = file.read().decode("utf8").encode("ascii", errors='ignore').rstrip() |
| 46 | #def envoie(datas): | 46 | #def envoie(datas): |
| 47 | # client.service.get_phon(datas) | 47 | # client.service.get_phon(datas) |
| 48 | #i =0 | 48 | #i =0 |
| 49 | #threadTab= [] | 49 | #threadTab= [] |
| 50 | #while i <= nb_times: | 50 | #while i <= nb_times: |
| 51 | # threadTab.append(threading.Thread(None, envoie, None,contents,None)) | 51 | # threadTab.append(threading.Thread(None, envoie, None,contents,None)) |
| 52 | #duree = time.time() - debut | 52 | #duree = time.time() - debut |
| 53 | 53 |