EP1719061A2 - Procédé mis en oeuvre dans un environnement informatique pour engendrer une vue courante à partir d'au moins un objet d'information source susceptible de varier - Google Patents
Procédé mis en oeuvre dans un environnement informatique pour engendrer une vue courante à partir d'au moins un objet d'information source susceptible de varierInfo
- Publication number
- EP1719061A2 EP1719061A2 EP04805302A EP04805302A EP1719061A2 EP 1719061 A2 EP1719061 A2 EP 1719061A2 EP 04805302 A EP04805302 A EP 04805302A EP 04805302 A EP04805302 A EP 04805302A EP 1719061 A2 EP1719061 A2 EP 1719061A2
- Authority
- EP
- European Patent Office
- Prior art keywords
- information
- objects
- information object
- user
- derived
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Withdrawn
Links
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F40/00—Handling natural language data
- G06F40/10—Text processing
- G06F40/194—Calculation of difference between files
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F40/00—Handling natural language data
- G06F40/10—Text processing
- G06F40/197—Version control
Definitions
- the present invention relates generally to techniques for handling information objects (web pages, files, parts of files, etc.), and for navigating among these information objects.
- It aims in particular to propose methods in which a user can personalize “source” information objects, and where both the changes which have appeared in the source information object or objects and the personalization which he has effected can be found in a current view each time said user makes access to such an object.
- the present invention also relates generally to the methods implemented in an environment or computer system for assigning to information objects or resources relevance scores, and the methods for accessing resources in an environment or computer system based on such relevance scores.
- the main object of the invention is therefore to allow a user to create “relevance relationships” between a first resource 1 and other resources, in order to be able to find the first resource simply by accessing at least one relevant resource. compared to the first resource.
- one (or more) resource (s) relevant to the first resource can (not) be, not only one (some) of said other resources that the user has linked (s) ) to the first resource, but also: - a resource (s) having a relevance relationship with the first resource, created by another user in a network of relevance relationships shared between these two users, - one (of ) resource (s) for which the first resource is automatically deemed relevant by means of inference rules 2 which apply to the relevance relationships thus created, - one (or more) resource (s) for which (which ) the first resource has a high relevance score which was automatically determined by the process by assimilating the relations of
- resource an information resource.
- relevance relationship between two resources is meant a relationship indicating their relative relevance (one in relation to the other).
- An object of the invention is that, in addition to the relevance relationships created by the users themselves, the method can use relevance score propagation conduits created automatically from the interrelationships and the content of the resources.
- a method of the invention aims to automatically create conduits: between the co-cited resources 4 , between the resources linked by hypertext links, between the resources having distributions close to words, possibly by combining in addition with determined conduits with further other methods of calculating relevance between resources.
- the invention aims to allow the user: • to find the first resources; • as the user can share a network (relevance relationships and relevance score propagation paths) with other users, the process aims to allow the user to discover the first resources expressly linked by others users within the shared network; • Finally, the process also allows the user to discover other relevant resources from private or public resources (eg on the Web) to which good scores have spread via automatically placed conduits.
- the present invention further aims in particular to propose techniques in which a user can modify a source information object - he can for example associate annotations to it, or personalize part of it - and save the modifications as a page derived from the original page.
- the invention also aims to allow the derived page to be spontaneously presented to it by the system when it revisits the original page.
- the invention aims to determine, by exploiting the links which are found in the pages of the Web, the degree of relevance of the pages in relation to each other and in relation to the browsing context of the user.
- the invention aims to present the user with the most relevant derived page as well as annotations associated with other relevant pages and links to other relevant pages.
- Another object of the invention is to allow an annotation to be for example a link to an information resource such as a file, so that the user can thus find information resources simply by placing themselves in their context of relevance: when the user navigates and gets closer to the context of the resource he is looking for, we aim for a system which spontaneously suggests it to him.
- the invention thus aims to use the system constituting, for the user, an "associative memory".
- the invention aims, finally, to facilitate the manipulation of information objects by allowing selections of parts of information objects made in a graphical user interface to become in turn manipulated for example for the benefit of other objectives supra.
- the invention proposes a method implemented in a computer environment to generate a current view from at least one source information object liable to vary, characterized in that it comprises the following steps: establish and store a reference of the view to the source information object, use by a user at least one information object modification tool to produce an object from the source information object transformed information, save in a memory a set of difference information representative of the effect of modification actions performed by the user using the tool (s), and generate a current view from the or each object source information in its current version and said set of difference information.
- the information object modification tool includes a document editing program.
- the editing program is able to generate a log of the modifications made to each document, the recording step is implemented using the log data.
- the information object modification tool includes a plurality of modification operators that can be individually selected by the user.
- the current view consists of a reference to the source information object, said reference being associated with a containing information object.
- the method further comprises a step of establishing and storing a relationship between an information object containing directly or indirectly said view and the source information object.
- the method further comprises a step of establishing and storing a relationship between the view and the source information object.
- the method further comprises the implementation of an inference process based on a plurality of semantic relationships between views and source information objects.
- the reference of the view to the source information object is constituted by a request in response to which one or more source information objects are delivered.
- the request is a request applied to a search engine, the latter delivering the source information object or objects.
- the request consists of a group of information objects, and the method comprises a step of searching for at least one other information object having the best score of relevance with respect to said group.
- the method comprises a step of memorizing the current view generated, and said set of difference information contains one or more pointers to one or more information objects whose content and position are contained in the current view.
- said information objects are structured into hierarchical sub-objects, and in the case where said set of difference information contains difference information targeting a part of an object, then the step of generating the current view retains the latest version of the smallest sub-object containing such an object part.
- said difference information relating to a part of an object comprises an item of attribute change information.
- said difference information targeting a part of an object comprises object position information.
- the method is implemented as many times as there are sub-objects.
- the difference information set contains, for an object comprising a plurality of sub-objects, modified / unmodified attributes for each of these object objects.
- each object identifier is unique in the IT environment.
- each current view has at least one composite identifier comprising a modification identifier and an object identification to which the modification by the corresponding difference information set applies.
- a current view has an identifier referring to a plurality of modification identifiers and a plurality of object identifiers to which the modifications by the corresponding sets of difference information apply respectively.
- a corresponding composite identifier comprises an object identifier possessed by said other starting information object and a double identifier of sets of difference information.
- a method implemented in an IT environment for assigning relevance scores to information objects, characterized in that it comprises the following steps: - assign to at least certain pairs of objects information a capacity (conduit) for propagation of relevance score from one information object to another, - assign to at least one information object a relevance score, and - calculate, for at least one other information object, a relevance score from relevance scores of information objects having with said other information object a propagation capacity and values (sizes of conduits) of said propagation capacities.
- a propagation capacity is assigned to each pair of information objects, a propagation capacity possibly having a zero value.
- at least certain information objects are linked together by citing information object links to cited information object, and the propagation capacity between two information objects is calculated on the basis of a number criterion common citing information objects between these two information objects.
- the calculation step includes a sum of the relevance scores weighted with the propagation capacities.
- the method includes a step of developing, by the user, a propagation capacity between two information objects of a pair.
- each pair of information objects is assigned two propagation capacities, one in a first direction and the other in the opposite direction.
- the invention further provides a method for accessing information objects in a computer environment, characterized in that it comprises: - the creation of a group of initial information objects, - the implementation implementation of the method as defined above to identify other information objects having the highest relevance scores with respect to the group of initial information objects, and - the display of elements representative of said objects of information identified for access to these by the user.
- the method includes the prior step of implementing a search process to develop the group of initial information objects.
- the group of initial information objects is developed from a manual and / or automated classification of information objects in an operating system of the IT environment or in a computer application.
- the method further comprises: - the determination of a refined relevance relationship between at least one of the identified information objects and at least one of the initial information objects, and - the graphic representation of said relationships of relevance refined.
- the display step comprises: the determination of the existence of non-zero propagation capacities between the starting information objects and said identified information objects, and - the graphical representation of links between said identified information objects and the original information objects as a function of the propagation capacities.
- the method further comprises: - determining the existence of a zero preexisting propagation capacity between at least one initial information object and an identified information object, and - modifying this zero propagation capacity in a non-zero propagation capacity.
- the set of information objects is formed by a basic network comprising information objects and the corresponding propagation capacities, and by modifications / additions / deletions made to this basic network to form a modified network, and the implementation of the method defined above is carried out from the group of initial information objects and said modification / addition / deletion data.
- the invention also proposes a method for accessing information objects in a computer environment, characterized in that it comprises: - the implementation of the method as defined above for determining absolute relevance scores of the 'set of information objects, - the implementation of a search process using a request, - the sorting of information objects satisfying said request according to their absolute relevance score, and - the display of '' representative elements of information objects sorted for access to them by the user.
- a method is also proposed according to the invention for accessing information objects in a computer environment, characterized in that it comprises: - the creation of a group of initial information objects, - the implementation of a relevance score calculation method to identify other information objects having the highest relevance scores compared to the group of initial information objects, - the creation of an object additional information representative of the group of initial information objects, and - the creation of propagation capacities, established as a function of said relevance scores, between the identified information objects and the additional information object.
- the invention also provides a method, implemented in a computer environment comprising information objects having references to other information objects, and in particular first content having at least one reference to second content such as a link to the second content or such as a transclusion of the second content, for the management of such references as a function of the existence of modifications made to the information objects by the user, characterized in that it comprises the steps following: - viewing by the user of a second current content via a reference possessed by a first content, in a mode allowing the modification of said second content; - when said second content is modified in said mode, creation of a new version of the second content and replacement of said reference by a reference to this new version.
- said reference is a query such as a query in a standard language, to a database.
- said new version of the second content is represented by a structure of markers containing the differences between said new version of the second content and said second current content, so as to present to the user a second content in which said differences have been applied to the version second content.
- the invention also proposes a method implemented in a computer environment for selectively accessing a derived information object created in the computer environment from a starting information object, characterized in that it includes the following steps: (a) developing relevance scores of the original information object and the derived information object using a given relevance determination mechanism; (b) in connection with the access by a user to the initial information object, whether or not providing the user with information on the existence of the derived information object or access to said object of derived information, based on said relevance scores.
- step (a) also draws up a relevance score of at least one other information object
- step (b) further comprises whether or not providing the user with information on the existence of said other information object or of access to said other information object, according to said relevance scores.
- step (a) also develops a relevance score of at least one other information object, and the method further comprises, in connection with access to the initial information object or to the derived information object, a step (c) of providing or not providing the user with information on the existence of said other information object, as a function of said relevance scores.
- step (a) also develops a relevance score of at least one other information object, and the method further comprises, in connection with access to the initial information object or to the derived information object, a step (c) of displaying or not displaying at least part (annotation) of the content of said other information object, as a function of said relevance scores.
- step (b) is implemented in relation to the existence of a modification made to said derivative or initial information object since its previous supply to the user.
- step (c) is implemented in relation to the existence of a modification made to said other information object since its previous supply to the user.
- the starting information objects being connected by directional links to together form a starting oriented graph
- the method further comprises the step of constructing a virtual derived graph formed from the starting oriented graph and virtual links starting from information objects citing the initial information object and directed to the derived information object, and the relevance scores are developed on the basis of said virtual derived graph.
- the derived information object is an information object having at least one view towards at least part of the initial information object.
- the derived information object is an information object having at least a copy of at least part of the original information object.
- the step of constructing the virtual derived graph also takes into account virtual links starting from information objects quoting said other starting information object and directed towards said other derived information object.
- the step of constructing the virtual derived graph takes into account the virtual links starting from information objects citing the objects d 'respective initial information and directed to the derived information object.
- a method implemented in a computer environment for personalized access to information objects comprising initial information objects linked by oriented links to form together a starting structure, characterized in that it comprises the steps consisting in: (a) creating information objects added to the starting information objects, to form a derived structure, (b) storing the derived structure under form of a reference to the starting structure, of the added information objects and of links between the starting structure and the added information objects, (c) memorizing, in association with the derived structure, specific research information relevant information objects, (d) search for relevant information objects in the derived structure using specific information from re seeks.
- steps (a) to (c) are implemented repeatedly to form a plurality of derived structures by adding information objects to the starting structure or to preexisting derived structures.
- step (c) of memorizing specific search information takes place in the form of a reference to specific search information already associated with the structure or to a preexisting derived structure, and specific search information added.
- the invention additionally provides a method implemented in a computer environment for selectively accessing one of a plurality of information objects from a starting information object, characterized in that it comprises the steps following: (a) elaborating relevance scores of the initial information object and other information objects using a given relevance determination mechanism, said other information objects comprising objects of independent information and information objects derived from the original information object and / or these independent information objects, (b) in relation to access by a user to the original information object , whether or not to provide the user with information on the existence of another information object or access to said other information object, according to said relevance scores.
- step (b) is implemented in relation to the existence of a modification made to said other information object since its previous supply to the user.
- the relevance determination mechanism is based on analyzes of links between information objects, at least one of the derived information objects is obtained by reproduction of a starting information object or by insertion, in a any information object, a view or a copy of the whole of said initial information object, and the method comprises a step of creating virtual links directed to said derived information object and starting from each information object having a link directed to the initial information object considered.
- the relevance determination mechanism is based on analyzes of links between information objects, at least one of the derived information objects is obtained by inserting, in any information object, a view or d '' a copy of only a part of a starting information object, this part being or containing itself a view or a copy of the whole of an indirect starting information object, and the method comprises a step of creating a virtual link directed to said derived information object and starting from each information object having a link directed to the initial indirect information object considered.
- the method further comprises, in connection with access to the initial information object or to another information object, a step of displaying or not displaying at least part (annotation) of the content of 'a third information object, according to said relevance scores.
- the display step is also implemented according to the existence of a modification made to the third information object since its previous display.
- the present invention also provides a method implemented in a networked computing environment for displaying a personalized information object obtained from an original information object, characterized in that it comprises the following steps: load the original information object from a site making said original information object available to the user, save in a memory a work information object obtained from '' a copy of the original information object, implement information object modification tools to produce from the said working information object a modified information object, save in a memory a set of information representative of the differences between the original information object or the work information object and the modified information object, and on subsequent access to the information object original, generate, from the original information object in its current version and of said set of information representative of said differences, a new modified information object.
- a preferred but non-limiting aspect of this process is as follows: * the work information object comprises a plurality of content belonging to the original information object and identifiers assigned to the respective content, and the differences represented by said set of information are differences identifier by identifier.
- a method of manipulating information is proposed using a graphical user interface, said interface comprising means allowing selection of a portion of given information, characterized in that it comprises a step of converting 'a selection made using said interface into a later manipulable object.
- the conversion step is implemented only in response to a user instruction triggered using a pointing tool used to make the selection.
- the method further comprises a step of selective display of a visual indicator showing the existence, among displayed information, of an information object resulting from a previous conversion from a selection.
- process or the term “system” will be used in an essentially undifferentiated manner, depending in particular on whether one refers to the actions implemented by the process of the invention or the computer system that supports these actions.
- object designates any information resource having an identity. For example: • a computer file • an element of a document in XML format • a directory • a paragraph in a Word document • a selection of part of a Word document • a web page • an entry in a directory (this entry representing a particular person). An object can contain others, thus forming a hierarchy 6 .
- relation covers any form of reference to one (or a set of) “source object (s)”, which reference is associated with a “connected object”.
- a relation can thus be for example: • a semantic relation from one object to another. For example, o an “author” relationship of a document (the linked object) written by a certain person, to the object (source object) representing this person;
- resource and “information resource” are also synonymous - for example in UP (Unifor Resource Identifier).
- transclusion or inclusion by reference 7
- HTML A special case of relation is transclusion (or inclusion by reference 7 ).
- img the "img" tag in HTML allows you to include an image by reference.
- transclusion is represented by the option "Create a link" from the menu that appears when a Word document is dragged and dropped from a selection of part of the document by holding the right button of the mouse supported.
- Transclusion consists in creating a view ("the result") of at least one object ("source”) placed in an object ("the container”).
- Source objects can be distant. They are either identified directly or implicitly as the result of a search query 10 .
- the source (of a transclusion) means "the source object or the set of source objects (of said transclusion)”.
- FIG. 1 schematically shows an example of a series of enriched transclusion operations 13 .
- A, B and C There are three documents, respectively named A, B and C. Initially these 3 documents are empty except A which contains a section (whose identifier is 1) in which there is a paragraph (whose identifier is 2).
- paragraph 3 First of all the user transcludes paragraph 2 in document B (transclusion 3). The result is paragraph 3: 2. Then he transcludes the latter in section 1 of document A, and places it just before paragraph 2 (transclusion 4). Finally he transcludes section 1 (taken entirely) in document C (transclusion 5).
- document C contains section 5: 1 in which paragraphs 5: 4: 3: 2 and 5: 2 are presented.
- the transclusion enriched with a view of an R2 directory would offer the advantage of being able to modify (add, rename, delete, etc. .) objects (files, sub-directories) in this view without modifying the content of the source of this view (that is to say without modifying the original content of the R2 directory - see Figure 2). If later a new object is added in R2, it will also be 1 added in this view of R2 (as in the simple transclusion).
- the invention provides in particular the implementation of an editor (or explorer) of objects presenting the objects in a tree-like manner (in the style of current file explorers) which allows on the one hand to carry out enriched transclusions, and on the other hand to create relationships between objects (for example to link a file located in a directory (or a directory view) with another file located in another directory in the same tree structure - see Figure 2) , each relationship optionally giving rise to a channel for the propagation of relevance scores.
- the user will create relations of the type “comments” (i.e. such object is a comment of), “confirms”, “contradicts”, “is against”, “is for”, “supports”,
- such an object explorer is able to present relations connecting an object taken as a whole to a part of another object.
- an object not explicitly presented such as a selection of only part of a document (the document being represented by an icon 17 in the object editor) can be linked with an object presented explicitly such as 'another document or directory. The user can then “zoom in” on the object not explicitly presented to refine the granularity of presentation.
- conduits are placed (automatically, for example by measuring the similarity of word distribution, or manually by the user) between web objects and the user's private objects, some of which can, for example, be transposed from other users' private items. This is how relevance scores for web objects spread to user 1's private objects. Private objects and / or objects of the Web can thus be considered relevant and will then be presented to the user, according to his current context of navigation 19 or exploration of objects.
- new relevant found objects can be automatically presented in the context of an object editor (such as a file explorer described above; for example new documents can be inserted in the (enriched) view of the R2 directory) .
- object editor such as a file explorer described above; for example new documents can be inserted in the (enriched) view of the R2 directory
- relevance relationships are automatically placed with existing objects (Figure 2 illustrates the automatic placement of a relevant object and its relationships in the Rl / réelle-de-R2 / R3 directory. ).
- the user can choose how the result of the transclusion should be presented, the trivial case being to insert all of the content. At the other extreme he can ask to have only a hypertext link (and therefore that the content is only accessible by a click on the link). The user can request that certain changes are made to the content source 20 before it is inserted into the object to be presented. He can choose a transformation from a pre-established list (which he can complete as needed), for example applying a function which selects the first n characters of each source object.
- the user can also define the transformations to be performed by acting directly on the result of the transclusion, using the appropriate content manipulation tool 21 (the tool he would use if he wanted to modify the source).
- the results of the actions he performs are saved in order to to be able to apply these transformations automatically the next time the object is displayed or updated. For example if the user exchanges two parts of a transcluded object, when the content of this object changes at the source, the two parts will keep their new position but their content will always correspond to that of the source.
- the current version of a transclusion (or "current view”) is the representation of the result of the transclusion, as it was presented the last time. This current version is kept, and is updated by the system each time the user accesses it.
- each transclusion is associated an object of differences (or "diff object"), which indicates the source or sources of this transclusion, as well as the transformations to be applied to it.
- the object of the differences is based on the current version 22 and therefore does not need to contain "verbatim" the contents and the positions of the objects to be transformed.
- the diff node indicates the source (ref) and the result (id) of the transclusion (or the identifier of the transclusion itself). Note that the source can be identified by a reference or a request.
- the identifiers “id” refer to the current version of the transclusion.
- FirstSentences is an operator that selects the first sentences of the content of an object. Modify indicates that the content of the object must be replaced (the new content being stored in the current version).
- these transformations can advantageously be carried out at the source level in order to avoid transferring unnecessary data.
- the object of differences refers to the objects of the current version (that is to say to their respective identifiers) to define the transformations which are applied to them. Move indicates that the object has been moved (the new position is also stored in the current version).
- Move, Modify and Create were created by the user by acting directly on the objects, in the same way as if he modified a local version (the process allowing this is described later in the section "Manipulation of objects").
- the user can request that the content of the source of a transclusion is not included at all, but that a simple hypertext link be placed as a result, pointing to the source or sources.
- the object of the differences, in this case, would look like this:
- Each transclusion can automatically be associated with a semantic relationship linking the result of the transclusion to its source, and expressing the nature of the changes made to the content. By default, it is an equivalence relation, that is to say that the meaning of this content is not affected.
- the user has the possibility of adding another semantic relation which applies from a direct or indirect container of the result of the transclusion, to its source.
- Figure 3 presents a transclusion whose source is the object obtained in a directory, representing the author of a document, and whose result is placed in this document (and transformed so as to show only a photo 23 ) . It may be advantageous for the user (in particular when carrying out searches, as described below) to place the semantics "author" at this transclusion. In this case it will ask to apply the relation to the document itself.
- the user may wish to have only a semantic relationship between two objects, without modifying the appearance of the objects concerned.
- Figure 4 shows an object representing an article of law and another object being a legal commentary of this article of law. If the user wishes to inform the system of this relationship without modifying the appearance of these objects, he will transpose the legal commentary in the article of law (at point "X” in Figure 4), select the desired semantic relation (“commented by”), and request that the result of the transclusion be “not presented” (and therefore naturally remove the equivalence relation from the result of the transclusion). This amounts to applying a transformation which removes the entire content of the object.
- he may request to have only a hypertext link 25 , as explained previously.
- the user interface thus makes it possible, within the framework of a single interaction (consisting in defining a transclusion), to specify both the hypertext link and the added semantic relationship.
- the information objects can themselves be characterized semantically.
- the semantic characterization of an object consists in indicating to the system what (s) information (s) this object presents (ie "what this object is talking about”). This can be done by specifying keywords (or descriptive text), or by creating relationships with objects representing semantic properties. This latter approach is facilitated by instantiating structured concepts 28 which offer the advantage of better structuring the added information.
- a relation to a transclusion is optional and one can therefore define a relation without associating it with a transclusion (for example when characterizing an object semantically, as described in the following section).
- the user interface visualization objects will then present the hyperlink as well as for example the title of the semantic relationship in question.
- the user interface (or programmatic, in particular within the framework of a Web service) could also present this semantic relation within the framework of a resource graph (for example according to one of the RDF or OWL recommendations of the W3C) and allow the user (or a program) to navigate from resource to resource. So in the example of the author relationship between a document and the resource representing its author, the interface allows you to navigate from the document to its author and from there to the author's address or to other documents of the same author.
- At least one concept is associated with at least one other determined object, by a method of determining relevant objects from a set of starting objects, as being relevant with respect to a (or des) object (s) determined according to step b1, the system offers him said (or said) concept (s) associated (s) for semantically characterizing the object to be characterized; 3. then for each associated concept selected by the user, the latter characterizes the object in question by instantiating it and by entering its properties 30 , for example by simply filling in fields in a form associated with said selected associated concept.
- the object to characterize is a document concerning case law.
- the user therefore uses the keyword "jurisprudence” to characterize it.
- the system recognizes the concept with which this keyword has been associated (suppose that for example the word "jurisprudence” is the very wording of the concept in question).
- a form for collecting additional information 31 is thus associated with this concept.
- the system offers the user to fill in this form to specify and complete the information: what is the type of object of the conflict, who is the plaintiff, who is the court, what is the jurisdiction, on what date the decision has been returned, etc.
- the user thus creates relationships between the object to be characterized and the objects corresponding to the properties entered (in the "form" in question). Like all relationships, they are likely to spread relevance scores as described later in this report.
- Objects can be created, modified and deleted, using the usual tools of the user.
- the user can also create, modify and delete transclusion results and semantic relationships between different objects, as described in the previous section. Finally, it can directly act on the content of the result of a transclusion in the same way as on local content.
- the transclusion operation can be implemented by a drag and drop operation.
- a drag and drop operation For example, the selection of part of a resource (viewed in the context of a resource manipulation tool such as Word, Excel or Frontpage, or even in the context of a directory and file explorer) being made , dragging and dropping while holding the right mouse button pressed will result in the presentation of a menu (context menu) in which the user can choose the option "Transclude here".
- the system will offer the user to choose a transformation (for example in XSLT, in particular in the context of Frontpage) from a set of transformations available if necessary to immediately modify the presentation (adapt it) to this location. Then the user can still modify the result of the transclusion interactively as already described ...
- a selection can be "reified". To reify a selection is to define it as an object (in the sense of an identified object, as defined in the introduction).
- the essential advantage of reified selections is that they can be distinguished from other selections and thus encourage reuse. It is advantageously possible to implement an option according to which the system automatically reifies any selection which serves as a source of transclusion or which is linked (by a relation among a set of types of relation specified beforehand) or according to still other criteria (in particular avoiding overlaps). The user will thus be able to avoid recreating a selection which had already been created on the same part of the resource or almost (in particular this is important to take advantage of the conduits of propagation of scores connecting this resource to the others).
- a handle titled "reified selection” - or any other distinctive means that we will assimilate here to such a handle - can be displayed at the selection level to allow it to be identified.
- a button or a menu option is offered in the toolbar to display (or alternatively hide) all the "reified selection” handles of a displayed resource, the purpose being of course able to select a pre-existing reified selection (if there is at least one).
- the selection is made conventionally by dragging the mouse so as to cover the selected part, the left button being pressed (this conventionally has the effect of highlighting the selected part); Then the reification itself is done by clicking on a menu option presented in the toolbar, or by pressing the right mouse button, which must first be positioned on the selection in question.
- the reification can be done directly within the framework of the very selection operation: by dragging the mouse so as to cover the selected part the right button being pressed (which will have the effect of highlighting the selected part) and by selecting the "Reify” option from the "context menu” (conventionally displayed when using the right mouse button).
- a "reified selection" handle is then displayed at the selection level to serve as a guide. It is useful to distinguish the reified selections actually used (in particular those which serve as a source for a transclusion or which are linked by relations being of a certain type among types previously specified) from other selections, and especially from those which do not not used at all. Indeed, the user will be able to more easily reuse those which are already used and thus avoid cluttering the resource in question. These can be distinguished by graphic means and, to lighten the presentation, under the control of the user, the system can automatically delete the reified selections that were not used at the end of a session or for example after a given period of time.
- Clicking on a "reified selection” handle has the effect of selecting the object it designates (and making the corresponding system highlight the corresponding selection, that is to say typically having "reverse” video "the part in question of the resource viewed).
- the system identifies and presents to it the closest reified selection (geographically) in the displayed resource ( however, this requires switching to a special mode).
- the system could automatically identify the most relevant reified selection (s), that is to say which correspond most closely to its "user profile” (as described in the "Personalization Method” section).
- the user can transpose part of an article viewed in Word by means of a drag and drop to a web page viewed in Frontpage.
- the system will offer to choose a transformation (in XSLT) from a set of transformations available for presentation at this location. Then the user can still modify the result of the transclusion interactively as already described. Change the result of a transclusion
- a query can therefore combine several properties, using Boolean operators.
- the network of conduits is an oriented network whose vertices are objects and the edges are conduits to which a numerical value called size is attached.
- a conduit between 2 objects an ability to propagate a relevance score from one object to another.
- the propagation capacity is called the size of the duct.
- a request is made up of a set of objects weighted by numerical values 34 .
- a positive value indicates a "score source” and a negative value indicates a "score absorber”.
- Each object distributes its score along its outgoing conduits (distributed according to their sizes).
- a score source produces score for itself.
- a score absorber spontaneously decreases his score.
- the method seeks to give scores to each object so that each object receives and creates as many scores as it destroys and gives, that is to say that we seek a situation of equilibrium.
- the query (all the sources and absorbers of score) describes the domain where the user wishes to obtain results (therefore the objects that the user wishes to favor or disadvantage), the conduits represent relevance relationships (a conduit of A à B means that if A is interesting then B will be interesting too, to a certain extent which is indicated by the size of this line).
- the result found by the method therefore corresponds to the objects which are relevant to the request, according to the network of conduits. Indeed, an object having incoming paths from numerous objects relevant to a request must also be relevant.
- xi is the score of the object.
- the exponent + represents the value after update.
- s; is the value of the source or the absorber of score for the object (zero if i is not a source or absorber of score).
- the conduits can be obtained by several means.
- a transclusion indicates a certain relation of relevance, even in the absence of explicit semantics; this is particularly useful in the case of hypertext links between web pages, because the system is thus able to analyze the web automatically, without any other intervention.
- the system can be extended, depending on the applications, with other “pipe installers”, that is to say functions which produce pipes between objects.
- conduits between objects which cite the same objects the size of which is equal to the proportion (weighted) of outgoing links in common.
- a difficulty is that it will be necessary for each type of semantic relationship to give the size of the conduit to associate with it, and for each installer of the conduit to give the weighting of its conduits vis-à-vis the other posers. These weights represent the importance in terms of relevance of these different kinds of conduits.
- each object When one wishes to obtain scores in an absolute way (without particular request), one can place a source of score with each object (thus with each iteration each object distributes a part - the same one for all the objects - of its score to all the other). This will have the effect of ensuring that each object has a non-zero score, and therefore of maintaining the differences between the different objects, as opposed to the case without sources of scores, where entire regions may end up with zero scores as explained more high, and therefore where the differences between objects disappear.
- This profile is in fact a weighted average of the interest of the user, the weight decreasing the more we go towards the past.
- the present interest can be estimated by considering the objects consulted by the user and the queries he makes (so when the user makes a query, the scores of the results will also be the scores of the objects in his present interest. also serves objects visited by the user, these can be considered as requests and the same processing can be carried out.)
- the weighting is carried out by making an average between the average interest of the user at the previous instant and the user's current interest.
- P (i) the score of object i in the user's profile, and p (i) the score of object i in the present interest of the user
- P (i) will be updated with s P (i) + (1-s) p (i), s being the weighting factor (constant giving the “weight of the past”; this value may depend on the information used to determine the interest In particular, a user request will leave less weight to the past than a simple page visit. 35 )
- An object can have optional children, so they should only be displayed if the system judges that they correspond to the user's profile. It can also have exclusive children between them, i.e. groups of objects whose one that most closely matches the user's profile will be displayed.)
- An object is said to correspond to the profile of the user when the score of this object in relation to the profile of the user is high.
- Each object has an identifier.
- Locally created objects have an atomic identifier, which is a whole number unique to the system.
- Each transclusion also has an atomic identifier, which is also unique.
- Objects seen through a transclusion have a composite identifier, noted A: B, where A (the head of this identifier) is the identifier of the transclusion, and B (the tail of this identifier) is the identifier of the object at the source of this transclusion.
- Parentheses are used to clearly delimit the head and the tail when necessary. In the absence of parentheses, the sub-identifiers extend as far to the right as possible. For example,
- a transclusion A is here considered on the one hand as a set of objects "seen through” A, and on the other hand to a set of modifications concerning these objects. These modifications include • modification or deletion of an object seen through A (therefore whose identifier begins with “A:”) • displacement of an object seen through A, whose parent before and after displacement is also an object seen through A. • creation of an object (locally created or seen through a transclusion different from A) as a child of an object seen through A. • displacement of an object seen through A as a child of object created or seen through a transclusion different from A.
- a particular case is as follows: when the user performs a transclusion, the algorithm, to perform this operation, will first create the transclusion but at this instant the latter n is not yet accessible (because no object seen through this transclusion is yet placed as a child of an accessible object.) The second step is then nothing more than a displacement of one of these inaccessible objects as a child of an accessible object.
- a polynomial simplification algorithm consists in replacing all the products of sums by sums of product, then for each x to group the terms in d x .
- the two forms therefore have the same density, as expected.
- Each object can have a set of sources, which is the set of objects of which it is the image by a transclusion, implicit or not.
- Each source is associated with the corresponding transclusion.
- 4: 3: 2 in the example above, has two sources, 3: 2 and 4: 2, through transclusions 4 and 4: 3, respectively.
- A is a source of B by the transclusion C
- the identifier of B is equivalent to C: A.
- Each object is associated with two types of information: its position and its content 36 .
- the position of an object is given by its parent and its predecessor (the predecessor being used only to determine the position of the object among the children of its parent).
- the notation ! A means that information was created locally by object A.
- Each object will store, in this form, the origin of its content and the origin of its position.
- the object is an element and its content is the "innertext"; indeed the attributes and the child elements are considered here as being child objects (contained in the object in question) therefore treated in their turn as objects each having a content and a position.
- the attributes present additional constraints, such as for example the fact that the algorithm will have to merge the same attribute coming from two different sources.
- the calculation of the origin of the position of an object is carried out in an identical way to the calculation of the origin of its content with the difference, of course, that the origins! Oj considered are the origins of the positions of these sources .
- the parent and the predecessor of the object will not, however, be equal to the parent and predecessor of O j , but to their image by the path T j: C j: So if the parent of O j is P then the parent of l 'object to calculate will be TCP, and the same for the predecessor. If the predecessor thus obtained is not a child of the parent thus obtained, then this information of predecessor will be ignored (and the object will for example be placed at the end of the list of children of its parent), [local 5]
- FIG. 8 presents an example of the behavior of this algorithm, for the calculation of the positions of the objects (since the calculation of the content is not detailed here, step 4 does not appear).
- the 5: 1 transclusion result also gives its position, in fact it is also considered displaced 38 , since its parent is not the corresponding by 5 of the parent of 1 (not shown in the diagram in order to avoid overload it.)
- Transclusion 5 specifies that 5: 3 is moved as the first child of 5: 1.
- transclusion 6 moves the objects 6: 5: 1 and 6: 5: 4.
- any source of information for this object will be the image of the same first source through a sub - all of these transclusions (or their images through a transclusion).
- the polynomial associated with a subset of these Ti is obtained if one replaces Ti by t 1 and one carries out the sum of all these terms.
- the subset Tl T3 gives the polynomial t + t 3 .
- One source has priority over another if the polynomial associated with the set of Ti which separates it from the object of which it is a source is greater than the corresponding polynomial of the other source, for t very large.
- the algorithm for constructing the object of differences will have to place in this object of differences the information that the root of the result of this transclusion is displaced.
- the terminator as the number that comes last in an identifier. For example, the terminator for 2: 3 is 3, the terminator for (4: 5): ((3: (8: 9): 5) :( 4: (7:11))) is 11, the terminator for 5 is 5.
- Ci If the different sources (Si is the source and Ci the path, Ci: Si is equivalent to O).
- Tn T (nl): ...: T2: Tl: S, where the Ti are transclusions of atomic identifier.
- S is the object at the very end of the chain, also atomic.
- the requested object is the image of another object by a transclusion
- the following objects must be recalculated with the local algorithm: • The object itself (in order to obtain its content) [global 1] • For each source (in the case of implicit transclusion), the images of all the descendants of this source by the transclusion corresponding to this source [global 2] • The set of objects created and moved by the transclusion [global 3].
- 4: 1 is obtained through a transclusion. We apply the local algorithm on 4: 1 to obtain the content [global 1]. 2. 4: 1 has only one source, 1, by the transclusion 4. We will therefore recalculate the image by 4 of all the descendants of 1, so 4: 3: 2, 4: 2, 4: 6, 4: 3: 5 and 4: 5 [global 2]. 3. 7 is the only object created or moved by 4, we recalculate it [global 3]. 4. The descendants thus obtained for 4: 1 are 4: 3: 2, 4: 2, 4: 6, 4: 3: 5, 4: 5 and 7. We continue the global algorithm on each of them [global 4]. 5. 4: 3: 2 is the image of an object by a transclusion.
- the local algorithm does not need to be called on it because it is already done [global 1]. 6.
- the set of transclusion pairs: source of 4: 3: 2 is 4: 3: 2 and (4: 3) :( 3: 2). We will therefore call the local algorithm on the descendants of 3: 2 seen through 4, then on the
- T2 has priority (closer) to Tj if i ⁇ j.
- T2 is closer and therefore more priority than T4. Therefore a path which borrows T2 and T3 will have priority compared to a path which borrows T4, for example.
- a path that passes through T3 and T4 will take priority over a path that passes through T2 and T5, because of T5 which has less priority than all the elements in ⁇ T3, T4 ⁇ .
- the present invention allows a user to create relevance relationships 40 between a first object 41 and other objects, in order to be able to find the first object simply by accessing at least one relevant object with respect to the first object.
- Said (or said) object (s) relevant to the first object can be, not only one (some) of said other objects that the user has connected (s) to the first object, but also: • one (s) object (s) having a relevance relationship with the first object, created by another user in a network of relevance relationships shared between these two users, • one (s) object (s) for which (which) the first object is automatically considered relevant by means of inference rules 42 which apply to the relevance relationships thus created, • one (or more) object (s) for which (which) the first object has a score of high relevance which was determined automatically by the method by assimilating the relations of relevance to capacities for propagation of relevance score from one object to the other (that is to say to conduits).
- the method uses conduits created automatically from the interrelationships and / or the content of the objects.
- the method automatically creates conduits, in particular 3 • between the cocitated objects 44 , • between the objects linked by hypertext links, • between the objects having distributions close to words.
- conduits are created in particular between web pages likely to interest users.
- conduits or relevance relationships between web objects and private objects (eg company documents) are created and thus allow the relevance scores of web objects (pages to be propagated to the latter).
- Web which are calculated automatically by analyzing the structure of the links and their content.
- Finding / discovering an object by accessing i.e. by visiting or expressly selecting
- relevant objects are done, for example, in the following scenarios.
- Tracing relationships between objects can be done in one of the following ways: • by explicitly indicating to the process the identifiers of the objects in question, or by first accessing a first object then by indicating to the process the identifier of a other object (to specify its relation to the first); • or can be done within a document, via a transclusion of each object that we want to link, that is to say by creating in a document references to the objects in question then by tracing relationships between these references in the document itself, using an editor; • or even in a mixed way (editor to object or object to editor).
- Figure 11 (which consists of a variant of Figure 2) illustrates such relationships presented (and made manipulable) in a typical specialized editor that we propose to use in a business intelligence activity on the Internet.
- Each block could represent an enriched transclusion, for example from a web page.
- By clicking on each of the arrows (which represent a relevance relation) the user can specify which semantic relation it is, and the given semantics will then appear when the mouse cursor is positioned on the arrow in question (this is also not illustrated in Figure 11).
- Any semantic relationship can be a relevance relationship and new relevance relationships (or conduits) derived automatically, semantics can be added manually or by means of user-configurable rules. The user can thus discover new semantic relationships, highlighted by the process.
- the result of the process is a set of new objects (new blocks are added to FIG. 11) which are effectively linked with the objects viewed by the user (arrows connect these new blocks with the existing blocks).
- the result of the method must be ordered first according to the user's wishes (for example, private objects first) and then sorted by relevance score (this method is described below).
- the process analyzes the web and calculates relevance scores for the pages. To do this, it calculates a network of conduits.
- a conduit between two pages expresses the fact that if the first is relevant (for the current request or in absolute terms) then the second will also be.
- the conduits also have a "size" which expresses the intensity of this propagation.
- the default conduit size between two web pages is the number of inbound links common to those two pages. It is possible to add (or enlarge) conduits following the links
- hypertexts 48 or from text analysis for example, a conduit is placed between two pages, the size of which increases with the resemblance of their word distributions), or by various other methods.
- the user can himself modify this network as desired, by adding / removing these conduits or by modifying their size.
- Process 4 continues inside the company's documents. For example: • The user can add a conduit from a web page to a company document, or from one company document to another. In general, a conduit can be placed from or to a reified selection of a document or page part.
- the user can perform a transclusion in a document whose source is a reified selection, which will also create conduits in both directions between the source and the result of this transclusion. • The user can set a conduit between two results transclusion, which will be replaced by default 50 a conduit between the respective sources of these transclusions. 51 • Conduits are placed between the Web and private documents according to their proximity to word distribution.
- selection will designate all the possible cases of reified selection of part or all of the content of a document or of a page 52 .
- a selection is therefore an object
- the user interface allows it to draw, between selections, relationships (as illustrated in FIG. 11) and to explain their meaning 53 ; these relationships generate conduits 54 .
- the user can configure the order in which the results are presented to him by default, according to the location (for example that his private documents are shown to him before the other documents of the company, or conversely that the documents found in the web be shown first) and score.
- the system can be placed in client or server mode.
- server mode it manages a server network
- client mode it manages a modified network which is a set of modifications made to the server network of a particular system.
- system in this document implies that it manages a single network.
- the user 50 may choose where the conduit will actually be placed (in each case or by reconfiguring the interface).
- the user can put a conduit from or to the result of a transclusion which by default will be replaced by a conduit from or to the source of this transclusion or its upstream transclusions if there is one ( cascade transclusions).
- the source and result of a transclusion are selections; the two ends of a conduit are selections.
- such relationships may indicate, for example, that a selection confirms / contradicts / causes / influences / explains / explains / translates / etc another selection.
- conduits are created according to rules that can be modified by the user.
- advanced users can be offered an API to define duct size calculation systems themselves, in particular according to the semantics of the content of the selections or the relationships between the selections.
- 55 See section "Request Handler" In client mode, the user creates and maintains his network, in particular by transcribing selections
- the network is maintained thanks to the fact that each conduit thus created is actually created in the network, and only one reference is inserted in the document in question.
- the network in which the conduit in question is actually created can be that of the system in client mode or directly that of the system in server mode.
- a user can make all or part of his network available to other users (his subscribers). When he modifies his network, his modifications will be directly visible and effective for his subscribers.
- a request representing a set of selections can itself be a node in the network.
- Conduits connect it to the selections having had the best scores for a previous execution of this query (their sizes being a function of these scores).
- the user can trace or modify relationships or paths from or to a set of selections (having constituted a request to the system).
- the query can be executed either by means of the relative score calculation algorithm expressed below, or by another method, in particular by the relative distillation method described in this report.
- each system manages a single network.
- part of the conduits in a network can be imported from another network and automatically updated from the latter 56 .
- Figure 10 an architecture 57 in graph structure where the Web is crawled by a basic system managing a
- Base network from which other systems (Company networks) 58 import conduits and add their own selections and conduits; and from these other systems, custom networks in turn import conduits that can be manipulated by users.
- the region denoted “CRAWLED” represents the part of the basic network resulting from the crawl of a subset of the Web of interest to a company; the region
- MUTUALIZED represents the part of the basic network resulting from the crawl of a subset of the Web of interest to two companies at the same time (which offers the advantage of sharing the crawling of this subset by the basic system) ;
- IMPORTED represents the part of the company's network made up of conduits imported from the basic network; the region
- ADITIONAL represents the additional conduits connecting the company's resources to each other as well as to web pages in the IMPORTED region.
- conduits and scores are generally neutral and uniformly applied in the basic network as well as in company networks, while they can be special (i.e. personalized) in personalized networks. Some query results can be delivered to custom networks (as introduced above).
- conduits from one network can be imported from any other network 59 .
- certain conduits of the network managed by a given system 60 can be references to conduits of networks of other systems (their sizes thus being traced
- Part of a network can be an enriched transclusion of part of another network.
- the user of a personalized network potentially benefits from all the enhancements made upstream in the graph, which may for example include selections in the form of advertising.
- a user can contribute modifications he has made from his network, upstream in the graph, and the owner of the network upstream from the transclusion in question can accept or not this contribution. Users can thus communicate relevant resources.
- Each system is able to estimate for itself the knowledge it has of the domain of each selection that is part of a query (this is described later in the section “The Distiller”). He can thus decide to delegate all or part of a request to a system which has the knowledge in question and with which it is connected in Peer-to-Peer (as described below).
- inertia a is a constant between zero and one. 0 gives none inertia (risk of oscillation) and 1 prevents any variation (large values slow convergence and 1 prevents any convergence)
- the well-known “PageRan” algorithm propagates scores only along hypertext links. Propagating scores along the conduits, for example if they are calculated from co-quotes, promotes selections that would not otherwise have been offered.
- a selection is highly cocited with a selection having a good score and in the second case several selections with a good score have a link to the same selection.
- a mixed algorithm that is to say to propagate the score both along the co-quotes and links, will discover the pages of interest in both cases.
- conduit makes it possible to combine several methods of searching for relevance relationships (including manual modifications) in order to obtain better results.
- the network of conduits is independent of requests 69 . Users can choose to share the same network and all the modifications made to this network by different users can be used at the same time.
- transclusions The exchange of networks between users is facilitated by the implementation of transclusions: a user can exploit the network of another user by performing a transclusion in a document in his system, and he can then modify it, reduce or enlarge it to suit its needs, simply by editing the document containing the result of the transclusion.
- the equations are linear in s (ie the scores obtained for the linear combination of several queries will be equal to the corresponding linear combinations of the scores obtained for the basic queries) which means that queries can be broken down into more basic queries which can then be recomposed differently. Thus one can calculate and memorize these elementary requests then obtain the composite results without having to re-carry out the calculations.
- the scores x t for R 3 are the average with the same weightings of the x, - correspondents of R ! and R 2 .
- Linearity is used in particular in the presentation of the results to the user and in the Peer-to-Peer delegation process described below.
- Each network represents the relevance of the selections each compared to each other, for a user or for a set of users, whatever their requests. However, different networks (for different interests) can be created by (or for) " ⁇ my users. a set of “authority” selections with high absolute scores.
- the score of a selection for a given request can be obtained by calculating for each selection in the request the amount of score x a that it would send to each selection authority, then averaging the scores x a weighted by the scores obtained by these selections a. So, by precalculating for all a the distributions of scores x a and x a , page scores can be calculated very quickly.
- navigation context can be used when giving relevant selections to the user.
- the navigation context is the set of selections that the user has seen or selected with a weight describing the importance it has in the present context.
- the context is taken into account, at each user request, by carrying out a weighted average between the context and his request before processing it.
- ⁇ is the set of score sources, i.e. ⁇ 2 -> X; 3 ⁇ -> ⁇ (as explained before, their sum must be worth 1).
- the interface allows you to request that the relationship between two selections be displayed in a document, whether it is a semantic relationship, a path imposed by the user or an implicitly calculated value.
- the interface allows you to perform a transclusion, the result of which is placed in a document.
- the interface will superimpose the relations starting from or arriving at the source (and if necessary from the source of this source and so on) and from or to result of this transclusion.
- the user can then modify the relationship in the document, and the change will be automatically reflected in the network.
- a reference will be sent to the server so that the latter can take it into account in the score calculations.
- the relationships that the user creates (or modifies, deletes, etc.) will be stored in the system, whether in client or server mode. If in client mode, the interface offers a way to send these conduits to the server (so that they are used for other client systems on the same server).
- This interface can be integrated into a standard editor such as Word.
- the user can also request to see the entire network of relationships (both those added by the user and those calculated automatically) in the vicinity of a selection.
- the relationships from or to the sources, of a transclusion will be “descended” in the graph presented.
- the user can add / delete semantic conduits and relationships.
- the user can request to see only certain relationships, i.e. activate or deactivate the display of relations obtained by subscription (selectively subscription by subscription), activate or deactivate the display certain types of relationships semantics, and so on, all the means of calculating the sizes of conduits can be selected or not to give rise to the display of relations.
- the user can configure the way in which the default sizes are calculated.
- the interface allowing to do this is presented in the form of a list of ways to calculate the sizes of conduits (cocitations, hypertext links, conduits given explicitly, subscriptions, etc.), on each line (except in the case of subscriptions and explicitly given conduits) the user can indicate the weighting and if it is not zero activate or not the display of the corresponding conduits.
- an option makes it possible to make them effective or not for the calculation, and here again if they are active an option makes it possible to display them or not in the representation of the network. More concretely this can be achieved with a two-column display, the first allows to weight (or activate / deactivate) the corresponding calculation and the second allows to display or hide the relationships in the representation.
- the user can select a set of selections (transclusions or not) as a request and ask the system to suggest selections relevant to this set. He then receives a list of selections which he can use to enrich his document.
- each selection is associated with a path which is a list of names such as "/ companyA / divisionB / departmentC /”. Selections found on the web will have a path such as "/ web / http: // ".
- the system represents in the interface in the form of a tree all the nodes existing for example in the company, and the user can choose if he wishes to see only the nodes which contain results.
- the user can open or close the nodes and reorder the children of a node and the system reacts by presenting the results in the same order as the nodes in the tree and by sorting according to their scores the results found in a closed node .
- the modifications carried out on the tree are memorized, that is to say that the tree will be presented in the same way at the next request.
- the user can also request that only the results found in certain nodes of the tree be returned to him (he will notably be limited to the paths containing selections to which he has access).
- the system offers the user tools to manage the context (for example to delete selections, to reset it, to temporarily deactivate it, to save it in order to resume it later, etc.).
- This part of the system explores the network of hypertext links on the web at the request of the other modules. It will also periodically check whether the sets of incoming and outgoing links of the selections have changed, and more often check the selections receiving requests from other modules.
- the scoring algorithms described above have the disadvantage that when the pages of a set are strongly linked to each other, any page outside the group will have a bad score relative to the pages of the group.
- Page 1 should get a good score relative to page 2 because, apart from the navigation links, all pages pointing to 2 also point to 1. However, the equations will only see the fact that, among the eight pages pointing to 2, only three also point to 1.
- the internal links to the site link very close pages (because the two ends are linked in common by many pages) while the others link pages of little proximity (few pages, in fact none .in the drawing) point to both the source and the target of this link.
- the vertices of U are copies of the vertices of AN, i.e. pages.
- Each edge (link) is associated with a weighting which is equal to the complement (1-x) of the proximity (homogeneity) of the two linked pages, calculated in the network U.
- this network is lazily built , that is, nodes and links are created when they are requested.
- the cardinality of a set of links in AN is replaced by the sum of the weights of these links. (For example we replace the number of reverse links by the sum of the weights of the reverse links).
- the sum of the scores for reverse links is replaced by the sum of the products of the scores and the weighting of the corresponding link.
- the cardinality of the union of two sets of links is calculated as follows. The contribution of a link present in only one of these sets is equal to its weighting. The contribution of a link present in the two sets is equal to the logical sum of their weights, i.e. l- (l-a) (l-b).
- the cardinality of the intersection of two sets of links is the sum, for all the links present in the two sets, of the products of their weights.
- This module is responsible for calculating the sizes of the conduits between selections (depending on the configuration by the user, by cocitation, along hypertext links, by text analysis, by translating semantic relationships, by taking a value imposed by l 'user, or conduits obtained by transclusion).
- the system will memorize in the network the conduits obtained by transclusion, and these are updated when the user views the documents containing these transclusions.
- the system will choose, in order of priority: 1. A pipe size or a semantic relation given by the user 2. A pipe size provided by transclusion 3. The pipe size calculated automatically ( cocitation summer)
- this module In addition to asking, the sizes of conduits, we can also ask this module how a particular conduit has been calculated in order to display it in a document (for example what type of semantic relation has been placed or if it is is a fixed value imposed by the user).
- the system can be configured to introduce artificial nodes into the network, each representing a request. Bidirectional conduits between the request and the resulting selections (those with the highest scores) are then laid, the sizes being a function of the scores for the request in question.
- conduits with special requests, such as those implementing a “relative distillation” method described below.
- this module When the user has chosen to publish part of his network, this module will be responsible for constructing the data to be sent, i.e. all the sizes of conduits either themselves obtained via a transclusion or explicitly provided by l 'user.
- This section describes an accessory component of the system allowing it to be used for web monitoring.
- the system must be able to suggest pages that have just been created, even if the relevance of the page based purely on hypertext links seems low. Indeed, if the page has just been published on the web 74 , it is likely that it is known to few people and that consequently few pages point to it, even if in reality it is a very good page. It is therefore necessary to calculate its relevance in another way, so as to give them a chance to appear among the suggestions to the user.
- Each page is associated with a state which can be:
- One scalar product of two distributions is equal to the sum for all the words of the products of the frequencies of appearance in one and the other document. The number will be close to one if the documents use the same vocabulary and zero if not.
- W represents the set of selections
- x (p) represents the absolute score of the selection p
- x p (q) represents the score of the selection q relative to p.
- r (p) x (p) - r max (max (x ⁇ (p), x p ("))), which means the absolute score minus (with a weighting ⁇ ) the greatest relative score involving p and a selection of A (which represents the “distance” of the candidate selection p with those already taken), ⁇ is a constant.
- a small value of ⁇ indicates that we prefer to have selections with a good absolute score and a large value indicates that we prefer to have one of the selections distant from each other.
- A is initially empty. Then as long as we wish to make the set A grow, we add to it the selection of W having the greatest representativeness.
- ⁇ . (I) be the score of selection i for the query consisting of the only selection y, calculated using the algorithm described in the introduction.
- the score will give too small a value but it is not important because it is assumed that the selections of A are chosen so as to be in the points (of the domain of interest to the user) easily affected by score streams in the conduits.
- the distiller is therefore responsible for memorizing and updating the values of the functions x a and x a for each selection of A.
- a request to this component consists of a set of selections, possibly a set of modifications to be made to the server network (this is used by the client mode described below), as well as a set of filters on the selections to return (which will be used in particular to return only the selections to which the user has access), and it responds with all the selections having the highest relevance score for this query (the score for each selection returned is also returned).
- the system can be used in two ways, either it does all the calculations itself (server mode) or it uses another system by providing the modifications (ie modifications / additions / deletions) that the user contributed to the other system's score propagation network (client mode).
- this module will simply send the request back to a server, along with all the modifications made on the score propagation network.
- this module In server mode, if the request does not request modifications to the score propagation network, this module simply calculates the function x R defined above. When a filter on selections has been given, only the scores of selections satisfying the filter will be calculated
- this module will modify the request so as to simulate the effects of the changes made to the server network.
- This algorithm works even for selections which, in the server network, have no incoming or outgoing path, unlike the modified network, which will occur in particular when a user of the client system has created selections for which he is the only one. to have access and therefore for which he is the only one to have put conduits. Since it itself depends on the result, this query will be iterated approximately, that is to say that you must have an estimate 80 of the result of the query to calculate the modified query, and that the results of the modified request are used to calculate a more precise modified request, until convergence 81 of the x values which can then be returned in response to the request. The closer the first estimate of the query is to the true value, the shorter the convergence will be, however whatever the initial values the algorithm will tend towards the same value.
- the request will consist of selection a.
- the score of q for this query is q s 0.1988, and so on.
- the diagram in Figure 24 represents all the data managed by the system as well as the dependencies which connect them.
- rectangles represent classes.
- a name inside a class represents data attached to each instance of the class.
- the asterisk * represents multiplicity.
- An arrow represents a dependency between two data (called source and target of the dependency).
- a dependency entirely contained in a class links attributes of the same instance of the class.
- a symbol • or! at one end of an addiction indicates the strength of the addiction, weak or strong respectively.
- a dependency is strong if its triggering makes the target data inaccessible until its update is completed, and weak if the target data remains accessible during its update
- the force symbol is on the source side if it is a push dependency, which means that the target is updated when the source changes.
- the ® symbol placed on a dependency indicates that the dependency is only checked if the last update of the target is old enough.
- a dependency whose source is the symbol indicates that the update of the target is carried out automatically at regular intervals.
- a dependency shown in dotted lines indicates that the update is done synchronously, that is to say that a modification of its source does not end until the update of the target is completed (and can be implemented by a simple function call, unlike the other dependencies which must be implemented by separate threads).
- the client mode system has no authorities and all of its requests are delegated to its server. In addition, it works on the same server network as its server and it is therefore not necessary for it to calculate the conduits obtained automatically: it can download them from the server. This leaves only the manually defined conduits, the semantic relationships and the subscriptions to manage.
- the system in server mode offers a function to make all the known pages grow as well as the set A. This operation must typically be carried out at startup, because at this moment the set A and the set of known pages are empty .
- the user gives a set of selections from which the extension will be made.
- the system then performs the relative algorithm for calculating the scores 82 starting from this set, and extending it along the conduits starting from selections having the highest score (which, via the dependencies, will cause a search for reverse links and before).
- the relative algorithm for calculating scores and the extension of the network are thus executed in parallel.
- border here means selection whose the outgoing duct set has not been calculated.
- the system will then be able either to destroy a possible set A already existing and to launch the algorithm of selection of the set A described in the section “The distiller” above, or simply to add new selections in this set, by resuming the algorithm from the set
- the error on the result and therefore the knowledge of the system on the request can be measured using the terms ⁇ 3r a ( z). Note that if the request is accompanied by a modification of the network, it is important to first calculate the modified request to take these modifications into account before calculating these terms.
- the user who is authorized to cause an extension of the network, requests suggestions for his document.
- the request modified by these three conduits will have a weight s not zero on the two web pages in addition to the two transclusions (see the algorithm in the section "The request handler"), and if no extension is made, only suggestions starting from the first web page will be given
- the user will define the domain he wishes to remove from his network by making a request, for example with a document containing transclusions, or with a set of selections given directly, etc. He can then tell the system to delete the authorities that have been used a lot to produce the results, ie the selections of A for which ⁇ R. • x a (i) is large enough (the user can either specify a threshold or an isR proportion of authorities to be deleted).
- the threshold we can display a graph indicating the proportion of authorities that would be deleted according to the threshold. If the domain he gave is tightly closed (i.e. weakly connected to the rest of the network) the graph will present a flat around the threshold to be chosen (because the threshold must be lowered a lot so that authorities in another area begin to be affected by their tower). This is illustrated in Figure 26.
- a peer-to-peer system can be used to delegate parts or all of the request to other systems.
- the user can link his system to other systems, thus forming a peer-to-peer network.
- the “neighboring” systems are those which are directly connected by this network. When the system chooses to delegate part of a request to other systems, it will ask its neighbors if they know a system capable of handling all or part of this request, that is to say which has knowledge values. ⁇ x a (i) large enough. ae
- a system If a system is able to handle part of the request, it informs the system where the search started (by providing it with its knowledge values for these selections), and queries its neighbors for the part of the request it did not know.
- the request will flow to the neighbors of these neighbors and so on until for all selections of the request a system has responded, or until the entire network has been traversed without success (which is detected if no response is received after a certain period).
- the first system (the one that initiated the search) can then distribute the request between the different systems that responded, then, thanks to the linearity of the algorithm, the different results can be recomposed directly.
- systems can memorize a table of the requests which most often reach them, by associating with it the system which had responded positively. This will allow requests to reach systems capable of handling them more quickly.
- each Distiller will ensure that the scores x a and 3c a are updated for their portion of the set A (according to the dependencies of the diagram in Figure 27).
- Another aspect of the present invention aims to propose techniques in which a user can modify an original page - he can for example associate annotations to it - and save the modifications as a page derived from the original page.
- the invention aims to determine, by exploiting the links which are found in the pages of the Web, the degree of relevance of the pages in relation to each other and in relation to the browsing context of the user.
- the invention aims to present the user with the most relevant derived page as well as annotations associated with other relevant pages and links to other relevant pages.
- Another object of the invention is to allow an annotation to be for example a link to an information resource such as a file, so that the user can thus find information resources simply by placing themselves in their context of relevance: when the user navigates and gets closer to the context of the resource he is looking for, we aim for a system which spontaneously suggests it to him.
- the invention thus aims to use the system constituting, for the user, a
- a first system implementing the method for selectively accessing one of a plurality of resources from a starting resource, characterized in that it comprises the following steps: (a) developing scores relevance of the starting resource and other resources using a relevance determination mechanism, said other resources comprising independent resources and resources derived from the starting resource and / or from these independent resources, ( b) in connection with the access by a user to the starting resource, whether or not providing the user with information on the existence of another resource or access to said other resource, as a function of said relevance scores.
- this system selects or not the content of a another resource to be presented, depending in particular on the relevance score of said other resource.
- support groups Users have declared a number of interests, known as "support groups," to the system. Each support group is initially represented by a set resource identifiers (typically URLs of popular web pages). Let us call R this set. We define 83
- R ⁇ + ⁇ by the set of resources having a link to at least one R "+ resource.
- Each R " + resource is associated with an authority score.
- the relevance score of a resource 86 for a given support group is the authority score 87 thus calculated for this resource.
- the relevance score of a resource P for a given support group can be determined more simply by counting the number of times that P is quoted 88 (by the resources of R " ) with the resources of R characterizing this support group 89
- Each resource derived from a 90 starting resource is constructed • by reproducing (and possibly by modifying) a starting resource • by inserting into any resource a view 91 (possibly modified) of a starting resource or an element a starting resource.
- the starting resources are linked by directional links to form together a starting oriented graph.
- the starting resources are for example web pages and the starting oriented graph is then the Web).
- the system creates a virtual link - directed to said derived resource (L5 directed to P7) - starting from each resource citing a starting resource (P2) having served to construct said derived resource.
- a first page is co-cited with a second page if there is a third page which has a link to the first page and a link to the second page.
- a resource can be derived from several starting resources at the same time, for example it can contain several views of different starting resources.
- the system creates a virtual link (L3) - directed to said derived resource (PI) - starting from each resource citing an indirect starting resource (P3).
- Figure 29 illustrates the inheritance of real and virtual links, as part of an example showing nested views.
- the page P4 contains a view of the page P3, this view itself containing a view of the page P5 as well as a view of the page P6.
- the view of P5 takes P5 entirely, it contributes (to page P4) the virtual link L1.
- the view of P6 contributes L2 and the view of P3 contributes L3.
- the page P4 inherits 93 from the links L1, L2 and L3.
- the page P2 contains a view on the part of the page P4 which contributes the virtual links L1, L2 and L3, this view in turn contributes the corresponding virtual links (also denoted L1, L2 and L3).
- page P7 contains a view of P2 (taken entirely), it inherits all the links (real or virtual) directed to P2, namely Ll, L2, L3 and L5. Furthermore, the page PI has a view of part of the page P2, this part being a view of the page P3 taken entirely and therefore contributing to its link L3. PI thus inherits the virtual link L3 (via P2). However, PI does not inherit from the other links of P2 (L5, Ll and L2) because neither it reproduces P2, nor a view that it contains takes
- the system thus constructs a “virtual derived graph” formed from the starting oriented graph and virtual links.
- page is thus meant “resource” (of any kind) to which a link can be directed (so that the resource is activated when the user clicks on said link).
- This mechanism is based on the notion of set of link sources for an element 94 .
- a page A is a source of links for an element B if any new link (real or virtual) pointing to page A also points (in the form of a virtual link) to B (and therefore to the page containing B as well than to all views containing B), as described above.
- Any element can have sources of links but only one page can be a source of links.
- a page A is a direct link source of an element B if it is a link source of B and that there is no page X such that X is a link source. of B and that A is a source of links of X.
- the extended set 95 of inbound links on a page is thus equal to the union of the actual inbound links on that page and the union, for all direct link sources, of their extended sets of inbound links.
- a derived resource inherits a link (virtual or not) from a citing resource and directed to a cited resource, means that for the system a virtual link exists (implicitly) from said citing resource to said derived resource.
- extended links we mean real links and virtual links. The construction of these extended sets is therefore separated into 1. the construction of these sources of direct links and 2. the inheritance of links proper.
- each instance of the system has a function returning the set of direct link sources for a given element.
- This function will return the union of all the pages of which a (full) view is contained in the requested element and sets of direct link sources of the parts of pages whose view is contained in the requested element.
- the set of extended links is then calculated as defined above, from these direct link sources.
- Figure 30 shows an example of eight pages.
- the first (PI) contains an entire view of the second (P2) as well as a partial view of the third (P3).
- P2 has an entire view of P4 as well as P5.
- the part of P3 seen by the second view of PI contains whole views of P6 and
- P7. P3 also contains a view of P8.
- the sources of direct links to PI are P2, P6 and P7.
- the extended set of links from PI is the union of the actual incoming links to PI with the extended sets of links from P2, P6 and
- the system selects or not another resource to present, according to the relevance scores.
- a relevance score was assigned - explicitly or implicitly - to each resource for each support group existing in the system. Recall that in the case where for a given support group the score has not been explicitly assigned, it is considered to be zero; the system knows in advance what resources whose score is not zero: those who belong 97 to the set R "of at least +
- the system selects or not the content of another resource to be presented if necessary in place of (or in relation to) the content of each view, according to the scores relevance.
- the selection of the resource P t most relevant to the view in question is then based on the logical sum (or the maximum) for j of the product of the score of this view for a support group E j with relevance score XEJ (PI) -
- the browsing context represents the user's current interests when browsing and visiting resources one after the other.
- a user's browsing context is defined by associating a score with each support group. You can initialize the navigation context with a score of 1 for all the support groups to indicate the absence of context. To update the navigation context, when a new PQ starting resource is visited by
- the user has the means, for a particular view, of indicating whether or not he wishes the view to be replaced by the system (if the user does not specify, each view will follow the default behavior of the system).
- the selection of said other resource P, the most relevant with respect to the starting resource Po, taking into account the navigation context, is done as follows: If X E J (P ⁇ is the relevance score of P, - compared to the support group Ej, the system selects the resource P, - whose relevance score in relation to Po and to the navigation context, calculated as being the logical sum 106 (or the maximum) for, / ' of K E j -XEJ (PO) -X E J (P ⁇ , is the highest.
- P t Information of the existence of P t is signaled to the user 107 if his score Si is sufficient, or the system can be configured so that (in particular if the logical sum for j of KEJ -XEJ (PO) -X ⁇ jfPi) is greater than the logical sum for./ ' of K E j -XEJ (PQ) -XEJ (PO)) Pi can be directly presented to the place of P ⁇ . 108
- Each resource created by the user is associated with an editing context D.
- his editing context is initialized to the browsing context of the user at the time of this creation.
- its new D + editing context becomes the weighted average of the old D editing context and the current K navigation context (when the new
- D + KK + KD, where K is a number between 0 and 1 representing the weight of the present compared to the past.
- the user will for example visit a page of an online book sales site and decides to monitor an element of a page (PI) presenting science fiction books. Later, when he visits another page (P2) which is relevant to the same field (of science fiction), the system presents him with the page (PI) of the bookseller whose element he had selected to monitor. However, the latter (PI) is only presented to it if the content of this element to be monitored has changed since the last time the user visited it.
- a view of a page (P3) accessed by the user reflects the content of a page
- the system offers the user a means of declaring that he has already seen a page (and that he therefore does not want the system to spontaneously offer it to him unless its content has changed).
- the system regularly uploads to the server all pages "viewed" by users and compares them to their previous downloaded version. When the system observes a change in a page, it will record with this page the date when the change was observed.
- the user can specify particular page elements whose change must be monitored.
- the system stores in a table the list of elements to be monitored (globally for all users) for each page already viewed, with for each element the last date when a change was detected 110 .
- the system regularly uploads to the server all the pages containing at least one item to monitor and compares them to their previous downloaded version. When the system observes a change, it will record the When it is a question of presenting an "other page" (more relevant) to the user, the system will select if necessary (according to the scores) another page in which at least one element that the user wanted monitor has changed since the user last viewed the page (or the item in question specifically).
- Each modification of an original page is shown to the user in solidarity with the page in which said modification was saved, except for the annotations 111 which can also be shown autonomously (ie adjacent or superimposed on another page displayed). 112
- the system is capable of presenting relevant annotations 113 , in addition to the methods already described.
- these annotations can in particular: • be displayed adjacent to the displayed page, • occupy spaces on the page reserved for advertising, • position themselves according to specifications given by the user when the annotation is created , • or be arranged in a special way specified or chosen by the user (by selecting from display configuration options).
- the user selects part of the page (by dragging the mouse there with the button pressed) • and / or provides the system with one (or more) comment (possibly containing a link ), • and optionally gives a set of keywords (or a display position).
- a derived page (by modification of the original page) containing this information is then created.
- the system searches the page for the occurrence of one of these keywords and displays the selection and / or the comment adjacent to the position of this keyword in the least intrusive way possible: for example, the keyword is simply underlined and the annotation appears when you bring the mouse cursor over it (by roll-over).
- the system is able to select only annotations whose content has changed since the last time the user saw them (as described in the section "selection of resources whose content has changed").
- the system When a user declares to have seen a page (or more precisely, an element under surveillance), the system will memorize the date of this instant, which makes it possible to know if the element has changed since the moment when the user saw. Thus the system is able to display only pages of which at least one element under surveillance has changed.
- Annotation is implemented as a special case of modification of a page.
- each annotation associated with a page is recorded as part of a page derived from this page (ie derived by reproduction / modification).
- Creating an annotation can consist of simply highlighting part of a page.
- the user selects part of a page (by dragging the mouse over it, the button being held down) and declares to the system that it is an annotation associated with this page.
- the system then creates a page derived from this page, in which the location of this annotation in the page is specified.
- the user can also modify the content of the annotation thus created, or even create any annotation containing new information, for example a link on another resource (see the last paragraph of this section).
- Said derived page created then contains in addition these modifications or this new information.
- annotations contained in pages that are relevant to the current page visited and to the context By clicking on an annotation with the right button of the mouse the user can (select in the contextual menu the option allowing him to) view the entire page containing this annotation 114 .
- An annotation can be simply textual, or visual or audible, for example an oral message or a video (or have any other effects on the senses) and can include one or more clickable link (s) by l 'user.
- annotations are able to include executable code directly and thus allow to extend the user interface.
- An annotation can contain a link to a resource 115 .
- the annotation could consist of an icon representing a document (and containing a link to it), an icon that the user associated with the page by dragging and dropping (from this icon) from his desktop.
- the system offers the option of downloading (to the system server) the resource at the end of this link, so that, when the annotation containing this link is presented, the user can automatically return this resource on his client computer and open it directly, simply by clicking on it (as he usually does to open a document).
- I (E) is the cardinal of the intersection inbound links from the pages of E, U (E) of the meeting, S (E) the cardinal inbound links from the page that counts the least, B (E) from the one that counts the most, constant.
- the introduction of the weighting by ⁇ is necessary because otherwise the equation does not make a difference between the case of a page having few inbound links but all of which are inbound links from the other pages of the set (should give a high homogeneity but gives a low value) and the case where all the pages have a lot of incoming links but only a small subset is common to them (the equation correctly gives a low homogeneity).
- the correction with the weighting by ⁇ increases the score in the first case (because the smaller the ratio the stronger the correction).
- the factor ⁇ indicates the strength of the correction. The larger it is (maximum 2) the stronger the correction. 0.6 is probably a good value.
- Equation by the reasons to love. where p (S) is the ratio between the cardinal of the union of the incoming links of pages of S divided by the cardinal of the workspace (the set of pages which we consider to have been able to point to a page of S, that is to say that they know). Since it is not possible to obtain the exact size of this workspace, we will generally take all of the pages known by the system.
- a pivot score and an authority score are associated with each page and the aim of the algorithm is to find values for these scores such as 1.
- the pivot score of a page is equal to the sum (except for a proportionality factor ) the authority scores of the pages to which it has a link 2.
- the authority score of a page is equal to the sum (to the same proportionality factor) of the pivot scores of the pages which have a link to it.
- R is defined by the set of pages having a link to at least one page of
- Each page of R ' is associated with a pivot score.
- Each R '+ page is associated with an authority score.
- the aim of the algorithm is to find values for these scores such as 1.
- the pivot score of a page is equal to the sum (except for a proportionality factor) of the authority scores of the pages to which it has a link 2.
- the authority score of a page is equal to the authority relative to R for that page.
- the system When the user requests to modify a page using an external tool, the system will create a derived page 117 .
- Legacy XML contains all the raw data that has been created for a site
- XML here replaces the“ current version ”described in the first part of the report). For example, in the case of a page containing a view towards another page of the site, the contents of these two pages are in XML legacy, but not the fact that the first contains a view towards the second.
- the "XML of the differences" (it is the equivalent of the object of the differences described in the first part of the report), contains all that is missing in the legacy XML to describe the site completely, that is to say does not contain any content (text, etc.) but rather everything that is reference between elements, the location and the reference of all views. It will contain the derived pages and a description of the differences (hence its name) present in the derived pages compared to the original pages 118 . The structure of these XML files will be described in the following sections.
- XML file in particular for XML legacy, can be stored and organized in various ways, not necessarily in the form of separate XLM files, for example by grouping them all in a single file, under a same node, or in an XML database.
- this section describes how to build a description of a page derived from a version modified by the user (using any commercial editor) but a specialized editor, allowing in particular to create views, can also modify these structures.
- page derived from a page X designates only a modified version of X (and not a page containing a possibly modified view of X).
- Either the referenced element has a unique identifier, and the reference is completely defined by this identifier.
- the difference XML describes the dynamic part of the system, in particular everything that is referenced. It describes what data to use and how to modify it in order to build the structure
- Each node in the differences XML corresponds to a node in the resolved structure and specifies
- the first information is specified using the name of the element and possibly a ref attribute which indicates a data source.
- the differences XML file can contain the following elements 119 : • deported: This means that the content of the element must appear as a copy of the element pointed to by the attribute ref (with all children) • imported: This state is similar to deported, except that the element is a version derived from the source (pointed to by ref), so it can be a modified version of the source (ie in addition to ref, it can be defined by modifications to bring to the source). • created: Indicates that the element was created from scratch by the user. It contains a ref attribute indicating where to take the element in an XML legacy. (All children of the node pointed in the legacy XML will be taken with) • rejected: Indicates that the element should not be displayed.
- the second information (on the location) can be defined as follows: • Using a reference of the replacing attribute: If a child of an import has this attribute, the element corresponding to the source of the import containing this element will be replaced by that one. In particular, if the element is in the rejected state, this attribute means that the element pointed to by replacing must be deleted in the resolved structure (a replacing attribute always refers to a child of the most import source. close containing the element having this attribute) • Implicitly: If A immediately precedes an element C, in the resolved structure it will also immediately precede this element C. If an element A is a child of an element B, this means that in the resolved structure element A will also be a child of B.
- markers are just references to elements from the source of an XML import or legacy (a marker always points to a child of the reference nearest created or imported node containing this marker)
- Figure 31 shows an element 10 being an import of an element 1.
- Element 1 has a child 11 which itself contains children 2, 3 and 4, and element 3 contains children 7, 8 and 9
- element 10 contains a child (marker) pointing to 3
- this marker contains an element (12) for example in the imported state followed by a marker pointing to 8.
- the resulting structure (see Figure 32) is therefore as follows: 10 has a child 10:11 which itself contains three children 10: 2, 10: 3 and 10: 4, and 10: 3 contains four children 10: 7, 12, 10: 8 and 10: 9. Note that the element 10:11 is missing from the XML file even in the form of a marker. Finally, if an element must replace an element in the source of an import while being placed elsewhere (the new location is implicitly specified), the reference to the element to be replaced is in the movedRepIacing attribute and replacing n is not present in the item description.
- Each XML legacy defines an XML structure without references, which can be placed as is in a resolved structure (in fact all the elements of a resolved structure will be found either in an XML legacy or in an external (html) page).
- All the elements of an XML legacy will preferably contain an identifier in order to allow XML differences to refer them, for example to indicate where to place a view in this structure.
- the P page without the view will be in an XML legacy
- the paragraph added by the user will be in another legacy XML. Indeed it is not possible to place the new paragraph and the rest of the page in the same XML legacy because they are separated by nodes from elsewhere (the source of the view).
- Figure 33 shows an example of a small website illustrating the role of the different files.
- the replacing attribute only means replacing a node (without its children), it is not necessary to make a copy of 4 (and if 4 changes in the original page in the future, the changes will be reflected in the modified version).
- Figure 34 shows what happens if the user moves 3 as a child from his div node:
- the moved element is placed at this location (if 2 had not been modified, it would have been necessary to create a marker for 2 at the location of this created node.
- Figure 35 presents the case where the user creates elements (for example a paragraph containing an image) inside this element 3.
- markers As already said briefly, a marker always refers to an element of the closest import or creation, unlike references of moved elements which apply exclusively to the nearest import (in fact, to move an element in a structure created, just move it into the XML legacy directly).
- the system makes it possible to create views on pages to other pages. From an XML point of view, this amounts to adding a deported node to the location in question in the XML legacy.
- the system will create a derived page (therefore an import) from the source of this view, containing the modifications made by the user, and change the definition of the view to point it to this new version derivative.
- the user has made modifications on a web page and the system must now build the definition of this derived version.
- the elements of the original file all have a unique identifier, and the system considers that these attributes are preserved when the user makes modifications to the elements.
- placing an element in a certain state means creating an XML element whose name is that of the state in question. Indeed, a production of this algorithm will always go to the XML file of the differences, because it is an import.
- the first step is to establish a table indicating, for each element of H, the element or elements of H 'having the same identifier, then to build the set of elements of H' which either do not have an identifier or have one who is absent from H.
- the second step is based exclusively on the structure (ie which node is the successor / parent of another) and on the correspondences established in the previous step. • Any element of H 'found in case A is placed at the root of the XML structure as a rejected element.
- the element For the elements found in case B or C, the element must be compared with that of the original document (H), that is to say its internal text and its attributes. If this content differs, the element must be placed in the created state and its replacing attribute (or movedReplacing if the previous step had placed it in the moved state) must be pointed to the original element. The new content of the element must be placed in a new XML legacy and pointed to by the ref attribute. Otherwise, if the element was placed in the moved state in the previous step, leave it in this state. Otherwise, if the element had not received a status, it can be deleted from the structure.
- H original document
- the element must be placed in the created state and its replacing attribute (or movedReplacing if the previous step had placed it in the moved state) must be pointed to the original element.
- the new content of the element must be placed in a new XML legacy and pointed to by the ref attribute. Otherwise, if the element was placed in the moved state in the previous step, leave it in this state. Otherwise,
- the parent of an element D is also in case D, they can share the same XML legacy, and only the parent must be present in the XML of the differences. If the predecessor or a child (1) of an element D (2) having been thus hidden in the difference structure is not the case D then it is necessary to create a marker pointing to 2 in the XML legacy, which allows to place 1 in the resolved structure.
- Figure 36 shows an example where five authors of pages derived from an original page suggested their modifications.
- the first user suggested removing the first item from the page 2.
- the second user suggested replacing this first item with another version 3.
- the third user suggested an item to add before the second 4
- the fourth user suggested another item, also to be added before the second. 5.
- the fifth user suggested replacing the first element with yet another version, and in addition to adding a pair of elements (the first of which is a version derived from the second) before the fourth
- Figure 37 shows what the user sees upstream (i.e. the author of the original page):
- the user has the option of accepting either the two pages (the first of which is a version derived from the second) but cannot accept the first without accepting the second.
- a propagated element with a ref attribute pointing to the propagated element will be placed in the place corresponding to the upstream (possibly using markers, if the page upstream is it - even a derived page).
- this element will be placed as a child of the element corresponding to the downstream parent, and immediately before the element corresponding to the downstream successor.
- the propagated element will be placed as a child of this element.
- This algorithm is used both to process pages derived from html pages (or more generally any XML structure without identifiers) and pages derived from XML pages (provided with identifiers), the only difference being the nature of the references to the original page, which are references relating to the position or the content in the first case and references to identifiers in the second case.
- This part of the system is called the Resolver.
- the resolver is a system capable of finding an element given its identifier, and, once an element is known, can return part of the children selected by filters and a maximum depth.
- the content of an element in the resolved structure is defined by its state, that is to say by the name of the element in the difference file. • If it is a created element then the content is the XML node (located in an XML legacy) pointed to by the ref attribute. • If it is a moved, imported or propagated element then the content of this element is the same as that of the element pointed by its ref attribute. Note that when an imported element is encountered, the list of differences described by this import must be stored in an associated structure, as described in the previous section. • If it is a rejected element, this means that the element must not be considered to exist (requesting this element produces an error)
- Movements or creations of elements within this list of children that is to say all the elements immediately preceding (in the difference file) an element of this list of children, and n 'having no (moved) replacing attribute pointing to an existing element at the source of the import 3.
- Movements or creations of elements as children of the element whose children are being constructed that is to say all the elements that must be placed using their parent in the difference file (which can be a marker for example), and whose successor does not exist in the difference file or does not exist at the source of the import, and finally having no (moved) replacing attribute pointing to an existing element at the source of the import. It is therefore necessary to apply all the differences corresponding to one of these criteria, and remove them from the list of differences still to be applied. ...
- the first thing to be done by the resolver is to locate the element whose identifier is given in the request. 123
- glassbox glassbox server, glassbox derivation, delegation to another glassbox, etc.
- glassbox server glassbox derivation, delegation to another glassbox, etc.
- each support group (of a glassbox) stores the initial associated links (denoted R), the union of their incoming links (R " ), and the union of the links before R " ,.
- An import can specify that only one element, its children and its ancestors must be returned, using a derivedOfElt attribute (this is described in more detail in the context of the second system). Here's how it should be handled by the resolver. If we are trying to build a child of an import whose attribute exists and is distinct from the value of ref, we must first find (by a call to the resolver) the element pointing to the target of derivedOfElt, then connect this import element by building the chain of parents until reaching the imported element. If the algorithm seeks to directly reach a descendant of this imported element via the identifier, we can determine if it is a child of derivedOfElt by placing the latter in M and the import in R rather than in M.
- a page i.e. outbound and inbound links
- These sets should be updated regularly.
- a page ie its front and back links
- Figure 38 shows schematically the architecture of the complete system
- 126 D is the symmetric of the algorithm described in the previous section where, instead of R-, R- + and R - + -, we take R +, R + - and R + - + and we evaluate to what extent candidate pages R + - cite the pages of R + cited by the pages of R.
- GlassBoxServer The data structure associated with a system.
- Supports all the support groups of the system.
- SupportGroup a support group, with a reference to the associated support element.
- Req The initial associated links of the support group.
- ReqB the set R " , ie the pages pointing to at least one initial associated link.
- Hub a pivot page for a support group. We store its pivot score in memory.
- ReqBF the set R " + .
- Authority an authority page for a support group. We know its authority score by the links and (in case the page is new) its score by the words.
- ReqBFB the known subset of R "+" (the system searches for internal links on a page only if the page is in the initial links of a support group or has a good authority score for at least a support group)
- Corpus This is the set of known pages in the system.
- Page A page found in the corpus. It has an identifier by which it is referenced from other points in the data structure. Freshness indicates if it is a new page, and transToOldDate indicates if necessary on what date the page will become old.
- F d All the links starting from a page. We also store the weight of the link (for antinepotism)
- Words The word distribution of the page.
- Word A word with a frequency associated with it (the sum of the squares for all the words gives 1)
- AltUrl If the system has detected that several different addresses correspond to the same page, this element will store the other url of the page.
- Friendship Gathers information corresponding to the peer-to-peer network of servers of which this server is a part.
- Neighbors These are all neighboring servers, i.e. to which this server can send requests (see description below).
- FriendServer Describes a neighboring server.
- FriendCache A cache of the most recent and most requested requests, associated with the glassbox server that could have answered them.
- FriendCacheEntry A cache entry, specifying the request and then the server that was able to respond to it, and the date since which this entry was in the cache.
- Us geEntry Gives the number of requests for this url on a given date. The interval between the oldest and the most recent entry in the Usage list is subject to a maximum and when it is about to be exceeded it is necessary to remove the entries that are too old.
- the system operates on the basis of a network of dependencies.
- the system builds a network of dependencies, and according to requests and needs, following the arcs of this network, decides which part of the system should be built / updated.
- dependency target depends on a (called dependency source) whether a change in the data associated with b may imply a change in the data associated with a.
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Health & Medical Sciences (AREA)
- Artificial Intelligence (AREA)
- Audiology, Speech & Language Pathology (AREA)
- Computational Linguistics (AREA)
- General Health & Medical Sciences (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
- User Interface Of Digital Computer (AREA)
Abstract
L’invention propose notamment un procédé mis en œuvre dans un environnement informatique pour engendrer une vue courante à partir d’au moins un objet d’information source susceptible de varier, caractérisé en ce qu’il comprend les étapes suivantes: - établir et mémoriser une référence de la vue à l’objet d’information source, - mettre en œuvre par un utilisateur au moins un outil de modification d’objet d’information pour produire à partir de l’objet d’information source un objet d’information transformé, - enregistrer dans une mémoire un ensemble d’informations de différence représentatif de l’effet des actions de modification effectuées par l’utilisateur à l’aide du ou des outils, et - engendrer une vue courante à partir du ou de chaque objet d’information source dans sa version courante et dudit ensemble d’informations de différence. L’invention propose également des procédés pour affecter à des objets d’information des scores de pertinence, pour accéder à des objets d’information en exploitant de tels scores, pour la gestion de références entre objets d’information en fonction de l’existence de modifications apportées aux objets d’information par l’utilisateur, pour accéder sélectivement à un objet d’information dérivé créé à partir d’un objet d’information de départ, pour accéder de façon personnalisée à des objets d’information reliés à d’autres par des liens orientés, pour accéder sélectivement à l’un parmi une pluralité d’objets d’information à partir d’un objet d’information de départ, pour l’affichage d’un objet d’information personnalisé obtenu à partir d’un objet d’information d’origine, et enfin pour manipuler des informations à l’aide d’une interface graphique utilisateur.
Description
« PROCEDES DE MANIPULATION D'OBJETS D'INFORMATION ET D'ACCES A DE TELS OBJETS DANS UN ENVIRONNEMENT INFORMATIQUE »
La présente invention concerne d'une façon générale des techniques de manipulation d'objets d'information, (pages Web, fichiers, parties de fichiers, etc.), et de navigation parmi ces objets d'information.
Elle vise notamment à proposer des procédé dans lequel un utilisateur puisse personnaliser des objets d'information « sources », et où à la fois les changements apparus dans le ou les objets d'informations sources et la personnalisation qu'il à effectuée puissent se retrouver dans une vue courante à chaque fois que ledit utilisateur réalise un accès vers un tel objet.
La présente invention concerne aussi d'une façon générale les procédés mis en oeuvre dans un environnement ou système informatique pour affecter à des objets d'information ou ressources des scores de pertinence, et les procédés pour accéder à des ressources dans un environnement ou système informatique sur la base de tels scores de pertinence.
Dans les environnements informatiques modernes, qui permettent à un utilisateur d'accéder rapidement à une quantité gigantesque de ressources notamment distantes, telles que des pages web, et également d'accéder à des quantités pouvant être importantes de ressources personnelles, les méthodes de classement ou d'organisation classiques de fichiers trouvent rapidement leurs limites. De même, les méthodes pour rechercher des informations d'intérêt (moteurs de recherche, etc.) sont en général limitées à des ressources de type texte et subissent les limites et les ambiguïtés du langage.
Et il s'avère que seul un environnement qui permettrait d'élaborer et de maintenir des relations de pertinence entre ressources créées, consultées, modifiées, etc., qu'elles soient locales ou distantes, pourrait permettre de contourner ces limitations et de permettre à un utilisateur soit de retrouver une ressource qui l'intéresse en accédant à des ressources qui sont pertinente par rapport à elle, soit de trouver de nouvelles ressources de la même manière.
L'objet principal de l'invention est donc de permettre à un utilisateur de créer des « relations de pertinence » entre une première ressource1 et d'autres ressources, afin de pouvoir retrouver la première ressource simplement en accédant à au moins une ressource pertinente par rapport à la première ressource.
On notera ici qu'une (ou des) ressource(s) pertinente(s) par rapport à la première ressource peu(ven)t être, non seulement l'une (certaines) desdites autres ressources que l'utilisateur a reliée(s) à la première ressource, mais aussi : - une (des) ressource(s) ayant une relation de pertinence avec la première ressource, créée par un autre utilisateur dans un réseau de relations de pertinence partagé entre ces deux utilisateurs, - une (des) ressource(s) pour laquelle (lesquelles) la première ressource est automatiquement estimée pertinente au moyen de règles d'inférences2 qui s'appliquent sur les relations de pertinence ainsi créées, - une (des) ressource(s) pour laquelle (lesquelles) la première ressource a un score de pertinence élevé qui a été déterminé automatiquement par le procédé en assimilant les relations de
1 Par ressource on entend ressource d'information. Par relation de pertinence entre deux ressources on entend relation indiquant leur pertinence relative (l'une par rapport à l'autre).
2 (qui sont configurées par défaut et/ou paramétrées par l'utilisateur)
pertinence à des capacités (conduits3) de propagation de score de pertinence d'une ressource vers l'autre.
Un but de l'invention est que, en plus des relations de pertinence créés par les utilisateurs eux- mêmes, le procédé puisse utiliser des conduits de propagation de score de pertinence créés automatiquement à partir des interrelations et du contenu des ressources. Ainsi un procédé de l'invention vise à créer automatiquement des conduits : entre les ressources cocitées4, entre les ressources liées par des liens hypertextes, entre les ressources ayant des distributions proches de mots, éventuellement en combinant en plus avec des conduits déterminés avec encore d'autres méthodes de calcul de pertinence entre ressources.
Ces conduits sont créés notamment entre les ressources du Web susceptibles d'intéresser les utilisateurs.
On vise également à proposer des mécanismes où les utilisateurs puissent créer des conduits de propagation de score de pertinence (ou des relations de pertinence) entre des ressources du Web et des ressources privées (par exemple les documents de l'entreprise) et permettent ainsi de propager vers ces dernières les scores de pertinence (calculés en analysant la structure des liens et du contenu) des ressources du Web.
Ainsi, en exploitant tous ces conduits de propagation de scores de pertinence, l'invention vise à permettre à l'utilisateur : • de retrouver les premières ressources; • comme l'utilisateur peut partager un réseau (de relations de pertinence et de conduits de propagation de score de pertinence) avec d'autres utilisateurs, le procédé vise à permettre à l'utilisateur de découvrir les premières ressources expressément reliées par d'autres utilisateurs au sein du réseau partagé ; • enfin le procédé permet aussi à l'utilisateur de découvrir d'autres ressources pertinentes parmi les ressources privées ou publiques (e.g. sur le Web) auxquelles de bons scores se sont propagés via des conduits placés automatiquement.
La présente invention vise en outre notamment à proposer des techniques dans lesquelles un utilisateur puisse modifier un objet d'information source - il peut par exemple lui associer des annotations, ou en personnaliser une partie - et enregistrer les modifications en tant que page dérivée de la page d'origine.
L'invention vise aussi à permettre que la page dérivée lui soit spontanément présentée par le système quand il revisite la page d'origine.
Selon un autre aspect, l'invention vise à déterminer, en exploitant les liens qui se trouvent dans les pages du Web, le degré de pertinence des pages les unes par rapport aux autres et par rapport au contexte de navigation de l'utilisateur.
Ainsi, pour chaque page visitée, l'invention vise à présenter à l'utilisateur la page dérivée la plus pertinente ainsi que des annotations associées à d'autres pages pertinentes et des liens vers d'autres pages pertinentes.
On appelle dans la suite un conduit entre 2 ressources, une aptitude à propager un score de pertinence d'une ressource vers l'autre. La capacité de propagation est appelée grosseur du conduit, (cocitées par exemple par liens hypertextes dirigés vers elles et placés dans une même page web)
Un autre but de l'invention est de permettre qu'une annotation puisse être par exemple un lien vers une ressource d'information tel qu'un fichier, de manière à ce que l'utilisateur puisse ainsi retrouver des ressources d'information simplement en se plaçant dans leur contexte de pertinence : lorsque l'utilisateur navigue et se rapproche du contexte de la ressource qu'il recherche, on vise un système qui la lui propose spontanément.
Plus globalement, l'invention vise ainsi à utiliser le système constituant, pour l'utilisateur, une "mémoire associative".
L'invention vise, pour terminer, à faciliter la manipulation d'objets d'information en permettant à des sélections de parties d'objets d'information faites dans une interface graphique utilisateur de devenir à leur tour manipulables par exemple au profit des autres objectifs précités.
Selon un premier aspect, l'invention propose un procédé mis en œuvre dans un environnement informatique pour engendrer une vue courante à partir d'au moins un objet d'information source susceptible de varier, caractérisé en ce qu'il comprend les étapes suivantes : établir et mémoriser une référence de la vue à l'objet d'information source, mettre en œuvre par un utilisateur au moins un outil de modification d'objet d'information pour produire à partir de l'objet d'information source un objet d'information transformé, enregistrer dans une mémoire un ensemble d'informations de différence représentatif de l'effet des actions de modification effectuées par l'utilisateur à l'aide du ou des outils, et engendrer une vue courante à partir du ou de chaque objet d'information source dans sa version courante et dudit ensemble d'informations de différence.
Certains aspects préférés mais non limitatifs de ce procédé sont les suivants :
* l'outil de modification d'objet d'information comprend un programme d'édition de document.
* le programme d'édition est apte à engendrer un journal des modifications apportées à chaque document, l'étape d'enregistrement est mise en oeuvre en utilisant les données de journal.
* l'outil de modification d'objet d'information comprend une pluralité d'opérateurs de modification sélectionnables individuellement par l'utilisateur.
* le procédé est mis en oeuvre sur un objet d'information source lui-même constitué par une vue courante engendrée par une mise en oeuvre précédente du même procédé.
* la vue courante est engendrée au sein d'un objet d'information plus grand contenant ladite vue.
* l'objet comprend plusieurs vues, et le procédé est répété pour chacune des vues courantes à engendrer.
* la vue courante est constituée par une référence à l'objet d'information source, ladite référence étant associée à un objet d'information contenant.
* la référence est constituée par un lien hypertexte.
* le procédé comprend en outre une étape d'établissement et de mémorisation d'une relation entre un objet d'information contenant directement ou indirectement ladite vue et l'objet d'information source.
* ladite relation est une relation d'équivalence sémantique.
* le procédé comprend en outre une étape d'établissement et la mémorisation d'une relation entre la vue et l'objet d'information source.
* la relation est une relation sémantique.
* le procédé comprend en outre la mise en œuvre d'un processus d'inférence basé sur une pluralité de relations sémantiques entre vues et objets d'information sources.
* l'objet d'information source est dérivé d'un autre objet d'information.
* la référence de la vue à l'objet d'information source est constituée par une requête en réponse à laquelle un ou plusieurs objets d'information sources sont délivrés.
* la requête est une requête appliquée à un moteur de recherche, ce dernier délivrant le ou les objets d'information sources.
* la requête est constituée par un groupe d'objets d'information, et le procédé comprend une étape de recherche d'au moins une autre objet d'information présentant le meilleur score de pertinence par rapport audit groupe.
* le procédé comprend une étape de mémorisation de la vue courante engendrée, et ledit ensemble d'informations de différence contient un ou plusieurs pointeurs vers un ou plusieurs objets d'information dont le contenu et la position sont contenus dans la vue courante.
* lesdits objets d'information sont structurés en sous-objets hiérarchiques, et dans le cas où ledit ensemble d'informations de différence contient une information de différence visant une partie d'un objet, alors l'étape de génération de la vue courante conserve la dernière version du plus petit sous-objet contenant une telle partie d'objet.
* ladite information de différence visant une partie d'un objet comprend une information de changement d'attribut de l'objet.
* ledit attribut est un nom d'objet.
* ladite information de différence visant une partie d'un objet comprend une information de position d'objet.
* dans le cas où l'objet d'information source comprend plusieurs sous-objets, le procédé est mis en œuvre autant de fois qu'il y a de sous-objets.
* l'ensemble d'informations de différence contient, pour un objet comprenant une pluralité de sous-objets, des attributs modifié/non modifié pour chacun de ces objets de objets.
* chaque objet d'information possède un identifiant d'objet.
* chaque identifiant d'objet est unique dans l'environnement informatique.
* l'étape de génération de vue courante se réfère à un identifiant de modification.
* chaque identifiant de modification est unique dans l'environnement informatique.
* chaque vue courante possède au moins un identifiant composite comprenant un identifiant de modification et un identification d'objet auquel la modification par l'ensemble d'informations de différence correspondant s'applique.
* une vue courante possède un identifiant renvoyant vers une pluralité d'identifiants de modification et une pluralité d'identifiants d'objets auquel les modifications par les ensembles d'informations de différence correspondants s'appliquent respectivement.
* dans le cas où un objet d'information source est lui-même issu de l'application d'un ensembles d'informations de différence à un autre objet d'information source, alors un identifiant composite correspondant comprend un identifiant d'objet possédé par ledit autre objet d'information de départ et un double identifiant d'ensembles d'informations de différence.
Selon un deuxième aspect, on propose un procédé mis en œuvre dans un environnement informatique pour affecter à des objets d'information des scores de pertinence, caractérisé en ce qu'il comprend les étapes suivantes : - affecter à au moins certaines paires d'objets d'information une capacité (conduit) de propagation de score de pertinence d'un objet d'information vers l'autre, - affecter à au moins un objet d'information un score de pertinence, et - calculer, pour au moins un autre objet d'information, un score de pertinence à partir de scores de pertinence d'objets d'information ayant avec ledit autre objet d'information une capacité de propagation et des valeurs (grosseurs de conduits) desdites capacités de propagation.
Certains aspects préférés mais non limitatifs de ce procédé sont les suivants :
* on affecte une capacité de propagation à chaque paire d'objets d'information, une capacité de propagation pouvant avoir une valeur nulle.
* au moins certains objets d'information sont reliés entre eux par des liens d'objet d'information citant vers objet d'information cité, et la capacité de propagation entre deux objets d'information est calculée à partir d'un critère de nombre d'objets d'information citants communs entre ces deux objets d'information.
* au moins certains objets d'information sont reliés entre eux par des liens d'objet d'information citant vers objet d'information cité, et la capacité de propagation entre deux objets d'information est calculée à partir d'un critère d'existence d'un lien entre ces deux objets d'information.
* au moins certains objets d'information possèdent un contenu textuel, et la capacité de propagation entre deux de tels objets d'information est calculée à partir d'un critère de distribution de mots dans ces deux objets d'information.
* la capacité de propagation entre deux objets d'information est calculée à partir d'un critère de relation entre objets d'information établie par l'utilisateur.
* la relation entre objets d'information établie par l'utilisateur est dérivée d'un classement ou d'un regroupement d'objets d'information effectué par l'utilisateur.
* la capacité de propagation entre deux objets d'information est calculée à partir d'une combinaison d'au moins deux critères.
* l'étape de calcul comprend une somme des scores de pertinence pondérée avec les capacités de propagation.
* les capacités de propagation sont normalisées.
* le procédé comprend une étape d'élaboration, par l'utilisateur, d'une capacité de propagation entre deux objets d'information d'une paire.
* à chaque paire d'objets d'information sont affectées deux capacités de propagation, l'une dans une première direction et l'autre dans la direction opposée.
* le procédé est mis en œuvre a priori sur un sous-ensemble d'objets d'information représentatif d'un ensemble d'objets d'information plus grand pour prédéterminer des valeurs intermédiaires utilisées ultérieurement pour calculer les scores de pertinence.
L'invention propose en outre un procédé pour accéder à des objets d'information dans un environnement informatique, caractérisé en ce qu'il comprend : - l'élaboration d'un groupe d'objets d'information de départ, - la mise en œuvre du procédé tel que défini ci-dessus pour identifier d'autres objets d'information ayant les scores de pertinence les plus élevés par rapport au groupe d'objets d'information de départ, et - l'affichage d'éléments représentatifs desdits objets d'information identifiés pour accès à ceux-ci par l'utilisateur.
Certains aspects préférés mais non limitatifs de ce procédé sont les suivants :
* le procédé comprend l'étape préalable consistant à mettre en œuvre un processus de recherche pour élaborer le groupe d'objets d'information de départ.
* le groupe d'objets d'information de départ est élaboré à partir d'un classement manuel et/ou automatisé d'objets d'information dans un système d'exploitation de l'environnement informatique ou dans une application informatique.
* le procédé comprend en outre : - la détermination d'une relation de pertinence affinée entre l'une au moins des objets d'information identifiés et l'un au moins des objets d'information de départ, et - la représentation graphique desdites relations de pertinence affinées.
* l'étape d'affichage comprend : - la détermination de l'existence de capacités de propagation non nulles entre les objets d'information de départ et lesdits objets d'information identifiés, et
- la représentation graphique de liaisons entre lesdits objets d'information identifiés et les objets d'information de départ en fonction des capacités de propagation.
* le procédé comprend en outre : - la détermination de l'existence d'une capacité de propagation préexistante nulle entre au moins un objet d'information de départ et un objet d'information identifié, et - la modification de cette capacité de propagation nulle en une capacité de propagation non nulle.
* ladite étape de modification est effectuée en fonction du score de pertinence de l'objet d'information identifié par rapport à l'objet d'information de départ.
* l'ensemble d'objets d'information est formé par un réseau de base comprenant des objets d'information et les capacités de propagation correspondantes, et par des modifications/adjonctions/suppressions apportées à ce réseau de base pour former un réseau modifié, et la mise en œuvre du procédé définie plus haut est effectuée à partir du groupe d'objets d'information de départ et desdites données de modifications/adjonctions/suppressions.
L'invention propose par ailleurs un procédé pour accéder à des objets d'information dans un environnement informatique, caractérisé en ce qu'il comprend : - la mise en œuvre du procédé tel que défini plus haut pour déterminer des scores de pertinence absolus de l'ensemble des objets d'information, - la mise en œuvre d'un processus de recherche utilisant une requête, - le tri des objets d'information satisfaisant à ladite requête en fonction de leur score de pertinence absolu, et - l'affichage d'éléments représentatifs des objets d'information triés pour accès à ceux-ci par l'utilisateur.
On propose en outre selon l'invention un procédé pour accéder à des objets d'information dans un environnement informatique, caractérisé en ce qu'il comprend : - l'élaboration d'un groupe d'objets d'information de départ, - la mise en œuvre d'un procédé de calcul de scores de pertinence pour identifier d'autres objets d'information ayant les scores de pertinence les plus élevés par rapport au groupe d'objets d'information de départ, - la création d'un objet d'information supplémentaire représentative du groupe d'objets d'information de départ, et - la création de capacités de propagation, établie en fonction desdits scores de pertinence, entre les objets d'information identifiés et l'objet d'information supplémentaire.
Certains aspects préférés mais non limitatifs de ce procédé sont les suivants :
* le procédé de calcul de scores de pertinence est conforme au deuxième aspect de l'invention présenté plus haut.
* le procédé étant appliqué à un ensemble d'objets d'information comprenant des objets d'information supplémentaires établis par le procédé tel que défini ci-dessus, on prévoit que le calcul d'un score de pertinence pour un objet d'information appartenant à un groupe d'objets d'information de départ pour lequel un objet d'information supplémentaire a été créé est effectué en prenant en compte le score de pertinence calculé pour cet objet d'information supplémentaire.
* ledit calcul d'un score de pertinence pour un objet d'information appartenant à un groupe d'objets d'information de départ pour lequel un objet d'information supplémentaire a été créé est effectué en prenant en compte uniquement le score de pertinence calculé pour cet objet d'information supplémentaire.
* le groupe d'objets d'information de départ est établi à partir d'une requête appliquée à une base de données, et l'objet d'information supplémentaire représente et contient ladite requête.
L'invention propose également un procédé, mis en œuvre dans un environnement informatique comportant des objets d'information ayant des références vers d'autres objets d'information, et notamment des premiers contenus ayant au moins une référence vers un second contenu telle qu'un lien vers le second contenu ou telle qu'une transclusion du second contenu, pour la gestion de telles références en fonction de l'existence de modifications apportées aux objets d'information par l'utilisateur, caractérisé en ce qu'il comprend les étapes suivantes : - visualisation par l'utilisateur d'un second contenu courant via une référence possédée par un premier contenu, dans un mode permettant la modification dudit second contenu; - quand ledit second contenu est modifié dans ledit mode, création d'une nouvelle version du second contenu et remplacement de ladite référence par une référence vers cette nouvelle version.
Certains aspects préférés mais non limitatifs de ce procédé sont les suivants :
* ladite référence est une requête telle qu'une requête dans un langage standard, à une base de données.
* ladite nouvelle version du second contenu est représentée par une structure de marqueurs contenant les différences entre ladite nouvelle version du second contenu et ledit second contenu courant, pour ainsi présenter à l'utilisateur un second contenu dans lequel lesdites différences ont été appliquées à la version courante du second contenu.
On propose aussi selon l'invention un procédé mis en œuvre dans un environnement informatique pour accéder sélectivement à un objet d'information dérivé créé dans l'environnement informatique à partir d'un objet d'information de départ, caractérisé en ce qu'il comprend les étapes suivantes : (a) élaborer des scores de pertinence de l'objet d'information de départ et de l'objet d'information dérivé à l'aide d'un mécanisme de détermination de pertinence donné ; (b) en relation avec l'accès par un utilisateur à l'objet d'information de départ, fournir ou non à l'utilisateur une information sur l'existence de l'objet d'information dérivé ou un accès audit objet d'information dérivé, en fonction desdits scores de pertinence.
Certains aspects préférés mais non limitatifs de ce procédé sont les suivants :
* l'étape (a) élabore également un score de pertinence d'au moins un autre objet d'information, et l'étape (b) comprend en outre la fourniture ou non à l'utilisateur d'une information sur l'existence dudit autre objet d'information ou d'un accès audit autre objet d'information, en fonction desdits scores de pertinence.
* l'étape (a) élabore également un score de pertinence d'au moins un autre objet d'information, et le procédé comprend en outre, en liaison avec l'accès à l'objet d'information de départ ou à l'objet d'information dérivé, une étape (c) de fourniture ou non à l'utilisateur d'une information sur l'existence dudit autre objet d'information, en fonction desdits scores de pertinence.
* l'étape (a) élabore également un score de pertinence d'au moins une autre objet d'information, et le procédé comprend en outre, en liaison avec l'accès à l'objet d'information de départ ou à l'objet d'information dérivé, une étape (c) d'affichage ou non d'au moins une partie (annotation) du contenu dudit autre objet d'information, en fonction desdits scores de pertinence.
* l'étape (b) est mis en œuvre en relation avec l'existence d'une modification apportée audit objet d'information dérivé ou de départ depuis sa fourniture précédente à l'utilisateur.
* l'étape (c) est mise en œuvre en relation avec l'existence d'une modification apportée audit autre objet d'information depuis sa fourniture précédente à l'utilisateur.
* les objets d'information de départ étant reliés par des liens directionnels pour former ensemble un graphe orienté de départ, le procédé comprend en outre l'étape consistant à construire un graphe dérivé virtuel formé à partir du graphe orienté de départ et de liens virtuels partant de objets d'information citant l'objet d'information de départ et dirigés vers l'objet d'information dérivé, et les scores de pertinence sont élaborés sur la base dudit graphe dérivé virtuel.
* l'objet d'information dérivé est obtenu par modification de l'objet d'information de départ.
* l'objet d'information dérivé est un objet d'information possédant au moins une vue vers au moins une partie de l'objet d'information de départ.
* l'objet d'information dérivé est un objet d'information possédant au moins une copie d'au moins une partie de l'objet d'information de départ.
* dans le cas où l'objet d'information dérivé est obtenu à partir d'un objet d'information de départ qui est lui-même un autre objet d'information dérivé d'un autre objet d'information de départ, l'étape de construction du graphe dérivé virtuel prend également en compte des liens virtuels partant d'objets d'information citant ledit autre objet d'information de départ et dirigés vers ledit autre objet d'information dérivé.
* dans le cas où l'objet d'information dérivé possède plusieurs vues vers plusieurs objets d'information de départ, l'étape de construction du graphe dérivé virtuel prend en compte les liens virtuels partant d'objets d'information citant les objets d'information de départ respectifs et dirigés vers l'objet d'information dérivé.
Selon la présente invention, il est proposé également un procédé mis en œuvre dans un environnement informatique pour accéder de façon personnalisée à des objets d'information, lesdites objets d'information comprenant des objets d'information de départ reliés par des liens orientés pour former ensemble une structure de départ, caractérisé en ce qu'il comprend les étapes consistant à : (a) créer des objets d'information ajoutés aux objets d'information de départ, pour former une structure dérivée, (b) mémoriser la structure dérivée sous forme d'une référence à la structure de départ, des objets d'information ajoutés et des liens entre la structure de départ et les objets d'information ajoutés, (c) mémoriser, en association avec la structure dérivée, des informations spécifiques de recherche d'objets d'information pertinents, (d) rechercher des objets d'information pertinents dans la structure dérivée en utilisant les informations spécifiques de recherche.
Certains aspects préférés mais non limitatifs de ce procédé sont les suivants :
* les informations spécifiques de recherche comprennent des informations de centres d'intérêt.
* les étapes (a) à (c) sont mises en œuvre de façon répétée pour former une pluralité de structures dérivées par ajout d'objets d'information à la structure de départ ou à des structures dérivées préexistantes.
* l'étape (c) de mémorisation des informations spécifiques de recherche s'effectue sous forme d'une référence à des informations spécifiques de recherche déjà associées à la structure ou à une structure dérivée préexistante, et d'informations spécifiques de recherche ajoutées.
* les structures dérivées sont elles-mêmes organisées en graphe.
* le graphe des structures dérivées est un arbre.
L'invention propose additionnellement un procédé mis en œuvre dans un environnement informatique pour accéder sélectivement à l'une parmi une pluralité de objets d'information à partir d'un objet d'information de départ, caractérisé en ce qu'il comprend les étapes suivantes :
(a) élaborer des scores de pertinence de l'objet d'information de départ et d'autres objets d'information à l'aide d'un mécanisme de détermination de pertinence donné, lesdits autres objets d'information comprenant des objets d'information indépendants et des objets d'information dérivés de l'objet d'information de départ et/ou de ces objets d'information indépendants, (b) en relation avec l'accès par un utilisateur à l'objet d'information de départ, fournir ou non à l'utilisateur une information sur l'existence d'un autre objet d'information ou un accès audit autre objet d'information, en fonction desdits scores de pertinence.
Certains aspects préférés mais non limitatifs de ce procédé sont les suivants :
* l'étape (b) est mis en œuvre en relation avec l'existence d'une modification apportée audit autre objet d'information depuis sa fourniture précédente à l'utilisateur.
* le mécanisme de détermination de pertinence est basé sur des analyses de liens entre objets d'information, au moins l'un des objets d'information dérivés est obtenu par reproduction d'un objet d'information de départ ou par insertion, dans un objet d'information quelconque, d'une vue ou d'une copie de l'ensemble de ledit objet d'information de départ, et le procédé comprend une étape de création de liens virtuels dirigés vers ledit objet d'information dérivé et partant de chaque objet d'information ayant un lien dirigé vers l'objet d'information de départ considéré.
* le mécanisme de détermination de pertinence est basé sur des analyses de liens entre objets d'information, au moins l'un des objets d'information dérivés est obtenu par insertion, dans un objet d'information quelconque, d'une vue ou d'une copie d'une partie seulement d'un objet d'information de départ, cette partie étant ou contenant elle-même une vue ou une copie de l'ensemble d'un objet d'information indirect de départ, et le procédé comprend une étape de création d'un lien virtuel dirigé vers ledit objet d'information dérivé et partant de chaque objet d'information ayant un lien dirigé vers l'objet d'information indirect de départ considéré.
* le procédé comprend en outre, en liaison avec l'accès à l'objet d'information de départ ou à un autre objet d'information, une étape d'affichage ou non d'au moins une partie (annotation) du contenu d'un troisième objet d'information, en fonction desdits scores de pertinence.
* l'étape d'affichage est mise en œuvre également en fonction de l'existence d'une modification apportée au troisième objet d'information depuis son affichage précédent.
La présente invention prévoit aussi un procédé mis en œuvre dans un environnement informatique en réseau pour l'affichage d'un objet d'information personnalisé obtenue à partir d'un objet d'information d'origine,caractérisé en ce qu'il comprend les étapes suivantes : charger l'objet d'information d'origine à partir d'un site mettant ledit objet d'information d'origine à disposition de l'utilisateur, enregistrer dans une mémoire un objet d'information de travail obtenu à partir d'une copie de l'objet d'information d'origine, mettre en œuvre des outils de modification de objet d'information pour produire à partir de la dite objet d'information de travail un objet d'information modifié, enregistrer dans une mémoire un ensemble d'informations représentatif des différences entre l'objet d'information d'origine ou l'objet d'information de travail et l'objet d'information modifié, et lors d'un accès ultérieur à l'objet d'information d'origine, engendrer, à partir de l'objet d'information d'origine dans sa version courante et dudit ensemble d'informations représentatif desdites différences, un nouvel objet d'information modifié.
Un aspect préféré mais non limitatif de ce procédé est le suivant :
* l'objet d'information de travail comprend une pluralité de contenus appartenant à l'objet d'information d'origine et des identifiants attribués aux contenus respectifs, et les différences représentées par ledit ensemble d'informations sont des différences identifiant par identifiant.
Enfin on propose un procédé de manipulation d'informations à l'aide d'une interface graphique utilisateur, ladite interface comprenant des moyens permettant une sélection d'une partie d'informations données, caractérisé en ce qu'il comprend une étape de conversion d'une sélection effectuée à l'aide de ladite interface en un objet ultérieurement manipulable.
Certains aspects préférés mais non limitatifs de ce procédé sont les suivants :
* l'étape de conversion est mise en oeuvre seulement en réponse à une instruction d'utilisateur déclenchée à l'aide d'un outil de pointage utilisé pour effectuer la sélection.
* le procédé comprend en outre une étape d'affichage sélectif d'un indicateur visuel montrant l'existence, parmi des informations affichées, d'un objet d'information issu d'une conversion antérieure à partir d'une sélection. * * *
D'autres caractéristiques préférées, buts et avantages de l'invention apparaîtront mieux à la lecture de la description détaillée suivante de formes de réalisation préférées de celle-ci, donnée à titre d'exemple non limitatif et faite en référence aux dessins annexés, sur lesquels les différentes figures sont des schémas, diagrammes, etc. illustrant l'invention.
On observera à titre préliminaire que dans la description qui suit, on utilisera le terme « procédé » ou le terme « système » de façon essentiellement indifférenciée, selon en particulier qu'on se réfère aux actions mises en œuvre par le procédé de l'invention ou au système informatique qui est le support de ces actions.
Introduction
On va décrire un cadre unifié et de nouvelles méthodes pour gérer des informations. Ces méthodes se basent sur les notions d'objet et de relotion.
Le terme « objet » (ou objet d'information5) désigne toute ressource d'information possédant une identité. Par exemple : • un fichier informatique • un élément d'un document en format XML • un répertoire • un paragraphe dans un document Word • une sélection d'une partie d'un document Word • une page web • une entrée dans un annuaire (cette entrée représentant une personne particulière). Un objet peut en contenir d'autres, formant ainsi une hiérarchie6.
La notion de « relation », quant à elle, couvre toute foπne de référence à un (ou un ensemble de) « objet(s) source(s) », laquelle référence est associée à un « objet relié ». Une relation peut ainsi être par exemple : • une relation sémantique d'un objet à un autre. Par exemple, o une relation « auteur » d'un document (l'objet relié) écrit par une certaine personne, vers l'objet (objet source) représentant cette personne ;
5 Les termes « ressource » et « ressource d'information » en sont aussi synonymes - par exemple dans UP (Unifor Resource Identifier).
6 On parlera d'objets enfants (ou sous-objets), objets descendants, objet parent, etc.
o une relation sémantique allant d'une représentation d'un article de loi (l'objet relié) vers un commentaire juridique de ce dernier (l'objet source) • un lien hypertexte dans une page (objet relié) vers une autre (objet source) • un élément html <iframe> est une relation de l'objet (objet relié) contenant cet élément vers l'objet pointé (objet source) • un raccourci vers un répertoire (objet source), placé dans un autre répertoire (objet relié) • une relation hiérarchique d'un objet contenu (objet relié) vers son objet contenant (objet source), par exemple dans une structure de répertoires.
Toutes les informations peuvent ainsi être vues soit sous forme d'objet soit sous forme de relation. Le cadre est unifié dans la mesure où l'on traite tous les objets de manière égale quelle que soit leur nature, et similairement on utilise une représentation unifiée de la notion de relation. On peut ainsi effectuer une recherche en réponse à une requête de l'utilisateur, et donner des scores de pertinence aux objets retournés. Ces résultats sont obtenus notamment en propageant des scores le long des relations (d'où l'intérêt ici d'unifier la représentation des relations).
Transclusion
Etat de l'art
Un cas particulier de relation est la transclusion (ou inclusion par référence7). Par exemple, la balise « img » dans le langage HTML permet d'inclure une image par référence.
Un autre exemple de transclusion est représentée par l'option « Créer un lien » du menu qui apparaît lorsque sur un document Word on effectue une opération de glisser-déposer d'une sélection d'une partie du document en tenant le bouton droit de la souris appuyé.
Un troisième exemple de transclusion aurait pu être ce que permet la fonction « Créer les raccourcis ici » (en anglais : « create shortcut ») proposée dans les système d'exploitation
Windows, si le raccourci d'un répertoire était une vue directe de son contenu, c'est-à-dire si cette fonction permettait d'inclure dans un répertoire (RI) une vue d'un autre répertoire (R2) dont on peut directement voir le contenu (sous RI).8
La transclusion consiste à créer une vue (« le résultat ») d'au moins un objet (« source ») placé dans un objet (« le contenant »).9 Les objets sources peuvent être distants. Ils sont soit identifiés directement, soit implicitement en tant que résultat d'une requête de recherche10. Par exemple, on peut inclure dans un document Word le résultat d'une requête à une base de données. Dans la suite par « la source (d'une transclusion) » on entend « l'objet source ou l'ensemble des objets sources (de ladite transclusion) ».
Lorsque le contenant est visionné par la suite, une présentation de la source sera visible à l'emplacement de la transclusion. Autrement dit, chaque fois que l'objet contenant sera ouvert ou actualisé11 manuellement ou automatiquement, la version courante (c'est-à-dire la plus récente) de la source sera présentée à cet emplacement. Dans une mise en œuvre plus complète, à chaque modification l'objet source notifie l'objet résultat qui peut ainsi se synchroniser.
Résumé de l'invention
Les offres existantes de transclusion sont limitées, en particulier parce qu'elles ne permettent pas à un utilisateur de modifier le résultat de la transclusion (sans, bien entendu, altérer le contenu de
7 (par opposition à l'inclusion par copie) En d'autres termes, cela aurait été une transclusion au sens courant du terme, si dans une représentation arborescente les contenus du répertoire R2 étaient présentés comme des descendants du répertoire RI, ce qui n'est aujourd'hui pas le cas.
9 Par abus de langage, il peut arriver dans la suite que l'on écrive « transclusion » au lieu de « résultat de transclusion ».
10 Les possibilités de requêtes seront décrites plus loin, dans la section « Recherche d'information »
11 (i.e. mis à jour ; « refreshed » en anglais)
la source12) de la même manière que s'il modifiait une copie locale de la source, ce résultat (ou plutôt ses parties non modifiées) restant quand même tenu à jour par rapport à la source.
Nous appelons « transclusion enrichie » cette opération de transclusion et modification du résultat sans perte du lien avec la source.
Pour mettre en œuvre la transclusion enrichie, une approche pourrait être de remplacer chaque transclusion d'objet composite par des transclusions sur ses enfants. Cette approche a le mérite d'être simple et relativement puissante (elle permet de modifier et déplacer les objets dans le résultat, et même d'insérer des informations entre les objets transclus) mais elle est cependant limitative : si par la suite un nouvel enfant est ajouté à la source, il ne sera pas ajouté dans le résultat (de la transclusion globale) ; de même si par la suite un enfant est déplacé, il ne sera pas déplacé dans le résultat. Nous allons présenter dans la suite un procédé qui n'a pas ces limitations.
La figure 1 montre schématiquement un exemple d'une série d'opérations de transclusion enrichie13. Il y a trois documents, respectivement nommés A, B et C. Initialement ces 3 documents sont vides sauf A qui contient une section (dont l'identifiant est 1) dans laquelle se trouve un paragraphe (dont l'identifiant est 2). Tout d'abord l'utilisateur transclut le paragraphe 2 dans le document B (transclusion 3) . Le résultat en est le paragraphe 3:2. Ensuite il transclut ce dernier dans la section 1 du document A, et le place juste avant le paragraphe 2 (transclusion 4). Enfin il transclut la section 1 (prise entièrement) dans le document C (transclusion 5). En résultat, le document C contient la section 5:1 dans laquelle sont présentés les paragraphes 5:4:3:2 et 5:2. Un objet supplémentaire 5:3:2 a été créé mais il est invisible pour l'utilisateur. Des transcmsions implicites 5:3 et 5:4 (respectivement vers et à partir de cet objet) ont été créées. Si l'utilisateur modifie le contenu du paragraphe 2, cette modification sera reflétée dans tous les autres paragraphes. De même, s'il déplace le paragraphe 2 pour le mettre avant le paragraphe 1, le paragraphe 5:2 va automatiquement se mettre avant le paragraphe 5:4:3:2. Ensuite, l'utilisateur modifie le contenu du paragraphe 5:2. Par le fait des transcmsions implicites 5:3 et 5:4, cette modification se reflète dans le paragraphe 5:4:3 2. Dans la mesure où 5:2 est le plus petit objet englobant cette dernière modification, une modification ultérieure du paragraphe 2 ne se reflétera alors plus dans le paragraphe 5:2 (via la transclusion 5) mais seulement dans 4:3:2, (via les transclusions 3 et 4). De même une modification de 4:3:2 ne se reflétera plus dans 5:4:3:2 (via la transclusion 5) puisque les transclusions 5:3 et 5:4 (qui ont propagé le résultat de la modification de 5:2 vers 5:4:3:2) sont prioritaires (car plus « locales ») par rapport à la transclusion 5.
Prenons un autre exemple. Dans l'exemple de transclusion de répertoire mentionné dans la section précédente, la transclusion enrichie d'une vue d'un répertoire R2 (placée par exemple dans un autre répertoire) offrirait l'avantage de pouvoir modifier (ajouter, renommer, supprimer, etc.) des objets (fichiers, sous répertoires) dans cette vue sans modifier le contenu de la source de cette vue (c'est-à-dire sans modifier le contenu original du répertoire R2 - voir la figure 2). Si plus tard un nouvel objet est ajouté dans R2, il sera également1 ajouté dans cette vue de R2 (comme dans la transclusion simple). En revanche, (contrairement à la transclusion simple) si dans cette vue une partie du contenu d'un objet est modifiée, le contenu de l'objet15 le plus petit contenant (ou égal à) cette partie cessera d'être tenue à jour par rapport à la source. Ainsi, quand un objet (par exemple un sous répertoire de R2) est renommé16 dans cette vue, si par la suite l'objet correspondant à la source (c'est-à-dire le sous répertoire correspondant dans R2) est renommé, ce dernier renommage ne sera pas reflété dans cette vue, bien que dans cette vue le contenu proprement dit de cet objet restera tenu à jour. De même les objets déplacés dans cette vue conservent leur
1 (sauf par synchronisation de la source à partir du résultat, ce qui bien sûr peut être une option offerte)
13 Le même exemple est présenté à la figure 6 de manière différente.
14 (dès que cette vue sera re-présentée, actualisée ou synchronisée)
15 Rappelons que par définition un objet est un élément d'information qui peut être identifié.
16 C'est-à-dire que son objet enfant (ou attribut) « nom » est modifié.
nouvelle position, alors que leurs contenus respectifs eux continuent à rester tenus à jour par rapport à la source.
On vise d'étendre les outils actuels les plus répandus, de manière à ce qu'ils permettent de telles fonctionnalités de transclusion enrichie et d'ajout de relations.
L'invention prévoit notamment la mise en œuvre d'un éditeur (ou explorateur) d'objets présentant les objets de manière arborescente (dans le style des explorateurs de fichiers actuels) qui permette d'une part d'effectuer des transclusions enrichies, et d'autre part de créer des relations entre des objets (par exemple de relier un fichier se trouvant dans un répertoire (ou une vue de répertoire) avec un autre fichier se trouvant dans une autre répertoire dans la même arborescence - voir la figure 2), chaque relation donnant optionnellement lieu à un conduit de propagation de scores de pertinence. Par exemple, l'utilisateur créera des relations du type « commente » (i.e. tel objet est un commentaire de), « confirme », « contredit », « est contre », « est pour », « appuie »,
« affaiblit », « cause », « influence », « remplace », « rappelle », « similaire », « analogue »,
« vend » (i.e. tel objet représente les données concernant la vente de), « achète », « traduit »,
« explique », « corrige », etc. Ces relations pourront par exemple être présentées directement comme à la figure 2, ou encore sous forme de liens cliquables (comme par exemple des annotations cliquables) placés sur les objets.
Comme illustré aussi à la figure 2, un tel explorateur d'objets est apte à présenter des relations reliant un objet pris dans sa globalité à une partie d'un autre objet. Par exemple, un objet non présenté explicitement tel qu'une sélection d'une partie seulement d'un document (le document étant lui représenté par un icône17 dans l'éditeur d'objets) peut être relié avec un objet présenté explicitement tel qu'un autre document ou un répertoire. L'utilisateur pourra alors « zoomer » sur l'objet non présenté explicitement pour affiner la granularité de présentation.
Par ailleurs, des conduits de propagation de scores de pertinence sont en plus créés
(automatiquement ou explicitement par l'utilisateur, comme décrit plus loin dans ce rapport) entre les objets du Web (c'est-à-dire les pages Web) du domaine qui intéresse l'utilisateur.
Enfin des conduits sont placés (automatiquement, par exemple en mesurant la similarité de distribution de mots, ou manuellement par l'utilisateur) entre les objets du Web et les objets privés de l'utilisateur dont certains peuvent par exemple être transclus à partir d'objets privés d'autres utilisateurs. C'est ainsi que les scores de pertinence des objets du Web se propagent sur les objets privés de l'utilisateur1 . Des objets privés et/ou des objets du Web peuvent ainsi être estimés pertinents et seront alors présentés à l'utilisateur, en fonction de son contexte courant de navigation19 ou d'exploration d'objets.
Ainsi de nouveaux objets trouvés pertinents peuvent être automatiquement présentés dans le cadre d'un éditeur d'objets (tel qu'un explorateur de fichiers décrit plus haut ; par exemple de nouveaux documents peuvent être insérés dans la vue (enrichie) du répertoire R2). Afin d'indiquer en quoi ils sont pertinents, des relations de pertinence sont automatiquement placées avec des objets existants (la figure 2 illustre le placement automatique d'un objet pertinent et de ses relations dans le répertoire Rl/vue-de-R2/ R3).
On va maintenant détailler la description de ces aspects ainsi que d'autres aspects annexes.
Dans ce rapport, sauf sens contraire, quand on dit « utilisateur » on entend « utilisateur ou programme informatique ». Ainsi par « interface utilisateur », on entend « interface utilisateur ou interface programmatique ».
17 (avec un symbole -un petit carré blanc dans la figure 2- indiquant que la relation en question concerne une partie seulement de l'objet)
18 (qui peuvent inclure des objets transclus d'ailleurs)
19 Plusieurs méthodes de personnalisation en fonction du contexte de navigation sont présentés dans ce rapport.
Transclusion enrichie
L'utilisateur peut choisir de quelle façon le résultat de la transclusion doit être présenté, le cas trivial étant d'insérer la totalité du contenu. A l'autre extrême il peut demander à n'avoir qu'un lien hypertexte (et donc que le contenu ne soit accessible que par un clic sur le lien). L'utilisateur peut demander que certaines transformations soient effectuées sur le contenu des sources avant20 qu'il ne soit inséré dans l'objet à présenter. Il peut choisir une transformation dans une liste pré-établie (qu'il peut compléter selon les besoins), par exemple appliquer une fonction qui sélectionne les n premiers caractères de chaque objet source.
L'utilisateur peut également définir les transformations à effectuer en agissant directement sur le résultat de la transclusion, en utilisant l'outil de manipulation de contenu approprié21 (l'outil qu'il utiliserait s'il voulait modifier la source). Lorsque l'utilisateur modifie ainsi directement le résultat d'une transclusion, les résultats des actions qu'il effectue (tel élément est supprimé, le contenu de tel autre est modifié, un autre encore est déplacé et modifié...) sont enregistrés afin de pouvoir appliquer ces transformations automatiquement la prochaine fois que l'objet est affiché ou mis à jour. Par exemple si l'utilisateur échange deux parties d'un objet transclu, lorsque le contenu de cet objet se modifie à la source, les deux parties vont conserver leur nouvelle position mais leur contenu va toujours correspondre à celui de la source.
On appelle version courante d'une transclusion (ou « vue courante »), la représentation du résultat de la transclusion, telle qu'il a été présenté la dernière fois. Cette version courante est conservée, et est mise à jour par le système à chaque fois que l'utilisateur y accède.
A chaque transclusion est de plus associé un objet des différences (ou « objet diff »), qui indique la ou les sources de cette transclusion, ainsi que les transformations à y appliquer. L'objet des différences s'appuie sur la version courante22 et n'a ainsi pas besoin de contenir « in extenso » les contenus et les positions des objets à transformer.
Voici un exemple qui illustre comment pourrait être représenté un objet des différences :
<diff id="8 : 1 " ref="document7#7"> <FirstSentences id≈"8:l" count="3" keepChildren≈ "true" /> <Modify id="8:2" /> <Move id="8:3" /> <Modify id="8:6:4:3" /> <Move id="8:6:4:3" /> <Create id="9" /> <Transclude id="10:23" /> </diff>
Le nœud diff indique la source (ref) et le résultat (id) de la transclusion (ou l'identifiant de la transclusion elle-même). A noter que la source peut être identifiée par une référence ou une requête.
Ensuite tous les enfants de ce nœud diff indiquent les transformations à appliquer sur la source de la transclusion. Les identifiants « id » se réfèrent à la version courante de la transclusion. FirstSentences est un opérateur qui sélectionne les premières phrases du contenu d'un objet. Modify indique que le contenu de l'objet doit être remplacé (le nouveau contenu étant stocké dans la version courante).
20 Selon les cas, ces transformations pourront avantageusement s'effectuer au niveau de la source afin d'éviter de transférer des données inutiles.
21 (tel que Word, voir section « Modifier le résultat d'une transclusion »)
22 L'objet des différences se réfère aux objets de la version courante (c'est-à-dire à leurs identifiants respectifs) pour définir les transformations qui leurs sont appliquées.
Move indique que l'objet a été déplacé (la nouvelle position étant également stockée dans la version courante).
Create crée un nouvel objet (dont le contenu et les éventuels enfants se trouvent dans la version courante).
Transclude indique une nouvelle transclusion au sein de la transclusion en question et se réfère donc à un autre objet des différences (l'attribut id="10:23" étant l'identifiant du résultat de la transclusion (ou de la transclusion elle-même), auquel est associé un autre objet diff).
Cet exemple montre que pour déplacer et modifier un même objet (8:6:4:3) on place deux opérateurs dans l'objet des différences. Tous ces opérateurs sont implantés dans des modules et de nouveaux types d'opérateurs peuvent être ajoutés au système afin d'étendre ses possibilités. Dans cet exemple, FirstSentences a été sélectionné par l'utilisateur dans une liste (extensible) d'opérateurs au moment de la transclusion ou par la suite en l'y associant. Les transformations
Move, Modify et Create ont été créées par l'utilisateur en agissant directement sur les objets, de même manière que s'il modifiait une version locale (le procédé le permettant est décrit plus loin à la section « Manipulation d'objets »).
L'utilisateur peut demander que le contenu de la source d'une transclusion ne soit pas du tout inclus, mais qu'un simple lien hypertexte soit placé comme résultat, pointant vers la ou les sources. L'objet des différences, dans ce cas, ressemblerait à ceci :
<diff id="18:23" ref="documentl3#19" > <JustHyperLink text="click hère" /> </diff>
A noter que, étant donné que la présentation du résultat ne dépend plus du contenu de la source et ne doit plus être mis à jour, cet objet des différences pourra en général être omis. En fait on ne traite pas différemment un lien hypertexte placé directement et une transclusion présentée sous forme de lien.
Relation sémantique associée à une transclusion
A chaque transclusion peut être associé d'office une relation sémantique liant le résultat de la transclusion à sa source, et exprimant la nature des changements effectués sur le contenu. Par défaut, il s'agit d'une relation d'équivalence, c'est-à-dire que le sens de ce contenu n'est pas affecté.
De plus, l'utilisateur a la possibilité d'ajouter une autre relation sémantique qui s'applique d'un contenant direct ou indirect du résultat de la transclusion, à sa source.
La figure 3 présente une transclusion dont la source est l'objet obtenu dans un annuaire, représentant l'auteur d'un document, et dont le résultat est placé dans ce document (et transformé de sorte à ne montrer qu'une photo23). Il peut être avantageux pour l'utilisateur (en particulier lorsqu'il effectuera des recherches, comme décrit plus loin) de placer la sémantique « auteur » à cette transclusion. Dans ce cas il demandera d'appliquer la relation au document lui-même.
A noter que, du point de vue de l'interface utilisateur, l'ajout ou les manipulations d'une transclusion et des relations qui y sont associées peuvent se faire en utilisant un groupe unifié
(intégré) de moyens graphiques interactifs.24
23 Dans la figure 3, une relation « Equivalence » est présentée. Celle-ci est proposée par défaut lors de toute transclusion, cependant elle peut être modifiée quand la sémantique du résultat de la transclusion est modifiée.
24 Bien que dans les figures les relations sont présentées (par des flèches) comme des entités séparées des transclusions, elles y sont associées et peuvent d'ailleurs être mises en œuvre sous forme d'attributs de ces dernières. Ainsi dans l'exemple ci-avant, Equivalence et Auteur seraint des attributs de la transclusion décrite. Cette approche se distingue par le fait qu'elle consiste à utiliser les transclusions comme support des relations. L'interface utilisateur permet de spécifier la transclusion et la relation sémantiαue dans le cadre d'une même opération. Néanmoins, l'ajout
La nature de la relation sera à choisir dans une liste préexistante de sémantiques possibles (liste pouvant être étendue selon les besoins).
Enfin, l'utilisateur peut souhaiter n'avoir qu'une relation sémantique entre deux objets, sans pour autant modifier l'apparence des objets concernés.
La figure 4 représente un objet représentant un article de loi et un autre objet étant un commentaire juridique de cet article de loi. Si l'utilisateur souhaite informer le système de cette relation sans pour autant modifier l'apparence de ces objets, il va effectuer une transclusion du commentaire juridique dans l'article de loi (au point « X » dans la figure 4), sélectionner la relation sémantique souhaitée (« commenté par »), et demander que le résultat de la transclusion soit « non présenté » (et donc naturellement supprimer la relation d'équivalence du résultat de la transclusion). Ce qui revient à appliquer une transformation qui supprime la totalité du contenu de l'objet.
Alternativement il peut demander à n'avoir qu'un lien hypertexte25, comme expliqué précédemment. A noter que l'interface utilisateur permet ainsi dans le cadre d'une seule interaction (consistant à définir une transclusion) de spécifier tant le lien hypertexte que la relation sémantique ajoutée.
Il peut arriver que l'utilisateur souhaite placer une relation sémantique entre deux objets auxquels il n'a pas accès en écriture (par exemple deux pages Web A et B, A étant par exemple26
« contredit par » B - voir figure 5). Le système ne lui permet donc pas, dans ce cas, de le faire directement (puisqu'il n'a pas le droit de modifier le contenu de A). L'utilisateur peut cependant créer27 une transclusion (A') de l'objet relié A de la relation souhaitée, et le système placera, comme déjà dit, une relation d'équivalence de A' à A. L'utilisateur pourra ensuite effectuer une transclusion « non présentée » (B') de la source (B) dans A'. Il peut ensuite, par cette transclusion, ajouter la relation sémantique souhaitée de A' (en tant que contenant de B') à B. Il aura indirectement obtenu le résultat souhaité : de « A' est équivalent à A » et « A' est contredit par B », le système pourra inférer que « A est contredit par B ».
Le procédé de transclusion, avec les possibilités de transformation et d'ajout de sémantique, recouvre l'ensemble des types de relation donnés en exemple en introduction. On pourra s'en servir pour modéliser toutes les relations rencontrées.
Caractérisation sémantique des objets
Les objets d'information peuvent eux-mêmes être caractérisés sémantiquement. La caractérisation sémantique d'un objet consiste à indiquer au système quelle(s) information(s) cet objet présente (c'est-à-dire « de quoi cet objet parle »). Ceci peut se faire en indiquant des mots clés (ou un texte descriptif), ou encore en créant des relations avec des objets représentant des propriétés sémantiques. Cette dernière approche est facilitée en instanciant des concepts structurés28 qui offrent l'avantage de mieux structurer l'information ajoutée. La sémantique associée aux objets et
d'une relation à une transclusion est facultative et on peut donc définir une relation sans l'associer à une transclusion (par exemple lorsqu'on caractérise sémantiquement un objet, comme décrit à la section suivante).
25 L'interface utilisateur de visualisation des objets présentera alors le lien hypertexte ainsi que par exemple l'intitulé de la relation sémantique en question. L'interface utilisateur (ou programmatique, notamment dans le cadre d'un service Web) pourrait aussi présenter cette relation sémantique dans le cadre d'un graphe de ressources (par exemple selon l'une des recommandations RDF ou OWL du W3C) et permettre à l'utilisateur (ou un programme) d'y naviguer de ressource en ressource. Ainsi dans l'exemple de la relation auteur entre un document et la ressource qui représente son auteur, l'interface permet de naviguer du document vers son auteur puis de là vers l'adresse de l'auteur ou encore vers les autres documents du même auteur.
26 On a pris ici la relation « contredit par » mais bien entendu n'importe quelle relation aurait pu être prise pour illustrer cet exemple.
27 Plus loin dans ce rapport on dira que l'utilisateur crée une « ressource dérivée » ou une « page dérivée ».
28 Le terme « concept » ou « concept structuré » peut être vu comme étant synonyme de « classe » au sens RDF, mais c'est une classe associée à des mots-clés ou à une gamme de distributions de mots, comme on va maintenant le décrire.
aux relations permet alors de répondre à des requêtes d'objets ayant des propriétés sémantiques données.
On va maintenant décrire une méthode permettant d'aider (et d'inciter) à caractériser sémantiquement un objet. Il s'agit d'une méthode d'identification de « formulaires » (ou analogue) à partir de mots clés. L'intérêt de cette méthode est qu'elle encourage l'utilisateur, qui associe à un objet (par exemple un article trouvé dans le cadre d'une veille documentaire) des mots clés ou un texte descriptif, à préciser d'avantage la caractérisation de l'objet en question, en lui présentant automatiquement des « formulaires » appropriés qu'il doit remplir. Cette méthode comprend les étapes suivantes : 1. l'utilisateur donne au moins un mot clé (ou un texte descriptif) pour décrire l'objet en question 2. puis, a) — approche directe — dans le cas où au moins un concept est associé29 à ce (ou à un parmi ces, ou à un sous-ensemble représentatif de ces) mot(s) clé(s) (ou à la distribution de mots de ce texte descriptif), b) ou — approche indirecte — dans le cas où au moins un concept est associé à au moins bl. un autre objet déterminé, par un procédé de détermination d'objets pertinents à partir de mots ou de texte, comme étant pertinent par rapport audit mot-clé (ou audit texte descriptif), b2. ou encore dans le cas où au moins un concept est associé à au moins un autre objet déterminé, par un procédé de détermination d'objets pertinents à partir d'un ensemble d'objets de départ, comme étant pertinent par rapport à un (ou des) objet(s) déterminé(s) selon l'étape bl, le système lui propose ledit (ou lesdits) concept(s) associé(s) pour caractériser sémantiquement l'objet à caractériser ; 3. ensuite pour chaque concept associé sélectionné par l'utilisateur, ce dernier caractérise l'objet en question en l'instanciant et en renseignant ses propriétés30, par exemple en remplissant simplement des champs dans un formulaire associé audit concept associé sélectionné.
Approche directe
Un exemple illustrant le cas a) est le suivant :
L'objet à caractériser est un document concernant une jurisprudence. L'utilisateur utilise donc le mot clé «jurisprudence » pour le caractériser. Le système reconnaît alors le concept auquel ce mot clé a été associé (supposons que par exemple le mot «jurisprudence » soit le libellé même du concept en question). Un formulaire de recueil d'informations complémentaires31 est ainsi associé à ce concept. Le système propose alors à l'utilisateur de remplir ce formulaire pour préciser et compléter l'information : quel est le type d'objet du conflit, qui est le demandeur, qui est le défendeur, quelle est la juridiction, à quelle date la décision a été rendue, etc.
Approche indirecte
On va maintenant décrire le cas b).
Tout d'abord, rappelons qu'il existe déjà des techniques permettant de retrouver des objets d'information à la volée en fournissant au système des mots ou des phrases (ou simplement de retrouver des objets à partir de mots clé, grâce à un index). On exploite la disponibilité d'un système mettant en œuvre une telle technique.
29 (directement ou via un synonyme)
30 On utilise ici le terme propriété au sens de RDF.
31 II s'agit par exemple d'un éditeur de propriétés RDF d'une ressource donnée.
On part de l'idée qu'au moins certains de ces objets (proposés par un tel système) ont déjà été eux-mêmes caractérisés, quel qu'en fut le moyen. Via ces objets, le cas échéant, le système peut alors retrouver • les concepts qui les ont caractérisés, • les concepts qui ont caractérisé les objets proches (obtenus par exemple par propagation de scores le long des relations, comme décrit plus loin).
Il les propose donc à l'utilisateur et ce dernier peut ainsi caractériser l'objet en question en renseignant (par exemple dans des formulaires ou encore au moyen d'un éditeur RDF) les propriétés de ces concepts.
L'utilisateur crée ainsi des relations entre l'objet à caractériser et les objets correspondant aux propriétés renseignées (dans le « formulaire » en question). Comme toutes les relations, elles seront susceptibles de propager des scores de pertinence comme décrit par la suite dans ce rapport.
Manipulation d'objets
Les objets peuvent être créés, modifiés et supprimés, en utilisant les outils habituels de l'utilisateur. L'utilisateur peut aussi créer, modifier et supprimer des résultats de transclusion et des relations sémantiques entre différents objets, comme décrit à la section précédente. Finalement il peut directement agir sur le contenu du résultat d'une transclusion de la même manière que sur le contenu local.
Au niveau de l'interface utilisateur, l'opération de transclusion peut être mise en oeuvre par une opération de glisser-déposer. Par exemple, la sélection d'une partie d'une ressource (visualisée dans le cadre d'un outil de manipulation de ressources tel que Word, Excel ou Frontpage, ou encore dans le cadre d'un explorateur de répertoires et fichiers) étant faite, le glisser-déposer en tenant le bouton droit de la souris appuyé entrainera la présentation d'un menu (menu contextuel) dans lequel l'utilisateur pourra choisir l'option "Transclure ici". Avant de présenter le résultat de la transclusion (à l'emplacement cible du glisser-déposer), le système proposera à l'utilisateur de choisir une transformation (par exemple en XSLT, en particulier dans le cadre de Frontpage) parmi un ensemble de transformations disponibles le cas échéant pour d'emblée modifier la présentation (l'adapter) à cet emplacement. Ensuite l'utilisateur pourra encore modifier le résultat de la transclusion interactivement comme déjà décrit...
Réifier une sélection
Une sélection pourra être "réifiée". Réifier une sélection est la définir comme étant un objet (au sens d'objet identifié, comme défini en introduction). L'avantage essentiel que présentent les sélections réifiées est qu'elles peuvent être distinguées des autres sélections et qu'elles incitent ainsi à la réutilisation. On pourra avantageusement mettre en oeuvre une option selon lequel le système réifie automatiquement toute sélection qui sert de source de transclusion ou qui est reliée (par une relation parmi un ensemble de types de relation spécifiés au préalable) ou selon encore d'autres critères (notamment en évitant les recouvrements). L'utilisateur pourra ainsi éviter de recréer une sélection qui avait déjà été créée sur la même partie de la ressource ou presque (en particulier ceci est important pour tirer parti des conduits de propagation de scores reliant cette ressource aux autres).
Présentation des sélections réifiées à l'utilisateur
Une poignée intitulée "sélection réifiée" -ou tout autre moyen distinctif que l'on assimilera ici à une telle poignée- peut être affichée au niveau de la sélection pour permettre de la repérer. Un bouton ou une option de menu est offerte dans la barre d'outils pour afficher (ou alternativement cacher) toutes les poignées "sélection réifiée" d'une ressource visualisée, le but
étant bien sûr de pouvoir sélectionner une sélection réifiée préexistante (s'il en existe au moins une).
On présente maintenant un procédé qui consiste a réifier par l'utilisateur une sélection et un autre procédé qui consiste à l'utiliser comme source de transclusion.
Procédé de réification
La sélection se fait classiquement en glissant la souris de manière à couvrir la partie sélectionnée, le bouton gauche étant appuyé (ceci a classiquement pour effet de mettre la partie sélectionnée en évidence); ensuite la réification proprement dite se fait en cliquant sur une option de menu présentée dans la barre d'outils, ou bien en appuyant sur le bouton droit de la souris celle-ci devant préalablement être positionnée sur la sélection en question.
En variante, la réification peut se faire directement dans le cadre de l'opération même de sélection: en glissant la souris de manière à couvrir la partie sélectionnée le bouton droit étant appuyé (ce qui aura pour effet de mettre la partie sélectionnée en évidence) et en sélectionnant l'option "Réifier" dans le "menu contextuel" (classiquement affiché lorsque l'on utilise le bouton droit de la souris).
Une poignée "sélection réifiée" s'affiche alors au niveau de la sélection pour servir de repère. Il est utile de distinguer les sélections réifiées effectivement utilisées (notamment celles qui servent de source à une transclusion ou qui sont reliées par des relations étant d'un certain type parmi des types spécifiés au préalable) des autres sélections, et surtout de celles qui ne servent pas du tout. En effet, l'utilisateur pourra ainsi plus facilement réutiliser de préférence celles qui servent déjà et éviter ainsi d'encombrer la ressource en question. Celles-ci pourront être distinguées par des moyens graphiques et, pour alléger la présentation, sous le contrôle de l'utilisateur, le système pourra supprimer automatiquement les sélections réifiées qui n'ont pas servi à la fin d'une session ou par exemple après une période de temps donné.
Transclusion par "click&drag"
Etape "click"
Le fait de cliquer sur une poignée "sélection réifiée" a pour effet de sélectionner l'objet qu'elle désigne (et de faire mettre en évidence par le système la sélection correspondante, c'est-à-dire typiquement faire mettre en "inverse vidéo" la partie en question de la ressource visualisée). Dans une mise en oeuvre particulière, dans le cas où l'utilisateur ne clique pas directement sur une poignée "sélection réifiée" mais à son voisinage, le système identifie et lui présente la sélection réifiée la plus proche (géographiquement) dans la ressource visualisée (ceci nécessite cependant de basculer dans un mode spécial). Dans une mise en oeuvre particulière aussi, sur demande de l'utilisateur le système pourrait identifier automatiquement la (ou les) sélection(s) réifiée(s) les plus pertinentes, c'est-à-dire qui correspondent) le plus à son "profil utilisateur" (comme décrit à la section « Méthode de Personnalisation »).
Etape "drag"
Ensuite un simple glisser-déposer (ou opération équivalente) de cette sélection permet de la transclure vers un autre emplacement.32
32 Par exemple l'utilisateur peut ainsi transclure une partie d'un article visualisé dans Word au moyen d'un glisser déposer vers une page Web visualisée dans Frontpage. Dans ce dernier outil, avant de présenter le résultat de la transclusion le système lui proposera de choisir une transformation (en XSLT) parmi un ensemble de transformations disponibles pour la présentation à cet emplacement. Ensuite l'utilisateur pourra encore modifier le résultat de la transclusion interactivement comme déjà décrit.
Modifier le résultat d'une transclusion
On va maintenant décrire des procédés permettant de modifier le résultat d'une transclusion en utilisant un outil usuel de manipulation de documents. Prenons le cas de Word. Cet outil offre une interface programmatique (API) de « suivi des changements » qui donne toutes les modifications effectuées sur un document et de manière ordonnée: ce qui a été inséré, supprimé, les modifications de propriété de style, etc. Pour chaque modification d'un objet contenu dans le résultat d'une transclusion, on met à jour l'objet diff qui lui est associé. Une modification de type insertion est insérée dans l'objet diff directement, sauf quand il s'agit de l'insertion d'un nouveau résultat de transclusion, auquel cas l'objet diff est mis à jour par le moyen de transclusion lui- même sans passer par le suivi des changements (qui lui ne verrait qu'une insertion classique). Une modification de type suppression est mémorisée, car à ce moment on ne peut savoir s'il s'agit d'un déplacement, une modification ou une suppression pure et dure; ce sont les modifications ultérieures qui vont permettre de le savoir.
Dans le cas où un suivi des changements ou une journalisation n'est pas offerte par l'outil en question, on met en œuvre des algorithmes de comparaison du résultat par rapport à la source. Des approches mixtes dans lesquelles les informations de journalisation servent à lever les ambiguïtés peuvent aussi être mises en œuvre.
Recherche d'information
Nous allons à présent considérer divers moyens de trouver des objets, qui peuvent être utilisés simplement pour trouver de rinformation ou pour définir la source d'une transclusion. Deux types de recherches d'informations sont utilisés : 1. Les recherches explicites, qui cherchent des objets possédant certaines propriétés 2. Les recherches opérant par propagation de score, qui, à partir d'un ensemble d'objets de référence, cherchent les objets «proches » ou « fortement liés » à cet ensemble (ces notions seront détaillées ci-après). Lesdits objets de référence peuvent être constitués par le contexte de navigation (voir section « Contexte de navigation ») ou d'exploration d'objets par l'utilisateur (par exemple les objets d'un répertoire sélectionné).
Etant donné que le deuxième type de recherche part d'un ensemble d'objets il est souvent intéressant de combiner les deux types d'algorithmes, en cherchant tout d'abord un ensemble d'objets possédant certaines propriétés (c'est-à-dire par recherche explicite) puis en cherchant les objets proches de ceux-là (par propagation de scores).
Recherche explicite
On peut avoir trois sortes de propriétés présentes dans une requête : - le cas trivial, où les identifiants des objets sont directement donnés - le contenu (par exemple recherche par mots clés) - les objets liés par relations sémantiques (par exemple pour trouver un document écrit par une certaine personne)
Une requête pourra donc combiner plusieurs propriétés, par des opérateurs booléens.
Recherche par propagation de score
Le procédé de recherche par propagation de score se base sur un réseau de conduits de propagation de scores (appelés plus brièvement « conduits » 33 par la suite). En voici une brève description (étendue plus loin à la section « Réseau de conduits »).
Le réseau de conduits est un réseau orienté dont les sommets sont des objets et les arêtes sont des conduits auxquels est attachée une valeur numérique appelée grosseur.
33 On appelle dans la suite un conduit entre 2 objets, une aptitude à propager un score de pertinence d'un objet vers l'autre. La capacité de propagation est appelée grosseur du conduit.
Une requête est constituée d'un ensemble d'objets pondérés par des valeurs numériques34. Une valeur positive indique une « source de score » et une valeur négative un « absorbeur de score ».
Chaque objet distribue son score le long de ses conduits sortants (réparti en fonction de leurs grosseurs). Une source de score produit du score pour elle-même. Un absorbeur de score diminue son score spontanément.
Le procédé cherche à donner des scores à chaque objet de telle sorte que chaque objet reçoit et crée autant de score qu'il en détruit et en donne, c'est-à-dire qu'on cherche une situation d'équilibre.
La requête (l'ensemble des sources et absorbeurs de score) décrit le domaine où l'utilisateur souhaite obtenir des résultats (donc les objets que l'utilisateur souhaite avantager ou désavantager), les conduits représentent des relations de pertinence (un conduit de A à B signifie que si A est intéressant alors B le sera aussi, dans une certaine mesure qui est indiquée par la grosseur de ce conduit). Le résultat trouvé par le procédé correspond donc aux objets qui sont pertinents par rapport à la requête, selon le réseau de conduits. En effet, un objet ayant des conduits entrants à partir de nombreux objets pertinents pour une requête doit être pertinent lui également.
Voici l'équation utilisée par le procédé pour recalculer le score d'un objet :
xi est le score de l'objet . L'exposant + représente la valeur après mise à jour. s; est la valeur de la source ou de l'absorbeur de score pour l'objet (zéro si i n'est pas une source ou un absorbeur de score).
S≈Σ si c'est-à-dire la somme des valeurs des sources et absorbeurs de scores. lij est la grosseur du conduit de i kj, zéro en l'absence de conduit.
Les conduits peuvent être obtenus par plusieurs moyens.
Tout d'abord une relation sémantique (comme décrit plus haut) indique implicitement une relation de pertinence, en fonction de la nature de cette relation. Le plus évident est la relation d'équivalence car si l'un de deux objets équivalents est intéressant dans un certain contexte, l'autre le sera aussi. Des relations sémantiques plus distantes telles que « auteur de » indiquent également une relation de pertinence (en effet, si un document est pertinent pour une requête alors potentiellement son auteur l'est aussi et ensuite les autres documents qu'il a écrit le sont alors aussi), il faudra cependant que les conduits créés pour ces relations soient moins gros que ceux d'une relation d'équivalence. A chaque type de relation sémantique sera donc associé une grosseur de conduit.
Plus généralement une transclusion indique une certaine relation de pertinence, même en l'absence de sémantique explicite ; ceci est particulièrement utile dans le cas des liens hypertextes entre pages web, car le système est ainsi capable d'analyser le web automatiquement, sans autre intervention.
Le système peut être étendu, en fonction des applications, avec d'autres « poseurs de conduits », c'est-à-dire des fonctions qui produisent des conduits entre objets.
On peut placer des conduits entre objets qui sont cocités, c'est-à-dire liés (par des liens hypertextes ou éventuellement d'autres sortes de transclusions) simultanément depuis d'autres objets. En effet, si presque toutes les pages contenant un lien vers une page A contiennent également un lien vers une page B, on peut en déduire une relation de pertinence (symétrique) entre A et B. Par exemple la grosseur du conduit de cocitation entre deux pages peut être égale (à une pondération près comme expliqué plus loin) à la proportion de liens entrants en commun de ces deux pages.
De même (de manière symétrique), on peut choisir de placer des conduits entre objets qui citent de mêmes objets, dont la grosseur est égale à la proportion (pondérée) de liens sortants en commun.
34 L'absence de pondération revient à une pondération pr- défaut.
Un autre façon encore de faire est de se baser sur la distribution de mots dans les objets : on place un conduit entre deux objets possédant une distribution similaire, et dont la grosseur croît avec la similarité. Typiquement on utilisera cette méthode pour poser des conduits entre des pages Web publiques et des documents privées, de manière à propager vers ces dernières les scores de pertinence obtenus automatiquement pour les pages Web publiques.
Enfin il peut être intéressant de placer (automatiquement, par un poseur de conduits dédié) des conduits entre des objets et leurs contenants. En particulier des objets à leurs contenants, comme le montre l'exemple suivant : Si un document regroupe un certain nombre d'objets et que la majorité de ces objets a obtenu un bon résultat pour une certaine requête, il est bien de présenter directement le document parent. En plaçant des conduits de ces enfants au document parent, les enfants donneront du score à ce dernier, qui se retrouvera avec un meilleur score qu'un enfant pris isolément.
Une difficulté est qu'il faudra pour chaque type de relation sémantique donner la grosseur de conduit à y associer, et pour chaque poseur de conduit donner la pondération de ses conduits vis- à-vis des autres poseurs. Ces pondérations représentent l'importance en termes de pertinence de ces différentes sortes de conduits.
Plutôt que d'associer une grosseur unique pour chaque type de relation sémantique, on peut associer un intervalle, et ensuite permettre à l'utilisateur, lorsqu'il place une telle relation, d'indiquer l'intensité de cette relation (par exemple sur une échelle graduée avec cinq intensités possibles). Plus la relation est forte plus la grosseur est élevée.
A noter qu'il faudra en général que les différents poseurs de conduits produisent des conduits de largeur bornée afin d'éviter qu'un conduit ne devienne disproportionné par rapport aux autres. C'est la raison pour laquelle, par exemple, pour les cocitations il vaut mieux utiliser un rapport qu'un nombre de cocitations, qui lui n'est pas borné.
Normalisation
Afin que le réseau ainsi construit puisse atteindre un équilibre il est important que la quantité de score envoyé par un objet via ses conduits sortants soit égale au score de cet objet, autrement dit que la quantité totale de score soit conservée. Ceci est assuré en exigeant que la somme des grosseurs des conduits sortant d'un objet soit égale à un (à noter qu'il n'est pas nécessaire que la somme des grosseurs des conduits entrants soit égale à un pour un objet particulier.) Afin d'obtenir ce résultat, on commence par placer tous les conduits sans normalisation, puis, pour chaque objet on calcule la somme s des grosseurs de ses conduits sortants. On ajoute ensuite depuis cet objet vers tous les autres (y compris vers lui-même) des conduits « conduits de normalisation » dont la grosseur est égale à (l-s)/«, n étant le nombre total d'objets. La nouvelle somme des conduits sortants pour cet objet sera ainsi égale à s+n(l-s)/n donc 1. Il est ainsi possible d'avoir des cas (lorsque s dépasse 1) où ces conduits de normalisation ont une grosseur négative, ce qui signifie que l'objet va donner du « score négatif », donc en fait prendre à tous les autres. Il est cependant important d'interdire qu'un conduit particulier possède une grosseur plus grande que 1, car, bien que la quantité de score totale reste conservée, un objet au bout d'un tel conduit serait avantagé d'une manière disproportionnée car il recevrait du début de ce conduit plus de score que ce début n'en possède.
Du point de vue implémentation, il n'est pas nécessaire de réellement placer ces conduits de normalisation ni même de les considérer de manière séparée, étant donné qu'à chaque itération il y aura une certaine quantité de score à partager de manière équitable à tous les objets. Il suffit en fait de ne calculer que la somme de ces « valeurs résiduelles » et en ajouter une n-ième partie à tous les objets lorsque tous les conduits normaux ont été traités - la valeur résiduelle d'un objet étant le produit du complément de sa valeur s et de son score : avant qu'il ne soit recalculé : (1- s)*x.
Il faut donc faire attention à ne pas introduire de déséquilibre entre différentes régions du réseau, en ayant tendance à mettre des conduits de grosseur élevée en moyenne dans une région, et d'en
moyenne plus faible dans une autre. En effet ceci aurait pour conséquence que la première région « vole » du score à la seconde et obtienne donc des scores en moyenne plus élevés également. On peut faire un algorithme qui détecte ces régions automatiquement et équilibre les grosseurs de conduits afin de diminuer le problème.
Variante préférée
Une autre façon d'obtenir une normalisation des conduits sortants est la suivante. Chaque objet conserve sont score résiduel au lieu de le distribuer parmi tous les objets, c'est-à- dire qu'on ajoute de chaque objet vers lui-même un conduit de grosseur 1-s, s étant toujours la somme des grosseurs des conduits sortants. Le problème de cette manière de faire est que les objets n'ayant aucun conduit sortant vont voir leur score augmenter jusqu'à ce que les scores des objets qui les alimentent directement ou indirectement soient épuisés.
Cependant ce problème ne se pose pas lorsqu'on utilise des sources de scores, par exemple pour traiter une requête, car les sources vont exploiter le score de tous les objets, puisqu'à chaque itération le score de chaque objet est multiplié par 1-S, S étant la somme des sources de score, ceci pour maintenir une somme des scores constante (voir plus haut l'équation utilisée par le procédé pour recalculer le score d'un objet). Ceci signifie donc que tous les objets contribuent à alimenter chaque source de score.
Scores absolus
Lorsqu'on souhaite obtenir des scores de manière absolue (sans requête particulière), on peut placer une source de score à chaque objet (donc à chaque itération chaque objet distribue une partie - la même pour tous les objets - de son score à tous les autres). Ceci aura pour effet d'assurer que chaque objet possède un score non nul, et donc de maintenir les différences entre les différents objets, par opposition au cas sans sources de scores, où des régions entières peuvent se retrouver avec des scores nuls comme expliqué plus haut, et donc où les différences entre objets disparaissent.
Echelle globale
On peut donc placer les grosseurs de chaque type de conduit sur une échelle globale. Dans le cas de grosseurs calculées automatiquement (cocitations, similarité de distribution de mots etc.) ces valeurs déterminent la pondération à donner aux résultats de ces calculs pour atteindre des valeurs comprises entre les minima et maxima souhaités.
Voici un exemple d'échelle globale :
Relation « équivalent à » : 1
Relation « pertinent par rapport à » : entre 0.5 et 1
Conduits calculés en comptant les cocitations : entre 0.3 et 0.6
Relation « auteur » : 0.2
Conduits placés le long des liens hypertextes : 0.1 Toute autre relation : 0.03
Méthode de personnalisation
On va décrire une méthode pour modifier le résultat d'une requête en fonction des intérêts moyens de l'utilisateur (son profil).
Profil de l'utilisateur
On peut représenter le profil de l'utilisateur sous la même forme que le résultat d'une requête, avec un score pour chaque objet (en pratique, lors de l'utilisation d'autorités pour optimiser le calcul d'une requête, il est suffisant de garder le score de chaque autorité pour l'utilisateur.)
Ce profil est en fait une moyenne pondérée de l'intérêt de l'utilisateur, le poids diminuant plus on va vers le passé. L'intérêt présent peut être estimé en considérant les objets consultés par l'utilisateur et les requêtes qu'il effectue (donc quand l'utilisateur effectue une requête les scores des résultats seront aussi les scores des objets dans son intérêt présent. Si on se sert également des objets visités par l'utilisateur, ceux-ci peuvent être considérés comme des requêtes et le même traitement peut être effectué.) La pondération est effectuée en faisant une moyenne entre l'intérêt moyen de l'utilisateur à l'instant précédent et l'intérêt présent de l'utilisateur. Si on note P(i) le score de l'objet i dans le profil de l'utilisateur, et p(i) le score de l'objet i dans l'intérêt présent de l'utilisateur, alors P(i) sera mis à jour avec s P(i) + (1-s) p(i), s étant le facteur de pondération (constante donnant le « poids du passé » ; cette valeur peut dépendre de l'information utilisée pour déterminer l'intérêt présent. En particulier, une requête de l'utilisateur laissera un poids plus faible au passé qu'une simple visite de page.35)
En pratique il suffit de ne stocker dans le profil que les objets ayant un score suffisamment plus grand que zéro, et considérer un objet absent du profil comme ayant un score nul. Ceci permet d'éviter d'avoir un profil trop volumineux et donc nécessitant trop de calcul à chaque étape.
Profil de chaque objet
De même que pour l'utilisateur on peut associer à chaque objet un profil qui est le score des autres objets par rapport à lui. Ce résultat s'obtient en appliquant l'algorithme de recherche par propagation de score à une requête contenant cet objet uniquement.
A noter que l'optimisation utilisant des autorités décrite plus loin va de toute façon calculer et tenir ce profil à jour.
Score d'un objet par rapport au profil de l'utilisateur
On peut ainsi calculer le score d'un objet par rapport au profil de l'utilisateur en effectuant une somme des produits, pour chaque objet, de son score dans le profil de l'objet testé et dans le profil de l'utilisateur.
Sélection d'option en fonction du profil de l'utilisateur
Un objet peut avoir des enfants facultatifs, donc qui ne doivent être affichés que si le système juge qu'ils correspondent au profil de l'utilisateur. Il peut également avoir des enfants exclusifs entre eux, c'est-à-dire des groupes d'objets dont celui qui correspond le plus au profil de l'utilisateur sera être affiché.)
On dit qu'un objet correspond au profil de l'utilisateur lorsque le score de cet objet par rapport au profil de l'utilisateur est grand.
Etant donné qu'en général (c'est-à-dire en l'absence de relations de ou vers eux) les enfants d'un objet n'auront pas des profils très différents les uns des autres, l'auteur de cet objet peut influencer ces profils en plaçant des relations sémantiques liant ces enfants à des objets représentant des propriétés sémantiques ou à des autorités.
Algorithmes utilisés pour les transclusions
Une fois que les modifications apportées par l'utilisateur au contenu du résultat d'une transclusion ont été détectées et enregistrées dans un objet des différences, il s'agit d'appliquer ces modifications à une version mise à jour de la source (tout en se servant de la version courante pour avoir les contenus et positions des objets modifiés). On va tout d'abord décrire certains concepts du point de vue implémentation, puis décrire un certain nombre d'algorithmes qui permettront d'actualiser chaque transclusion de la version courante.
35 Cette approche est maintes fois reprise et détaillée plus loin.
On décrira tout d'abord un « algorithme local » qui permet de déterminer le contenu et la position d'un certain objet, puis un « algorithme global » qui permet, en s'appuyant sur l'algorithme local, de construire un objet et tous ses descendants.
H suffira alors, pour mettre à jour une version courante, d'appeler l'algorithme global sur la racine de cette version courante.
Identifiants
Chaque objet possède un identifiant. Les objets créés localement possèdent un identifiant atomique, qui est un nombre entier unique dans le système.
Chaque transclusion possède également un identifiant atomique, unique également.
Les objets vus à travers une transclusion possèdent un identifiant composite, noté A:B, où A (la tête de cet identifiant) est l'identifiant de la transclusion, et B (la queue de cet identifiant) est l'identifiant de l'objet à la source de cette transclusion.
On utilise des parenthèses pour clairement délimiter la tête et la queue en cas de besoin. En l'absence de parenthèses, les sous-identifiants s'étendent le plus à droite possible. Par exemple,
1:2:3:4 doit être lu 1:(2:(3:4)). Autre exemple, si A=l:2 et B=3:4 alors A:B=(1:2):3:4.
Transclusions
Une transclusion A est ici considérée comme d'une part un ensemble d'objets « vu à travers » A, et d'autre part à un ensemble de modifications concernant ces objets. Ces modifications incluent • modification ou suppression d'un objet vu à travers A (donc dont l'identifiant commence par « A: ») • déplacement d'un objet vu à travers A, dont le parent avant et après déplacement est également un objet vu à travers A. • création d'un objet (créé localement ou vu à travers une transclusion différente de A) comme enfant d'un objet vu à travers A. • déplacement d'un objet vu à travers A comme enfant d'un objet créé ou vu à travers une transclusion différente de A. Un cas particulier est le suivant : lorsque l'utilisateur effectue une transclusion, l'algorithme, pour effectuer cette opération, va d'abord créer la transclusion mais à cet instant cette dernière n'est pas encore accessible (car aucun objet vu à travers cette transclusion n'est encore placé comme enfant d'un objet accessible.) La seconde étape n'est alors rien d'autre qu'un déplacement d'un de ces objets inaccessibles comme enfant d'un objet accessible.
A noter qu'en cas de déplacement d'un objet d'une transclusion à une autre ou de création d'une transclusion dans une autre transclusion, cette modification sera « partagée » par deux transclusions.
Par convention, on dit qu'une transclusion implicite ne contient aucune modification. En effet, on dira que de telles modifications seront traitées par la transclusion par laquelle cette transclusion implicite est venue. Par exemple si un objet ((1:2):3):4 est modifié, cette modification sera associée à la transclusion 1.
Transclusions implicites, transclusions internes
Lorsque le résultat (l'objet 3:2 dans l'exemple de la figure 7) d'une transclusion (3) est visible à travers une transclusion (4), on dit que l'image de ce résultat (4:3:2) est une transclusion implicite (4:3) de la source (4:2) de la première transclusion, et cette première transclusion (3) est appelée transclusion interne à la seconde.
Dans cet exemple (figure 7), l'image (4:2) de la source (2) de la transclusion interne est également visible à travers la transclusion (4), mais ce n'est pas toujours le cas. Dans le cas contraire, la source de la transclusion interne sera simplement invisible. L'exemple de la figure 6 (ou la figure 1) en donne une conséquence concrète.
Dans cet exemple, on peut dire que 4:3:2 est une transclusion indirecte de 2, car les modifications appliquées sur 2 seront indirectement transmises à 4:3:2.
Lorsque cette structure est vue à travers la transclusion 5, la transclusion indirecte est maintenue, bien qu'elle transite par un objet invisible (5:3:2). Ainsi, des modifications appliquées à 5:2 seront répercutées sur 5 :4:3 :2.
Equivalence d'identifiants
L'existence d'un objet peut parfois être obtenue par plusieurs chemins, en présence de transclusions implicites. Dans l'exemple de la figure 7, 4:3:2 est à la fois l'objet 3:2 vu à travers la transclusion 4, et l'objet 4:2 vu à travers la transclusion 4:3. En considérant la seconde manière, on obtient l'identifiant (4:3):4:2 (on place des parenthèses afin de clairement identifier la tête de cet identifiant).
En pratique, on va considérer ces deux identifiants comme équivalents, et plus généralement que pour tous A, B, C, (A:B):A:C est équivalent à A:B:C. Etant donné que cette équivalence est difficile à vérifier dans le cas général, on peut utiliser la méthode suivante (plus générale).
On appelle la densité « d » d'un identifiant le polynôme défini comme suit : d(x)=dx, si x est un identifiant atomique, d(A:B)=s d(A) + (1-s) d(B) (s est un symbole sans valeur numérique définie.)
Deux identifiants sont considérés équivalents si et seulement si leurs densités sont égales.
Un algorithme de simplification de polynômes consiste à remplacer tous les produits de sommes par des sommes de produit, puis pour chaque x à regrouper les termes en dx.
Par exemple, d(4:3:2)=s d(4) + (1-s) d(3:2)=s d4 + (1-s) ( s d(3) + (1-s) d(2) )= s d4 + (1-s) ( s d3 + (1-s) d2 )= s d4 + (s-s2) d3 + (l-2s+s2) d2.
De même, la densité de l'autre forme de cet identifiant est la suivante : d((4:3):4:2V= s d(4:3) + (1-s) d(4:2) = s ( s d4 + (1-s) d3) + (1-s) ( s d4 + (1-s) d2) =
(s-s2) d3+s (^ - (s-s2) d4+(l-2s+s2) d2= (s-s2+s2) d4 + (s-s2) d3 + (l-2s+s2) d2.
Les deux formes ont donc bien la même densité, comme prévu.
Sources d'un objet
Chaque objet peut posséder un ensemble de sources, qui est l'ensemble des objets dont il est l'image par une transclusion, implicite ou non. A chaque source est associée la transclusion correspondante.
Par exemple, 4:3:2, dans l'exemple ci-dessus, possède deux sources, 3:2 et 4:2, par les transclusions 4 et 4:3, respectivement.
Si A est une source de B par la transclusion C, alors l'identifiant de B est équivalent à C:A. On peut donc noter l'ensemble des sources d'un objet par un ensemble de formes de son identifiant, tel que la queue de chacune de ces formes est une source, et la tête est la transclusion correspondante.
Pour l'exemple de la figure 7, on va noter l'ensemble des sources pour 4:3:2 par 4:(3:2) et
(4:3): (4:2) (les parenthèses supplémentaires ne sont placées que pour raisons de clarté.)
Le calcul de l'ensemble des sources d'un objet peut s'effectuer à partir d'une source de cet objet
(comme cet objet aura été obtenu par une transclusion on connaît déjà une paire transclusion: source) .
Soient Si les sources de la source considérée (S), soient Ti les transclusions correspondantes, et soit T la transclusion telle que T:S est l'objet étudié.
L'ensemble complet des sources de l'objet est alors T:Si, et les transclusions associées sont T:Ti.
Il faut bien sûr encore y ajouter T:S. Grâce à l'équivalence des identifiants le résultat ne dépend pas de la première paire T:S choisie.
Information présente dans un objet
A chaque objet est associé deux types d'informations : sa position et son contenu36.
La position d'un objet est donnée par son parent et son prédécesseur (le prédécesseur n'étant utilisé que pour déterminer la position de l'objet parmi les enfants de son parent).37
Il sera nécessaire, comme on le verra plus tard, de connaître l'origine de ces informations (entre autre si l'objet les a modifiées localement ou s'il les a obtenues par une source).
Plus précisément, Y origine d'une information est une expression définie comme suit :
La notation ! A signifie qu'une information a été créée localement par l'objet A.
La notation A:B, où B est l'origine d'une information, représente une information d'origine B, qui a ensuite encore transité par la transclusion A.
Par exemple, 1:2:!3:4 doit être interprétée comme suit : une information a été créée par l'objet
3:4, puis a transité par la transclusion 2 (ce qui donne l'origine 2:!3:4), puis a transité par la transclusion 1.
Chaque objet va stocker, sous cette forme, l'origine de son contenu et l'origine de sa position.
A noter que si on enlève le point d'exclamation de l'origine d'une information on obtient (une forme de) l'identifiant de l'objet qui contient cette information.
Calcul d'un objet
Lorsque l'image d'un objet par une transclusion n'a pas été modifiée (respectivement déplacée) par cette transclusion, les informations présentes dans cet objet (position, respectivement contenu) seront obtenues par une des sources (le calcul de la position et du contenu s'effectuent indépendamment).
Voici tout d'abord comment le calcul du contenu est effectué. Entre crochets se trouve une numérotation des étapes.
Soit {Tj.'Sj} l'ensemble des paires transclusion: source d'un objet, et soit { !Oj} les origines des contenus de ces sources (C,!Oj est l'origine du contenu de Si, Ci est le chemin parcouru par ce contenu, et O; est l'objet dont le contenu a été ainsi hérité.) [local 1]
Dans l'exemple de la figure 7, supposons que 3:2 et 4:2 ont été modifiés. 2 étant créé localement, définit également son contenu.
L'origine du contenu de 2 est donc !2, l'origine du contenu de 4:2 est !4:2 et l'origine du contenu de 3:2 est !3:2. (si 4:2 n'avait pas été modifié localement il aurait hérité du contenu de 2 et l'origine de ce contenu aurait été 4:!2.)
Connaissant les sources et les origines des contenus de ces sources il s'agit à présent de choisir de quelle source l'objet considéré doit hériter son contenu. Ce choix s'effectue en donnant une priorité aux chemins Ti:Ci des contenus de ces sources (voir section « Calcul de priorités de chemins » ci-après), [local 2]
Supposons que TJ:CJ est le chemin choisi, alors l'origine du contenu de l'objet considéré sera
Tj:Cj!Oj, c'est-à-dire qu'on prolonge simplement le chemin Cj de cette origine avec la transclusion
Tj correspondant à la source Sj choisie, [local 3]
Dans l'exemple de la figure 7, les paires transclusion: source de 4:3:2 sont 4:(3:2) et (4:3):(4:2).
Les origines des contenus de ces sources sont !3:2 et !4:2, donc les deux Cj sont vides. Le chemin
(4:3): ayant priorité sur le chemin 4:, l'origine du contenu de 4:3:2 sera (4:3):!4:2.
36 Dans un cadre XML, l'objet est un élément et son contenu en est l'« innertext » ; en effet les attributs et les éléments enfants sont considérés ici comme étant des objets enfants (contenus dans l'objet en question) donc traités à leur tour comme des objets ayant chacun un contenu et une position. Cependant les attributs présentent des contraintes supplémentaires, comme par exemple le fait que l'algorithme devra fusionner un même attribut provenant de deux sources différentes.
37 Dans le cadre de la description de l'objet des différences donnée précédemment, si un objet est modifié localement, respectivement déplacé localement, l'objet des différences informera de ce fait, et le contenu ainsi que la position eux-mêmes seront obtenus par la version courante (mais d'autres moyens de stocker ces informations sont bien entendu possibles).
Une fois obtenue l'origine Tj:Cj!Oj du contenu, la valeur de ce contenu est simplement égale au contenu de l'objet Oj. [local 4]
Le calcul de l'origine de la position d'un objet s'effectue de façon identique au calcul de l'origine de son contenu à la différence près, bien sûr, que les origines !Oj considérées sont les origines des positions de ces sources. Le parent et le prédécesseur de l'objet ne seront par contre pas égaux aux parent et prédécesseur de Oj, mais à leur image par le chemin Tj:Cj: Donc si le parent de Oj est P alors le parent de l'objet à calculer sera T C P, et de même pour le prédécesseur. Si le prédécesseur ainsi obtenu n'est pas un enfant du parent ainsi obtenu, alors cette information de prédécesseur sera ignorée (et l'objet sera par exemple placé à la fin de la liste des enfants de son parent), [local 5]
La figure 8 présente un exemple du comportement de cet algorithme, pour le calcul des positions des objets (étant donné que le calcul du contenu n'est pas détaillé ici, l'étape 4 n'apparaît pas).
A côté de chaque nœud se trouve l'origine de sa position.
Les objets 1, 2, 3 et 4 étant créés localement, ils donnent eux-mêmes leur position.
Similairement, le résultat de transclusion 5:1 donne également sa position, en fait il est également considéré comme déplacé38, car son parent n'est pas le correspondant par 5 du parent de 1 (pas montrés dans le schéma afin d'éviter de trop le charger.)
La transclusion 5 spécifie que 5:3 est déplacé comme premier enfant de 5:1.
5:4 possède une seule source qui est 4 par la transclusion 5 [local 1]. Son parent sera donc le correspondant par la transclusion 5 du parent (1) de 4, donc 5:1. De même, son prédécesseur sera
5:2 [local 2,3,5].
La position et l'origine de la position de 5:2 s'obtiennent de la même manière.
Ensuite, la transclusion 6 déplace les objets 6:5:1 et 6:5:4.
L'origine de la position de 6:5:2, dont l'unique source est 5:2 par la transclusion 6 [local 1], sera l'origine de la position de 5:2 (donc 5:!2) [local 2] étendu par 6, ce qui donne 6:5:!2 [local 3]. Son parent sera comme vu précédemment le correspondant par la transclusion 6 du parent (5:1) de 5:2, donc 6:5:1. Son prédécesseur sera le correspondant du prédécesseur 5:3 de 5:2, donc 6:5:3 [local
5]-
Le calcul de la position de 6:5:3 s'effectue de façon identique, son origine est l'origine de la position de sa source (!5:3) [local 1,2] étendue par la transclusion 6, ce qui donne 6:!5:3 [local 3].
Calcul de priorités de chemins
A partir d'un objet A, voici un procédé pour comparer deux chemins.
Si l'objet A vient par une série de transclusions Tl T2 T3 ete (A=T1 :T2:T3 ...), alors toute source d'information pour cet objet sera l'image de la même première source à travers un sous-ensemble de ces transclusions (ou de leurs images à travers une transclusion).
Le polynôme associé à un sous ensemble de ces Ti est obtenu si on remplace Ti par t1 et on effectue la somme de tous ces termes. Par exemple le sous ensemble Tl T3 donne le polynôme t+t3.
Une source est prioritaire par rapport à une autre si le polynôme associé à l'ensemble des Ti qui la sépare de l'objet dont elle est une source est plus grand que le polynôme correspondant de l'autre source, pour t trè ^s grand i.39
38 En effet, chaque fois qu'une transclusion est créée, l'algorithme de construction de l'objet des différences devra placer dans cet objet des différences l'information que la racine du résultat de cette transclusion est déplacée. Explications : On définit le terminateur comme le nombre qui vient en dernier dans un identifiant. Par exemple le terminateur de 2:3 est 3, le terminateur de (4:5):((3:(8:9):5):(4:(7:11))) est 11, le terminateur de 5 est 5.
Soit O l'objet dont on veut chercher une source. Soit Ci:Si les différentes sources (Si est la source et Ci le chemin, Ci:Si est équivalent à O). On fais l'hypothèse que O est sous la forme Tn : T(n-l) : ... : T2 : Tl : S, où les Ti sont des transclusions d'identifiant atomique. S est l'objet tout au bout de la chaîne, atomique aussi. On peut "reconnaître" les Ti dans chaque Ci:Si en regardant le terminateur de chaque élément de Ci:Si. Par exemple (4:3:2):4:3: 1 :S a quatre éléments si on ignore le S, et ces éléments se terminent respectivement par 2,4,3 et 1. (O serait 4:3:2:1 :S dans ce cas, donc, et T1,T2.. = 1,2..) Ainsi on peut voir
Détermination des objets à calculer
Nous avons vu comment calculer la position et le contenu d'un objet (« algorithme local »), il reste encore à savoir, à partir d'un objet demandé (par exemple la racine de la version courante), quels objets calculer afin d'en obtenir la structure développée (avec tous les descendants.) Cet algorithme (« algorithme global ») va provoquer un calcul de tous les objets pouvant se retrouver comme descendants de l'objet demandé. Afin d'éviter des calculs répétitifs (et dans un certain nombre de cas afin d'éviter que algorithme ne boucle), il faut stocker, pour chaque objet, s'il a déjà été atteint respectivement par l'algorithme local ou global. Lorsqu'un de ces algorithmes rencontre un objet qu'il a déjà traité, il va simplement ne rien faire. Si l'objet demandé est créé localement (possède un identifiant atomique), il connaît la liste de ses enfants, donc il suffit de continuer l'algorithme global sur chacun de ces enfants l'un après l'autre. Entre crochets se trouve une numérotation des étapes.
Si l'objet demandé est l'image d'un autre objet par une transclusion il faut recalculer avec l'algorithme local les objets suivants : • L'objet lui-même (afin d'obtenir son contenu) [global 1] • Pour chaque source (dans le cas de transclusion implicite), les images de tous les descendants de cette source par la transclusion correspondant à cette source [global 2] • L'ensemble des objets créés et déplacés par la transclusion [global 3].
Enfin, on continue l'algorithme global pour chacun des enfants ainsi obtenus pour l'objet étudié
[global 4].
Voici comment l'algorithme global va calculer la structure développée de 4: 1 dans la figure 9 : 1. 4:1 est obtenu à travers une transclusion. On applique l'algorithme local sur 4: 1 pour en obtenir le contenu [global 1]. 2. 4:1 possède une seule source, 1, par la transclusion 4. On va donc recalculer l'image par 4 de tous les descendants de 1, donc 4:3:2, 4:2, 4:6, 4:3:5 et 4:5 [global 2]. 3. 7 est le seul objet créé ou déplacé par 4, on le recalcule [global 3]. 4. Les descendants ainsi obtenus pour 4:1 sont 4:3:2, 4:2, 4:6, 4:3:5, 4:5 et 7. On continue l'algorithme global sur chacun d'eux [global 4]. 5. 4:3:2 est l'image d'un objet par une transclusion. L'algorithme local n'a pas besoin d'être appelé sur lui car c'est déjà fait [global 1]. 6. L'ensemble des paires transclusion: source de 4:3:2 est 4:3:2 et (4:3):(3:2). On va donc appeler l'algorithme local sur les descendants de 3:2 vu à travers 4, puis sur les
dans un chemin Ci quelles transclusions Ti y sont utilisées, en regardant les terminateurs. Par exemple si Ci = 1:(2:3): alors ce chemin emprunte la transclusion 1 et la transclusion 3 (en fait une image de cette transclusion). On ne travaille donc plus avec des chemins mais avec des ensembles de transclusions, avec des sous-ensembles de {Tl..n}. Trois règles permettent de déterminer la priorité:
1) Si un chemin est un prolongement d'un autre alors le second a priorité. (Donc A sous-ensemble de B implique A a priorité sur B. En particulier le chemin vide (création locale) aura toujours priorité.)
2) Si A utilise une transclusion que B n'utilise pas, et que toutes les transclusions utilisées par B sont prioritaires par rapport à cette transclusion alors B est prioritaire. ( Ti est prioritaire (plus proche) à Tj si i<j. Par exemple T2 est plus proche et donc plus prioritaire que T4. Donc un chemin qui emprunte T2 et T3 sera prioritaire par rapport à un chemin qui emprunte T4, par exemple. Autre exemple, un chemin qui passe par T3 et T4 sera prioritaire à un chemin qui passe par T2 et T5, à cause de T5 qui est moins prioritaire que tous les éléments dans {T3, T4} .)
3) Si A et B ont une transclusion en commun, on peut retirer cette transclusion du chemin, et la relation de priorité sera préservée. Par exemple si A = {T2, T3, T8} et B = {T4, T8}, on peut retirer T8 de chaque côté.
Pour représenter cela, on pourra utiliser des polynômes, en faisant la somme, pour chaque transclusion de l'ensemble, de t à la puissance i, i étant le numéro de cette transclusion. Par exemple A = {T2,T3,T8} donne +r'+t8 et B = {T4.T8} donne t4+t8. Le polynôme le plus grand quand t est très grand représente le chemin le plus long, donc le moins prioritaire. Par exemple t +t8 > t2+t3+t8 quand t est grand. On peut le vérifier en faisant la différence, en simplifiant puis en regardant le signe du terme de plus haut degré. t4+t8 - ( rV+t8 ) = t4 - 13 - 12.
Quand on n'arrive pas à rendre tous les éléments de O atomiques, on peut parfois reconnaître ces éléments dans les sources (si les terminateurs sont tous différents), et alors on devrait placer les éléments non atomiques avant tous ceux qui en partagent des parties. Par exemple (a:b) devrait être placé avant a et avant b, s'il y a des a et des b. "avant" signifie ici dans l'ordre Tl...Tn, donc plus prioritaire.
descendants de 3:2 vu à travers 4:3. Tous ont déjà été faits sauf (4:3):7 (qui va donc être ajouté comme enfant de 4:3:2, l'image par 4:3 du parent 4:2 de 7.) [global 2] 7. L'algorithme va maintenant continuer la descente de la structure développée de 4: 1 sans découvrir de nouveaux enfants, avant de se terminer.
Réseau de conduits
La présente invention permet à un utilisateur de créer des relations de pertinence40 entre un premier objet41 et d'autres objets, afin de pouvoir retrouver le premier objet simplement en accédant à au moins un objet pertinent par rapport au premier objet.
Ledit (ou lesdits) objet(s) pertinent(s) par rapport au premier objet peu(ven)t être, non seulement l'un (certains) desdits autres objets que l'utilisateur a relié(s) au premier objet, mais aussi : • un (des) objet(s) ayant une relation de pertinence avec le premier objet, créé par un autre utilisateur dans un réseau de relations de pertinence partagé entre ces deux utilisateurs, • un (des) objet(s) pour lequel (lesquels) le premier objet est automatiquement estimé pertinent au moyen de règles d'inférences42 qui s'appliquent sur les relations de pertinence ainsi créés, • un (des) objet(s) pour lequel (lesquels) le premier objet a un score de pertinence élevé qui a été déterminé automatiquement par le procédé en assimilant les relations de pertinence à des capacités de propagation de score de pertinence d'un objet vers l'autre (c'est-à-dire à des conduits).
En plus des relations de pertinence créés par les utilisateurs eux-mêmes, le procédé utilise des conduits créés automatiquement à partir des interrelations et/ou du contenu des objets. Ainsi le procédé crée automatiquement des conduits notamment 3 • entre les objets cocités44, • entre les objets liés par des liens hypertextes, • entre les objets ayant des distributions proches de mots.
Ces conduits sont créés notamment entre les pages Web susceptibles d'intéresser les utilisateurs. Enfin, des conduits (ou des relations de pertinence) entre des objets du Web et des objets privés (e.g. les documents de l'entreprise) sont créés et permettent ainsi de propager vers ces derniers les scores de pertinence des objets du Web (les pages Web) qui sont calculés automatiquement en analysant la structure des liens et le contenu de ces derniers. Ainsi, en exploitant tous ces conduits, le procédé permet à l'utilisateur : • de retrouver lesdits premiers objets ; • comme l'utilisateur peut partager un réseau (de relations de pertinence et de conduits) avec d'autres utilisateurs, le procédé permet à l'utilisateur de découvrir lesdits premiers objets qui sont expressément reliés par d'autres utilisateurs au sein du réseau partagé ; • enfin le procédé permet à l'utilisateur de découvrir d'autres objets pertinents parmi les objets privés ou publics (e.g. sur le Web) auxquels de bons scores se sont propagés via des conduits placés automatiquement.
Retrouver/découvrir un objet en accédant à (i.e. en visitant ou en sélectionnant expressément) des objets pertinents se fait par exemple dans les scénarios suivants.
Certains outils (de la famille des éditeurs de texte) tels que « OneNote »® de Microsoft, offrent à l'utilisateur la notion de « contenant » permettant de regrouper des objets.45 On peut imaginer dans ces outils l'existence d'une fonction supplémentaire d'enrichissement automatique de contenants par des objets pertinents46 supplémentaires suggérés par le procédé. On peut en effet
voir les éléments qui se trouvaient dans les contenants avant enrichissement, comme des objets pertinents par rapport auxdits premiers objets, c'est-à-dire comme une requête au système mettant en œuvre le procédé47. La plupart des applications basées sur des contenants peuvent être munis d'une telle fonctionnalité d'enrichissement automatique.
D'autres outils permettent à l'utilisateur de tracer, entre des ressources d'information, des relations de pertinence et éventuellement de préciser en quoi consiste cette pertinence (en spécifiant des relations dites sémantiques). Cette pratique est fréquente notamment dans les activités de « Veille Stratégique » (voir l'illustration de la figure 11).
On peut imaginer qu'avec de tels outils l'utilisateur puisse retrouver/découvrir un objet, simplement en visitant ou en sélectionnant des objets pertinents par rapport à lui ou en manipulant leurs relations. Il peut s'agir d'un objet dont il avait déjà pris connaissance ou pas. Le procédé relie les objets proposés par le système avec ceux que l'utilisateur est en train de visiter. Tracer des relations entre objets peut se faire de l'une des manières suivantes : • en indiquant explicitement au procédé les identifiants des objets en question, ou en accédant d'abord à un premier objet puis en indiquant au procédé l'identifiant d'un autre objet (pour spécifier sa relation au premier) ; • ou peut se faire au sein d'un document, via une transclusion de chaque objet que l'on veut relier, c'est-à-dire en créant dans un document des références vers les objets en question puis en traçant des relations entre ces références dans le document même, au moyen d'un éditeur ; • ou encore de manière mixte (éditeur vers objet ou objet vers éditeur).
La figure 11 (qui consiste en une variante de la figure 2) illustre de telles relations présentées (et rendues manipulables) dans un éditeur spécialisé typique que l'on propose d'utiliser dans une activité de veille stratégique sur l'Internet. Chaque bloc (rectangle) pourrait représenter une transclusion enrichie par exemple à partir d'une page Web. En cliquant sur un bloc on peut visualiser la page Web qu'il représente (ceci n'est pas illustré dans la figure 11). En cliquant sur chacune des flèches (qui représentent une relation de pertinence) l'utilisateur peut préciser de quelle relation sémantique il s'agit, et la sémantique donnée apparaîtra alors lorsque l'on positionnera le curseur de la souris sur la flèche en question (ceci n'est pas non plus illustré dans la figure 11).
Toute relation sémantique peut être une relation de pertinence et à de nouvelles relations de pertinence (ou conduits) dérivées automatiquement, de la sémantique peut être ajoutée manuellement ou au moyen de règles paramétrables par l'utilisateur. L'utilisateur peut ainsi découvrir de nouvelles relations sémantiques, mises en évidence par le procédé. Le résultat du procédé est un ensemble de nouveaux objets (de nouveaux blocs sont ajoutés à la figure 11) pertinemment reliés avec les objets visualisés par l'utilisateur (des flèches relient ces nouveaux blocs avec les blocs existants).
Le résultat du procédé doit être ordonné d'abord en fonction du souhait de l'utilisateur (par exemple, les objets privés d'abord) et ensuite triés par score de pertinence (ce procédé est décrit plus loin).
Le procédé analyse le web et calcule des scores de pertinence pour les pages. Pour ce faire, il calcule un réseau de conduits. Un conduit entre deux pages exprime le fait que si la première est pertinente (pour la requête en cours ou dans l'absolu) alors la deuxième le sera aussi. Les conduits ont aussi une « grosseur » qui exprime l'intensité de cette propagation.
La grosseur de conduit par défaut entre deux pages du web est le nombre de liens entrants en commun à ces deux pages. Il est possible d'y ajouter (ou d'élargir) des conduits suivant les liens
47 L'utilisateur peut sélectionner les éléments d'un ou plusieurs contenants et demander au système de présenter d'autres éléments pertinents par rapport à eux.
hypertextes48 ou à partir de l'analyse de texte (par exemple on place entre deux pages un conduit dont la grosseur croît avec la ressemblance de leurs distributions de mots), ou encore par diverses autres méthodes. Notamment, l'utilisateur peut lui-même modifier ce réseau à souhait, en ajoutant/supprimant ces conduits ou en modifiant leur grosseur. Le procédé4 se prolonge à l'intérieur des documents de l'entreprise. Par exemple : • L'utilisateur peut ajouter un conduit à partir d'une page du web vers un document de l'entreprise, ou d'un document de l'entreprise à un autre. De manière générale, un conduit peut être placé de ou vers une sélection réifiée d'une partie de document ou de page. • L'utilisateur peut effectuer dans un document une transclusion dont la source est une sélection réifiée, ce qui va également créer des conduits dans les deux sens entre la source et le résultat de cette transclusion. • L'utilisateur peut mettre un conduit entre deux résultats de transclusion, qui sera par défaut50 remplacé par un conduit entre les sources respectives de ces transclusions.51 • Des conduits sont placés entre le Web et les documents privés selon leurs proximité de distribution de mots.
Dans la suite le mot « sélection » désignera tous les cas possibles de sélection réifiée d'une partie ou de l'ensemble du contenu d'un document ou d'une page52. Une sélection est donc bien un objet
(tel que définit au début de ce rapport) au sens où il est identifié. Ainsi, au lieu d'utiliser le terme
« objet » ou « ressource » on utilisera ici le terme sélection.
L'interface utilisateur lui permet de tracer, entre des sélections, des relations (comme illustré à la figure 11) et d'expliciter leur sens53 ; ces relations génèrent des conduits54.
A chaque fois que l'utilisateur visualise ou sélectionne au moins une sélection (indifféremment dans le web ou dans les documents de l'entreprise) il peut demander au système de lui présenter des sélections pertinentes, elles-mêmes également trouvées dans les documents de l'entreprise ou dans le web. L'utilisateur peut ainsi compléter son document en y transcluant une ou plusieurs sélections proposées par le système et en traçant ensuite dans le document des relations entre elles. Les sélections pertinentes présentées par le système peuvent être automatiquement reliées avec les sélections de la requête vis-à-vis desquelles elles sont les plus pertinentes.
L'utilisateur peut paramétrer l'ordre dans lequel les résultats lui sont présentés par défaut, en fonction de l'emplacement (par exemple que ses documents privés lui soient montrés avant les autres documents de l'entreprise, ou à l'inverse que les documents trouvés dans le web soient montrés en premier) et du score.
On introduit maintenant des fonctions particulières tirant parti des avantages apportés par le procédé de transclusion enrichie.
Le système peut être placé dans un mode client ou serveur. Lorsqu'il est en mode serveur il gère un réseau serveur, et lorsqu'il est en mode client il gère un réseau modifié qui est un ensemble de modifications apportées au réseau serveur d'un système particulier. Plusieurs utilisateurs peuvent ainsi maintenir des vues différentes d'un même réseau dans leurs systèmes clients respectifs55.
48 (de manière à avoir en plus l'équivalent de l'approche de l'algorithme bien connu PageRank ; on voit ainsi que le « Relevance Web » inclut le Web actuel)
49 Le mot « système » dans ce document sous-entend qu'il gère un seul réseau.
50 L'utilisateur peut choisir là où le conduit sera effectivement placé (au cas par cas ou en reconfigurant l'interface).
51 De manière générale, l'utilisateur peut mettre un conduit de ou vers le résultat d'une transclusion qui par défaut sera remplacé par un conduit de ou vers la source de cette transclusion ou de ses transclusions amonts s'il y'en a (cas de transclusions en cascade).
52 Par exemple la source et le résultat d'une transclusion sont des sélections ; les deux extrémités d'un conduit sont des sélections.
53 Comme déjà mentionné, de telles relation peuvent par exemple indiquer qu'une sélection corifirme/contredit/cause/mfluence/explique/cornmente/traduit/etc une autre sélection.
5 Les conduits sont créés selon des règles modifiable par l'utilisateur. En plus de ça on peut offrir aux utilisateurs avancés une API pour définir eux-mêmes des systèmes de calcul de grosseur de conduits, notamment en fonction de la sémantique du contenu des sélections ou des relations entre les sélections. 55 Voir section « Traiteur de Requêtes »
En mode client, l'utilisateur crée et maintient son réseau notamment par transclusion de sélections
(c'est-à-dire d'objets) dans des documents et en traçant des relations (ou directement des conduits) entre ces résultats de transclusion. Le réseau est maintenu grâce au fait que chaque conduit ainsi créé est en réalité créé dans le réseau, et une référence seulement en est insérée dans le document en question. Le réseau dans lequel le conduit en question est réellement créé peut être celui du système en mode client ou directement celui du système en mode serveur.
Un utilisateur peut mettre tout ou partie de son réseau à disposition d'autres utilisateurs (ses abonnés). Lorsqu'il modifie son réseau, ses modifications seront directement visibles et effectives chez ses abonnés.
Une requête représentant un ensemble de sélections peut elle-même être un nœud dans le réseau.
Des conduits la relient aux sélections ayant eu les meilleurs scores pour une exécution précédente de cette requête (leurs grosseurs étant fonction de ces scores). Ainsi, l'utilisateur peut tracer ou modifier des relations ou conduits à partir de ou vers un ensemble de sélections (ayant constitué une requête au système). A noter que la requête peut être exécutée soit au moyen de l'algorithme de calcul de score relatif exprimé ci-après, soit par une autre méthode, notamment par la méthode de distillation relative décrite dans ce rapport.
Dans le cadre de la présente description il est sous-entendu que chaque système gère un seul réseau. Néanmoins, une partie des conduits d'un réseau peut être importée d'un autre réseau et tenue à jour automatiquement à partir de cette dernière56. On présente dans la figure 10 une architecture57 en structure de graphe où le Web est crawlé par un système de base gérant un
« Réseau de base », duquel d'autres systèmes (Réseaux d'entreprises)58 importent des conduits et ajoutent des sélections et conduits qui leurs sont propres ; et à partir de ces autres systèmes, des réseaux personnalisés importent à leur tour des conduits qui peuvent être manipulés par les utilisateurs.
A noter qu'au niveau des réseaux personnalisés, des utilisateurs experts peuvent modifier le réseau de propagation de pertinence de manière à ce que le système donne de meilleurs résultats qu'un moteur purement automatique.
A noter aussi que dans le réseau de base, le crawling des parties du Web qui intéressent plus d'une entreprise peut être mutualisé entre ces dernières.
Ainsi dans la figure 10, la région notée « CRAWLED » représente la partie du réseau de base résultant du crawl d'un sous-ensemble du Web intéressant une entreprise; la région
« MUTUALIZED » représente la partie du réseau de base résultant du crawl d'un sous-ensemble du Web intéressant deux entreprises à la fois (ce qui offre l'avantage de la mutualisation du crawling de ce sous-ensemble par le système de base) ; la région « IMPORTED » représente la partie du réseau de l'entreprise composé des conduits importés du réseau de base ; la région
« ADDITIONAL » représente les conduits supplémentaires reliant les ressources de l'entreprise entre elles ainsi qu'avec des pages Web de la région IMPORTED.
Les méthodes de calcul de conduits et de scores sont en général neutres et uniformément appliqués dans le réseau de base ainsi que dans les réseaux des entreprises, tandis qu'elles peuvent être spéciales (i.e. personnalisés) dans les réseaux personnalisés. Certains résultats de requête peuvent être remis dans les réseaux personnalisés (comme introduit plus haut).
De manière générale, des conduits d'un réseau peuvent être importés de n'importe quel autre réseau59. Ainsi, certains conduits du réseau géré par un système donné60 peuvent être des références à des conduits de réseaux d'autres systèmes (leurs grosseurs étant ainsi calquées
56 Bien évidemment, pour des raison de performances seules les différences qui ont été apportés au réseau source seront notifiées (périodiquement) au réseau qui importe.
57 (non limitative)
58 II n'y a qu'une seule entreprise illustrée dans la figure 10.
59 Une partie d'un réseau peut être une transclusion enrichie d'une partie d'un autre réseau.
60 On parle ici en particulier de systèmes en mode serveur, mais des propriétés analogues sont prévues pour les systèmes en mode client (voir section « Traiteur de Requs+"ι »).
dynamiquement à partir de ces autres systèmes). L'utilisateur peut configurer les méthodes de combinaison des grosseurs des conduits61.
Il est à souligner que l'utilisateur d'un réseau personnalisé bénéficie potentiellement de tous les enrichissements effectués à l'amont dans le graphe, qui peuvent par exemple comporter des sélections sous forme de publicité .
Un utilisateur peut contribuer des modifications qu'il a faites de son réseau, vers l'amont dans le graphe, et le propriétaire du réseau à l'amont de la transclusion en question peut accepter ou non cette contribution. Les utilisateurs peuvent ainsi se communiquer des ressources pertinentes. Chaque système est apte à estimer lui-même la connaissance qu'il a du domaine de chaque sélection faisant partie d'une requête (ceci est décrit plus loin à la section « Le Distilleur »). Il peut ainsi décider de déléguer tout ou partie d'une requête à un système qui a la connaissance en question et avec qui il est connecté en Peer-to-Peer (comme décrit plus loin).
Principe du calcul de scores de pertinence
Voici le principe de la méthode utilisée pour calculer les scores des sélections à partir d'un réseau de propagation de scores (on notera ly la grosseur du conduit reliant la sélection i à la sélection y, égale à zéro en l'absence de conduit). On suppose que la somme des grosseurs des conduits sortant d'une sélection donnée est égale à un : Vi∑ly = 1
En première étape on initialise les scores de toutes les sélections de sorte à avoir une somme des ssccoorreess ééggaallee : à un : Vz.;t. (0) = — (n est le nombre de sélections sur lesquelles on démarre n l'algorithme).
Ensuite, l'approche est de recalculer le score de toutes les pages64 itérativement: Xj (t + 1) = ∑ly t (t)... et x, = limx, (t)
On va toutefois mettre ici en œuvre la notion déjà décrite de source de scores. Ceci permettra au système notamment de donner des scores relatifs à une requête65. Par exemple, à partir d'une requête consistant en un ensemble de sélections R on peut définir st, la source de score pour la
sélection i, de la façon suivante: ss =
(s étant ici une grandeur entre zéro et un qui exprime l'importance de la requête. Si elle vaut zéro, le résultat est indépendant de la requête et on retrouve le cas absolu, si elle vaut un seules les pages de la requête auront un score non nul) L'initialisation des scores est comme dans le cas précédent :
61 (provenant de transclusions mettant enjeu de mêmes conduits)
62 Ainsi, pour bénéficier de publicités « locales » en même temps que de publicités ciblées par rapport à ses domaines d'intérêt, l'utilisateur formera son système par transclusions à la fois à partir de réseaux « locaux » (au sens géographique) et de réseaux couvrant les domaines qui l'intéressent. 3 Si ce n'est pas le cas une normalisation est effectuée sur le réseau avant de passer à la première étape.
6 Et dans le cas où les valeurs oscillent et ne convergent jamais, l'approche serait d'utiliser un facteur d'inertie : *;(t + l) + CCCt (t) . L'inertie a est une constante entre zéro et un. 0 donne aucune
inertie (risque d'oscillation) et 1 empêche toute variation (de grandes valeurs ralentissent la convergence et 1 empêche toute convergence)
65 Dans la suite de la description on utilisera aussi l'approche par sources de score pour calculer des scores absolus (aussi décrit plus haut).
A chaque itération on ajoute la quantité j . au score de la sélection j. Afin de maintenir la somme des scores constante66 on va multiplier d'abord chaque score par une constante l égale au complément à un de s : 67 , (t + 1) = s Y l,.χ, (t) + s , et x. = lim x. (t) (On se reportera au début du présent rapport (section « Recherche par propagation de score » ) pour une variante du même procédé.) Exemple numérique Soit deux sélections a et b ayant un lien entrant en commun, a ayant un lien vers b et b ayant deux liens entrants en plus (voir figure 12). On prendra
et R={a}. On utilise ici les cocitations pour construire le réseau de propagation des scores présenté à la figure 13. a est cocité une fois avec lui-même (car il possède un lien entrant) et une fois avec b, et b est cocité une fois avec a et quatre fois avec lui-même (il possède quatre liens entrant en tout). Comme on l'a déjà décrit, plusieurs approches existent pour normaliser (pour obtenir une somme des grosseurs de conduits sortants égale à un). On va supposer qu'après normalisation on obtient un conduit de grosseur 0.5 liant a à lui-même, un conduit de grosseur 0.5 liant a à b, un conduit de grosseur 0.2 liant b à a et un conduit de grosseur 0.8 liant b à lui-même (voir figure 14). Les valeurs initiales de a et b sont 0.5 (pour cet exemple on ne travaille que sur a et b, donc n=T) . La mise à jour des scores se fera avec *fl (* + l) = £(/Ofl fl ( + ^Λ( ) + ' s'o et xb (t + 1) = s{labxa (t) + lbbxb (t))+ sb , donc xa (t + 1) = 0.25 • jcβ ( + 0.1 - jcό( + 0.5 et xb (t + 1) = 0.25 • xa (t) + 0.4 • xb (t) . . Voici les premières valeurs calculées par l'algorithme
On constate que les valeurs convergent. Si au lieu de prendre les conduits de cocitation on avait pris les liens hypertextes le réseau aurait été68 celui de la figure 15 (pour normaliser il y a un conduit de chaque sélection vers elle-même). On obtient laa = 0.5 et lab = 0.5, lba = 0 et lbb = 1 (voir figure 16). On va maintenant effectuer une moyenne pondérée entre le réseau de conduits le long des liens hypertextes et le réseau de cocitations (mais ici encore d'autres méthodes peuvent être envisagées). La moyenne de ce réseau avec l'autre -avec poids pour les liens et % pour les cocitations- donne/fla = 0.5 et lab = 0.5, lba = 0.15 et lbb = 0.85 (voir figure 17).
66 A noter qu'il serait inutile d'effectuer une étape de normalisation car contrairement à l'algorithme de calcul de scores absolus elle s'effectue implicitement par les termes 5. 67 De l'inertie peut être ajoutée de la même façon que dans l'équation précédente : x. (t + 1) = a I lijxi (t) + + ax,- (t) 68 On continue (pour simplifier) à supposer que l'algorithme s'exécute uniquement sur les pages a et b, i.e. on ne calcule pas les scores des trois pages possédant ces liens f;rs a etb.
Le reste de l'algorithme fonctionne de la même façon.
Avantages :
L'algorithme bien connu « PageRan » propage les scores uniquement le long des liens hypertextes. Propager les scores le long des conduits, par exemple s'ils sont calculés à partir des cocitations, favorise des sélections qui autrement n'auraient pas été proposées.
Considérons par exemple les deux cas extrêmes suivants :
Dans le premier cas une sélection est fortement cocitée avec une sélection possédant un bon score et dans le deuxième cas plusieurs sélections possédant un bon score possèdent un lien vers une même sélection.
Un algorithme (à la PageRank) suivant exclusivement les liens va bien fonctionner dans le second exemple mais pas dans le premier, et à l'inverse un algorithme utilisant exclusivement les cocitations fonctionnera bien dans le premier exemple mais pas dans le second.
Un algorithme mixte, c'est-à-dire permettant de propager le score tant le long des cocitations que des liens, découvrira les pages intéressantes dans les deux cas.
De manière générale la notion de conduit permet de combiner plusieurs méthodes de recherche de relations de pertinence (y compris les modifications manuelles) afin d'obtenir de meilleurs résultats.
Ainsi, pour chaque domaine où des utilisateurs experts ont offert leurs modifications du réseau de propagation de pertinence, le système donnera de meilleurs résultats qu'un moteur complètement automatisé.
La possibilité de combiner des conduits provenant de l'amont dans une architecture distribuée de réseaux sera ainsi particulièrement avantageuse.
Autres avantages :
Le réseau des conduits est indépendant des requêtes69. Des utilisateurs peuvent choisir de partager un même réseau et toutes les modifications apportées à ce réseau par différents utilisateurs peuvent être exploitées en même temps.
L'échange de réseaux entre utilisateurs est facilité par la mise en œuvre de transclusions : un utilisateur peut exploiter le réseau d'un autre utilisateur en en effectuant une transclusion dans un document se trouvant dans son système, et il peut ensuite le modifier, le réduire ou l'agrandir pour l'adapter à ses besoins, simplement en éditant le document contenant le résultat de la transclusion.
Les équations sont linéaires en s (i.e. les scores obtenus pour la combinaison linéaire de plusieurs requêtes seront égaux aux combinaisons linéaires correspondantes des scores obtenus pour les requêtes de base) ce qui signifie que des requêtes peuvent être décomposées en requêtes plus élémentaires qui peuvent ensuite être recomposées différemment. Ainsi on peut calculer et mémoriser ces requêtes élémentaires puis obtenir les résultats composites sans avoir à re-effectuer les calculs.
Par exemple dans un espace de sept sélections de 0 à 6, soient trois requêtes RÎ=(1 ; 2 ; 3), R2=(
5 ; 6) et R3 = (1 ; 2 ; 3 ; 5 ; 6) (en prenant s=0.5). Leurs valeurs s,, respectives sont ( 0 ;/6 ; % ; ; 0 ; 0 ; 0), ( 0 ; 0 ; 0 ; 0 ; 0 ; ; ) et ( 0 ; Xo ; X0 ; X0 ; 0 ; o ; Xo).
On observe que les s,- de R3 sont une moyenne pondérée des s,, correspondants pour R\ et R2
(avec et X comme pondération, respectivement). Par linéarité, les scores xt pour R3 sont la moyenne avec les mêmes pondérations des x,- correspondants de R! et R2.
La linéarité est notamment utilisée dans la présentation des résultats à l'utilisateur et dans le procédé de délégation en Peer-to-Peer décrit plus loin.
On décrit plus loin (voir « algorithme de calcul relatif optimisé ») que pour éviter d'avoir pour chaque requête à effectuer l'algorithme itératif décrit plus haut de calcul de scores, on se base sur
69 Chaque réseau représente la pertinence des sélections chacune par rapport à chaque autre, pour un utilisateur ou pour un ensemble d'utilisateurs, quelles que soient ses requêtes. Néanmoins, des réseaux différents (pour des centres d'intérêt différents) peuvent être créés par (ou pour) de "^mes utilisateurs.
un ensemble de sélections « autorités » ayant des scores absolus élevés. Le score d'une sélection pour une requête donnée peut être obtenu en calculant pour chaque sélection de la requête la quantité de score xa qu'elle enverrait à chaque sélection autorité, puis on faisant la moyenne des scores xa pondérée par les scores obtenus par ces sélections a. Donc, en précalculant pour tous les a les distributions de scores xa et xa , les scores des pages peuvent être calculés très rapidement.
Présentation des résultats à l'utilisateur
On a décrit comment le système calcule les scores relatifs des sélections à partir d'un ensemble de sélections (c'est-à-dire une requête) données par l'utilisateur (cette requête étant prise dans sa globalité). On va maintenant décrire comment le système peut, quand il présente le résultat de la requête, tracer des relations de pertinence le cas échéant entre chaque sélection du résultat70 et chaque sélection de la requête prise séparément. Les étapes sont les suivantes71 :
1. Le calcul des scores relatifs se fait par rapport à toutes les sélections de la requête prises ensemble (comme déjà décrit).
2. On ne garde que les sélections ayant les plus grands scores, et on recalcule leurs scores par rapport à chaque sélection de la requête (prise séparément comme une requête en soi). On a ainsi pour chaque sélection de la requête les scores de chaque sélection du résultat.72
3. On relie chaque sélection de la requête avec chaque sélection du résultat ayant un score suffisant par rapport à elle (la grosseur de la relation ainsi tracée73 est fonction de ce score).
Contexte de navigation
La notion de contexte de navigation peut être utilisée au moment de donner des sélections pertinentes à l'utilisateur. Le contexte de navigation est l'ensemble des sélections que l'utilisateur a vues ou sélectionnées assorties d'un poids décrivant l'importance qu'elle a dans le contexte présent.
Lorsque l'utilisateur ne retourne pas voir les anciennes sélections leurs poids diminuent au fil du temps, lorsque l'utilisateur effectue une requête sur un ensemble de sélections leurs poids augmentent etc.
La prise en compte du contexte se fait, à chaque requête de l'utilisateur, en effectuant une moyenne pondérée entre le contexte et sa requête avant de la traiter.
Etant donné que les sources de scores dans une requête doivent s'additionner à 1, on exigera que la somme de tous les poids dans un contexte soit toujours 1.
Voici un exemple d'une façon de calculer le contexte :
• Lorsque l'utilisateur visionne une sélection on multiplie le poids de toutes les sélections du contexte par une constante (exprimant le poids du passé dans le contexte) et on augmente le poids de la sélection visionnée par le complément de cette constante (exprimant l'importance des sélections simplement vues)
• Lorsque l'utilisateur envoie une requête, les poids de toutes les sélections du contexte sont multipliés par une constante et on augmente (toujours dans le contexte) le poids de toutes les sélections constituant la requête de sorte à compenser la multiplication. Le résultat est à la fois le nouveau contexte et la requête envoyée au système.
• Le contexte est initialement vide, et la première modification que l'utilisateur y apporte doit donner un poids nul au passé.
70 (le résultat ne contient que les sélections ayant les plus grands scores)
71 Ce procédé est performant lorsque l'on utilise l'algorithme relatif optimisé décrit à la section « Le Distilleur ».
72 En variante on peut prendre des sous-ensembles de la requête.
73 (par exemple l'épaisseur du trait si l'on trace une flèche pour représenter cette relation)
Etant donné que toutes les opérations effectuées sur le contexte peuvent être exprimée sous forme linéaire ( C+ = λC + λA , avec la somme des poids dans Δ égale à 1), et par la linéarité des algorithmes utilisés, il est possible de mémoriser les scores dus au contexte et après ne calculer que les scores dû au deuxième terme Δ. Les scores peuvent ensuite être combinés au contexte en utilisant la même pondération λ.
Exemple numérique :
L'utilisateur visionne une sélection 1, le contexte donne 1 -> 1 (le passé n'a pas de poids à cette première étape puisqu'il qu'il n'existe pas ; et on donne le poids 1 à cette sélection pour que la somme des termes dans Δ vaille 1).
L'utilisateur effectue une requête pour les sélections 2 et 3. Le terme Δ est l'ensemble des sources de scores, c'est-à-dire {2 -> X;3 ι-> χ}(comme expliqué avant, leur somme doit valoir 1). En donnant un poids au passé lorsqu'on fait des requêtes de 0.25 le nouveau contexte est
{lh^ X;2ι→ %;3h- χ}.
L'utilisateur visionne ensuite a sélection 2. En donnant un poids au passé lorsqu'on visionne de
0.75 le nouveau contexte est {l i- χ6;21-» %2 + X;3 → %2). Le terme Δ est ici 21→ 1, multiplié par le facteur λ qui vaut 1 - = . Interface utilisateur
Editeur de documents
L'interface permet de demander à ce que la relation entre deux sélections soit affichée dans un document, qu'il s'agisse d'une relation sémantique, d'un conduit imposé par l'utilisateur ou d'une valeur calculée implicitement.
L'interface permet d'effectuer une transclusion dont le résultat est placé dans un document.
Lorsque la relation entre deux sélections dont au moins une est une transclusion doit être affichée, l'interface superposera les relations partant de ou arrivant à la source (et le cas échéant de la source de cette source et ainsi de suite) et de ou au résultat de cette transclusion.
L'utilisateur peut ensuite modifier la relation dans le document, et le changement sera automatiquement reflété dans le réseau.
Lorsqu'une nouvelle relation est créée de ou vers une transclusion le système propose de remonter les extrémités de cette relation aux sources des transclusions, permettant ainsi de créer des relations entre les sources (qui peuvent par exemple être des pages web).
Pour toute sélection que l'utilisateur d'un système en mode client crée, une référence sera envoyée dans le serveur afin que ce dernier puisse en tenir compte dans les calculs de scores.
Les relations que l'utilisateur crée (ou modifie, supprime, etc.) vont être mémorisée dans le système, qu'il soit en mode client ou serveur. S'il est en mode client, l'interface propose un moyen d'envoyer ces conduits au serveur (afin qu'ils soient utilisés pour les autres systèmes clients du même serveur).
Cette interface peut être intégrée dans un éditeur standard tel que Word.
Visionneur de réseau
L'utilisateur peut également demander à voir la totalité du réseau de relations (tant celles ajoutées par l'utilisateur que celles calculées automatiquement) au voisinage d'une sélection. Ici encore, les relations de ou vers les sources, d'une transclusion seront « descendues » dans le graphe présenté. Dans cette interface également, l'utilisateur peut ajouter/supprimer des conduits et relations sémantiques.
Afin d'aider à la visualisation l'utilisateur peut demander à ne voir que certaines relations, c'est-à- dire activer ou désactiver l'affichage des relations obtenues par abonnement (sélectivement abonnement par abonnement), activer ou désactiver l'affichage de certains types de relations
sémantiques, et ainsi de suite tous les moyens de calculer les grosseurs de conduits peuvent être sélectionnés ou non pour donner lieu à l'affichage de relations.
De plus l'utilisateur peut configurer la manière dont les grosseurs par défaut sont calculées. L'interface permettant d'effectuer ceci se présente sous forme d'une liste de manières de calculer des grosseurs de conduits (cocitations, liens hypertextes, conduits donnés explicitement, abonnements, etc.), à chaque ligne (sauf dans le cas des abonnements et des conduits donnés explicitement) l'utilisateur peut indiquer la pondération et si elle est non nulle activer ou non l'affichage des conduits correspondant. Dans le cas des abonnements et des conduits donnés explicitement, une option permet de les rendre effectifs ou non pour le calcul, et ici encore s'ils sont actifs une option permet de les afficher ou non dans la représentation du réseau. Plus concrètement ceci peut être réalisé avec un affichage à deux colonnes, la première permet de pondérer (ou activer/désactiver) le calcul correspondant et la seconde permet d'afficher ou cacher les relations dans la représentation.
Requêtes
Soit dans l'éditeur de documents soit dans le visionneur de réseau l'utilisateur peut sélectionner un ensemble de sélections (transclusions ou pas) en tant que requête et demander au système de lui proposer des sélections pertinentes pour cet ensemble. Il reçoit ensuite une liste de sélections qu'il peut utiliser pour enrichir son document.
Afin de permettre au système d'organiser les résultats de la requête, à chaque sélection est associé un chemin qui est une liste de noms telle que « /entrepriseA/divisionB/départementC/ ». Les sélections trouvées sur le web auront un chemin tel que « /web/http://... »
Le système représente dans l'interface sous forme d'un arbre tous les nœuds existant par exemple dans l'entreprise, et l'utilisateur peut choisir s'il souhaite ne voir que les nœuds qui contiennent des résultats.
L'utilisateur peut ouvrir ou fermer les nœuds et réordonner les enfants d'un nœud et le système réagit en présentant les résultats dans le même ordre que les nœuds de l'arbre et en triant selon leurs scores les résultats se trouvant dans un nœud fermé. Les modifications effectuées sur l'arbre sont mémorisées, c'est-à-dire que l'arbre sera présenté de la même façon à la prochaine requête. L'utilisateur peut également demander à ce que seuls les résultats se trouvant dans certains nœuds de l'arbre lui soient retournés (il va notamment se limiter aux chemins contenant des sélections auxquelles il a accès).
Gestionnaire de contexte
Enfin, le système offre à l'utilisateur des outils pour gérer le contexte (par exemple pour en supprimer des sélections, pour le remettre à zéro, pour le désactiver temporairement, pour l'enregistrer afin de le reprendre plus tard, etc.).
Composantes principales du système
Le crawler
Cette partie du système explore le réseau de liens hypertextes du web à la demande des autres modules. Elle va également périodiquement vérifier si les ensembles de liens entrants et sortants des sélections ont changé, et vérifie plus souvent les sélections recevant des requêtes des autres modules.
Anti-népotisme
Les algorithmes de calcul de score décrits plus haut ont ce désavantage que lorsque les pages d'un ensemble sont fortement liées les unes aux autres, n'importe quelle page en dehors du groupe aura un mauvais score relativement aux pages du groupe.
Il peut y avoir deux raisons pour que les pages d'un ensemble se lient fortement les unes aux autres. Premièrement dans le cas où il s'agit de l'ensemble des pages d'un site et que chacune contient la table des matières du site (et donc possède un lien vers toutes les autres). Le deuxième cas est si les auteurs des pages souhaitent obtenir un meilleur score dans les moteurs de recherche se basant sur les liens, en se citant les unes les autres. On appelle cette situation le népotisme.
La raison est que, comme déjà dit, les équations se basent sur la notion de co-citation, et que seules les pages souvent liées en commun avec une page du groupe pourront obtenir un bon score.
Dans l'exemple présenté à la figure 18, un groupe de six pages se citent fortement entre elles
(supposons qu'il s'agit de l'exemple de la table des matières). La page 1 devrait obtenir un bon score relativement à la page 2, car, à part les liens de navigation, toutes les pages pointant vers 2 pointent vers 1 également. Cependant les équations ne verront que le fait que, parmi les huit pages pointant vers 2, seules trois pointent également vers 1.
Pour diminuer cet effet on va atténuer l'effet des liens entre pages fortement connectées de façon à ce que les autres liens aient plus d'effets.
En pratique on va dire que lorsqu'on sait que les deux extrémités d'un lien sont proches (la proximité étant calculée par une équation d'homogénéité), le poids de ce lien sera diminué (le poids étant une valeur entre zéro et un, zéro étant équivalent à une absence de lien). Le poids d'un lien est égal au complément de l'homogénéité des deux extrémités (cette homogénéité étant bien sûr calculée sans se baser sur les poids des liens), et borné entre zéro et un.
Dans l'exemple ci-dessus, les liens internes au site relient des pages très proches (car les deux extrémités sont liées en commun par beaucoup de pages) alors que les autres relient des pages de faible proximité (peu de pages, en fait aucune .dans le dessin) pointent à la fois vers la source et la cible de ce lien.
Après correction on obtient ce qui est présenté à la figure 19 (un lien plus clair symbolise le fait que sont poids est plus faible).
Et l'homogénéité des pages 1 et 2 sera grande.
Pour utiliser cette méthode d'anti-népotisme, il faut construire un réseau (AN) parallèle au réseau des pages (U, comme underlving, sous-jacent), qui sera utilisé par les algorithmes (voir figure 20).
Les sommets de U sont des copies des sommets de AN, c'est-à-dire des pages.
A chaque arête (lien) est associé une pondération qui est égale au complément (1-x) de la proximité (homogénéité) des deux pages reliées, calculée dans le réseau U. Pour éviter que ce soit trop lourd, ce réseau est construit paresseusement, c'est-à-dire que les nœuds et les liens sont créés quand ils sont demandés.
La cardinalité d'un ensemble de liens dans AN est remplacée par la somme des pondérations de ces liens. (Par exemple on remplace le nombre de liens inverses par la somme des pondérations des liens inverses). La somme des scores des liens inverses est remplacé par la somme des produits des scores et de la pondération du lien correspondant.
La cardinalité de l'union de deux ensemble de liens est calculée comme suit. La contribution d'un lien présent dans un seul de ces ensembles est égale à sa pondération. La contribution d'un lien présent dans les deux ensembles est égale à la somme logique de leurs pondérations, c'est-à-dire l-(l-a)(l-b).
La cardinalité de l'intersection de deux ensembles de liens est la somme, pour tous les liens présents dans les deux ensembles, des produits de leurs pondérations.
Le poseur de conduits
(Piper en anglais)
Ce module est responsable de calculer les grosseurs des conduits entre sélections (en fonction de la configuration par l'utilisateur, par cocitation, le long des liens hypertextes, par analyse de texte, en traduisant des relations sémantiques, en prenant une valeur imposée par l'utilisateur, ou encore des conduits obtenus par transclusion).
Le système va mémoriser dans le réseau les conduits obtenus par transclusion, et ces derniers sont mis à jour lorsque l'utilisateur visionne les documents contenant ces transclusions.
Pour la grosseur de conduit entre deux sélections le système choisira, par ordre de priorité : 1. Une grosseur de conduit ou une relation sémantique donnée par l'utilisateur 2. Une grosseur de conduit fournie par transclusion 3. La grosseur de conduit calculée automatiquement (cocitation ete)
Tous les calculs de grosseurs de conduits sont effectués dynamiquement (bien que des valeurs précalculées peuvent bien sûr être mémorisées).
En plus de demander, les grosseurs de conduits, on peut donc également demander à ce module comment un conduit particulier a été calculé afin de l'afficher dans un document (par exemple quel type de relation sémantique a été placé ou s'il s'agit d'une valeur fixe imposée par l'utilisateur).
Conduits spéciaux entre sélections et requêtes
Optionnellement, le système pourra être configuré pour introduire dans le réseau des nœuds artificiels, chacun représentant une requête. Des conduits bidirectionnels entre la requête et les sélections qui en ont résultées (celles ayant eu les meilleurs scores) sont alors posées, les grosseurs étant fonction des scores pour la requête en question.
On pourra ainsi faire poser des conduits avec des requêtes spéciales, telles que celles mettant en œuvre un procédé de « distillation relative » décrit plus loin.
Lorsque l'utilisateur a choisi de publier une partie de son réseau, ce module sera responsable de construire les données à envoyer, c'est-à-dire toutes les grosseurs de conduits soit elles-mêmes obtenues via une transclusion soit explicitement fournies par l'utilisateur.
Favorisation des nouvelles pages
Cette section décrit une composante accessoire du système permettant de l'utiliser pour faire de la veille sur le web. Le système doit pouvoir suggérer des pages qui viennent d'être créées, même si la pertinence de la page se basant purement sur les liens hypertextes semble faible. En effet, si la page vient d'être publiée sur le web74, il est probable qu'elle soit connue de peu de monde et que par conséquent peu de pages pointent sur elle, même si en réalité il s'agit d'une très bonne page. Il faut donc calculer sa pertinence d'une autre manière, de façon à leur donner une chance d'apparaître parmi les suggestions à l'utilisateur.
On se base sur la notion de région fiable, qui est une partie d'une page qui ne pointe que sur des pages que le système sait être bonnes.
Pour une nouvelle page découverte dans une région fiable on va donner une pondération plus grande aux conduits calculés à partir des distributions de mots, et après que la page a été dans le système plus d'un certain temps, le système réduit l'importance de ces conduits de mots au profit de ceux calculés à l'aide des liens hypertextes, jusqu'à les supprimer complètement. Plus précisément on donne un poids τ aux conduits obtenus par les distributions de mots et un poids 1- τ aux conduits obtenus par les liens hypertextes, τ vaut 1 lorsqu'une page est découverte (soit dans l'état inconnu soit dans l'état nouvelle, voir ci-dessous pour les définitions), et décroît linéairement pour atteindre 0 à l'instant où elle passe dans l'état ancienne, τ possède donc une valeur strictement entre 0 et 1 pour les pages dans l'état inconnu bien que les conduits par les mots ne soient pas du tout appliqués.
Définitions
A chaque page est associé un état qui peut être :
74 Bien entendu, au lieu d'une page ce peut être une sélection publiée par exemple au sein de l'entreprise seulement. Dans cette section, « page » peut être remplacé par « sélection ».
• inconnu : la page a été découverte en téléchargeant d'autres pages sur le web et on ne sait donc pas si elle est nouvelle ou ancienne. La date de découverte de la page est mémorisée dans la structure, ce qui permet de la faire passer dans l'état ancienne après un certain temps • nouvelle : La page n'est pas connue depuis longtemps par le système et on l'a vue apparaître sur une région fiable. A noter qu'une page existant déjà dans l'état inconnu peut passer dans l'état nouvelle si on la voit apparaître dans une région fiable mais la date à laquelle elle passera à l'état ancienne reste inchangée. • ancienne : La page est connue depuis suffisamment longtemps par le système.
Construction des régions fiables
Voici l'algorithme utilisé pour construire les régions fiables.
Il faut tout d'abord attacher à chaque page web un score global qui est calculé en effectuant une requête contenant toutes les autorités (le score global d'une page i est calculé avec r— τ a (i) )•
Ensuite on sélectionne un ensemble de pages candidates à abriter une région fiable en Funion des liens entrants des pages possédant les meilleurs scores globaux.
Pour chacune de ces pages candidates on effectue la somme des scores globaux des pages liées par des liens hypertextes puis on télécharge les pages ayant obtenu les plus grandes sommes.
On y définit les régions fiables comme étant les plus grandes dont tous les liens hypertextes vers des anciennes pages pointent vers des bomies pages. "Les plus grandes" signifie que toute région englobant la région en question contient un lien vers une ancienne page avec un score global insuffisant.
On définit une distribution de mots d'un document par un ensemble de paires (mot, fréquence) associant à chaque mot présent au moins une fois dans le document sa fréquence d'apparition (il faut également normaliser les fréquences en les divisant par la somme des carrés afin que la somme de leurs carrés atteigne un).
On produit scalaire de deux distributions est égal à la somme pour tous les mots des produits des fréquences d'apparition dans l'un et l'autre document. Le nombre sera proche de un si les documents utilisent le même vocabulaire et de zéro sinon.
Lorsqu'une page entre dans l'état nouvelle, le système va la télécharger et construire sa distribution de mots, et en effectuer le produit scalaire avec celles des pages possédant un bon score global, et placer entre la nouvelle page et chaque bonne page un conduit (bidirectionnel) dont la grosseur est égale au produit scalaire correspondant, divisé (dans la direction de la nouvelle à la bonne page) par le nombre d'autorités. Afin d'avoir une somme des conduits sortants égale à un on ajoute aux nouvelles pages un conduit les reliant à elles-même égale au complément de la somme des conduits sortants.
Ces valeurs étant calculées une fois pour toute, la distribution de mots des nouvelles pages peuvent être détruites une fois ces valeurs obtenues (mais les distributions de mots des bonnes pages peuvent être gardées en prévision des prochaines nouvelles pages)
Le distilleur
Pour éviter d'avoir pour chaque requête de pages pertinentes à effectuer l'algorithme itératif décrit plus haut de calcul de scores, on se base sur un ensemble A de sélections « autorités ». Cet ensemble est construit en calculant les scores des sélections de façon absolue en partant du ou des domaines (sous forme d'un ensemble de pages données par l'utilisateur, notamment à l'initialisation) où l'utilisateur souhaite que le système soit précis. Les pages ayant obtenu les
meilleurs scores formeront cet ensemble, et plus il est grand plus la charge du système est grande mais plus les résultats sont précis.
Afin d'améliorer encore les résultats on peut favoriser que les sélections de A soient « lointaines » les unes des autres c'est-à-dire qu'elles n'aient pas de bons scores les unes par rapport aux autres, ceci évite que l'algorithme soit très bon dans une petite région et imprécis ailleurs.
Algorithme de sélection d'autorités
Voici un algorithme de construction de l'ensemble A, à effectuer à l'initialisation du système et qui peut être relancé (ou repris afin d'augmenter la taille de A) lorsque l'ensemble des sélections connues du système croît suffisamment. Dans cet algorithme, W représente l'ensemble des sélections, x(p) représente le score absolu de la sélection p et xp(q) représente le score de la sélection q relativement à p. On définit une représentativité r(p) ainsi : r(p) = x(p) - r max(max(xα (p),xp («))), ce qui signifie le score absolu moins (avec une pondération τ) le plus grand score relatif impliquant p et une sélection de A (ce qui représente la « distance » de la sélection candidate p avec celles déjà prises), τ est une constante. Une petite valeur de τ indique qu'on préfère avoir des sélections à bon score absolu et une grande valeur indique qu'on préfère avoir un des sélections lointaines les unes des autres.
A est initialement vide. Ensuite tant qu'on souhaite faire grandir l'ensemble A on y ajoute la sélection de W ayant la représentativité la plus grande.
Algorithme de calcul relatif optimisé
On va maintenant décrire l'algorithme de calcul des scores basé sur cet ensemble de sélections autorités.
Soit χ .(i) le score de la sélection i pour la requête constituée de la seule sélection y, calculé à l'aide de l'algorithme décrit dans l'introduction.
Soit Xj(i) le score de la sélection i pour la requête constituée de la seule sélection,/, calculé sur un réseau de propagation des scores où toutes les flèches auraient été inversées par rapport au vrai réseau (c'est-à-dire que le terme l.. est remplacé par le terme lβ dans l'algorithme)75'76, et auparavant où tous les conduits sortants des autorités sont mis à zéro, sauf les conduits liant les autorités à elles-mêmes qui sont mis à un, c'est-à-dire que le terme / . (avant l'inversion des 77 flèches) sera assigné à 1 si a=j et 0 sinon .
En précalculant pour tous les a les distributions de scores xa et xa , la fonction suivante peut être calculée très rapidement. Elle donne un score à la page j pour une requête R représentée par un poids donné à certaines pages (le terme R* est défini comme Si dans l'algorithme décrit au départ) :
75 Le réseau inversé n'est pas nécessairement normalisé, cependant P algorithme convergera quand même vers la bonne valeur : Soit s = 1 — S , L la matrice de conduits. Xj est la e colonne de la matrice solution X dans
\I — s • L X = s - I . Cette équation est équivalente (par transposition et par XY=I ssi YX≈T) à
(I — s • £,)• X — s - I . x, qui est la me colonne de X1 (égal à la me ligne de X) se calcule donc effectivement avec le même algorithme que la me colonne de X sur la transposition de la matrice de conduits.
76 Comme déjà dit, il n'est pas nécessaire de normaliser les scores dans l'algorithme relatif ; c'est d'autant plus important dans ce cas que la somme des résultats ne sera en général pas 1 (et normaliser fausserait les résultats)
77 Les termes lia avec i ≠ a ne sont donc pas touchés.
Le principe est le suivant : on calcule pour chaque sélection de la requête la quantité de score qu'elle enverrait à chaque sélection autorité, puis on fait la moyenne des scores xa pondérée par les scores obtenus par ces sélections a. On reconstitue ainsi le comportement qu'aurait eu l'algorithme de base pour la requête R, à cette restriction que seuls les propagations de scores transitant au moins une fois par une sélection de A sont pris en compte.
Lorsque des chemins ne touchant pas A existent, le score donnera une valeur trop petite mais ce n'est pas important car on suppose que les sélections de A sont choisies de sorte à se trouver dans les points (du domaine intéressant l'utilisateur) facilement touchées par les flux de score dans les conduits. D'autre part il peut être avantageux de ne mémoriser que les valeurs xa(j) et xa(J) suffisamment grandes, ce qui produira également une erreur vers le bas.
Etant donné que l'approximation donnera toujours une valeur trop petite pour les scores, il est possible d'estimer l'erreur en effectuant la somme de tous les scores d'une réponse à une requête.
∑^ ") = ∑∑∑^( - R,- -^a ') s ∑Rr∑^( - Le facteur ∑5cfl( exprime la j j a A i≡R ieR eA aeA connaissance que le système a de la sélection i : Une valeur égale à 1 signifie qu'une requête sur cette sélection donnera des scores exacts (c'est-à-dire Vy' ^ ') = xR (j)). Plus la valeur est petite plus l'erreur sera grande.
Le distilleur est donc responsable de mémoriser et tenir à jour les valeurs des fonctions xa et xa pour chaque sélection de A.
Exemple numérique
Soit le « vrai » réseau de propagation de scores présenté à la figure 21, avec trois sélections/», a, q.
On choisit l'ensemble A={a} et la requête R={p}.
Calculons d'abord les fonctions xa et xa .
En enlevant tous les conduits sortant des sélections de A et en mettant un conduit reliant chaque sélection de A à elle-même avec une grosseur de 1 puis en inversant tous les conduits on obtient le réseau « transformé » de la figure 22.
Sur le réseau transformé, l'algorithme de calcul de score relatifs avec {a} comme requête et s=0.5 (donc sa=0.5 et sp=sq=0) utilise les équations suivantes (p, a et q représentant les scores des trois sélections pendant l'application de l'algorithme) : jp(t + l) = XJp(t) + X (t) (t + l) = Xα(t) + X q(t + l) = y2q(t) '
Les valeurs à convergence sont les valeurs 3c : l (-im» p(t) = xa (p) = , x (a) = l et 3c (q) = 0.
Dans le cas où A contient plus d'une sélection cette étape doit être répétée pour chacune.
On effectue l'algorithme normal (toujours avec {a} comme requête) sur le vrai réseau pour obtenir les valeurs xa .
Les équations de transformations sont cette fois-ci les suivantes (en reprenant les mêmes noms de variables) :
a(t + ï) = y4p(t) + y2 q(t + l) = %a(t)
Les valeurs à convergence sont les valeurs de xa : limp(t) = xa(p) = %3 , „ («) = %
Ici encore, cette étape doit être effectuée pour chaque sélection de A s'il y en a plus qu'une (ce qui n'est pas le cas dans cet exemple).
On peut maintenant appliquer la définition de x par exemple en prenant ? comme requête : χ P(q) = χ a(p) - a (q) = y - %6 = %6 -
Etant donné que toutes les trajectoires que les scores peuvent suivre de p à q passent par a on obtient exactement la même valeur que l'algorithme de base aurait donnée avec xp (q) , comme montré ci-dessous :
Dans ce cas les équations d'évolution des scores (basées sur le vrai réseau) sont les suivantes : p(t +i) = y4p(t) + ys a(t) +y2 a(t + ï) = y4p(t) q(t + ï) = ys a(t) Qui convergent vers lim (t) = x (p) = % 78, x (a) = n etx (q) = %6.
Le traiteur de requêtes
(Request Handler en anglais)
Une requête à cette composante consiste en un ensemble de sélections, éventuellement un ensemble de modifications à apporter au réseau serveur (ceci est utilisé par le mode client décrit plus bas), ainsi qu'un ensemble de filtres sur les sélections à retourner (qui sera utilisé en particulier pour ne retourner que les sélections auxquelles l'utilisateur a accès), et elle répond avec l'ensemble des sélections ayant le plus grand score de pertinence pour cette requête (le score de chaque sélection retournée est également retourné).
Comme dit en introduction, le système peut être utilisé de deux manières, soit il fait tous les calculs lui-même (mode serveur) soit il utilise un autre système en lui fournissant les modifications (i.e. modifications/adjonctions/suppressions) que l'utilisateur a apportées au réseau de propagation des scores de l'autre système (mode client).
Dans le mode client, ce module va simplement renvoyer la requête à un serveur, accompagnée de l'ensemble des modifications effectuées sur le réseau de propagation des scores.
Dans le mode serveur, si la requête ne demande pas des modifications au réseau de propagation de scores ce module calcule simplement la fonction xR définie plus haut. Lorsqu'un filtre sur les sélections avait été donné, seuls les scores des sélections satisfaisant le filtre seront calculés
(c'est-à-dire qu'il est appliqué sur les distributions de scores xa avant d'y effectuer les pondérations et additions).
Dans le cas où des modifications doivent être apportées au réseau serveur79, ce module va modifier la requête de façon à y simuler les effets des changements apportés au réseau serveur.
Cet algorithme fonctionne de la façon suivante :
Soit l'ensemble des l:. le réseau serveur et V.. le réseau modifié.
Le résultat de la requête doit sembler être appliqué sur le réseau /'» et doit satisfaire l'équation
Xj = s∑/'l7 xt + Sj . Etant donné que le serveur calcule des équations sur le réseau l.. l'équation
est changée ainsi : Xj ≈ .s∑ /,}•*, + Sj + s iψg-liJ)xl Entre parenthèses se trouve s', la requête modifiée : _?' = j + s ψJ..-li.)χ. .
78 Par contre x (p) ≠ x (p) car il existe un chemin reliant àp ne passant par aucune sélection de A.
79 Cet algorithme fonctionne même pour les sélections qui, dans le réseau serveur, ne possèdent aucun conduit entrant ou sortant, contrairement au réseau modifié, ce qui se produira en particulier lorsqu'un utilisateur du système client a créé des sélections auxquelles il est le seul à avoir accès et donc pour lequel il est le seul à avoir mis des conduits.
Etant donné qu'elle dépend elle-même du résultat, cette requête va être approximée itérativement, c'est-à-dire qu'il faut avoir une estimation80 du résultat de la requête pour calculer la requête modifiée, et que les résultats de la requête modifiée sont utilisés pour calculer une requête modifiée plus précise, jusqu'à convergence81 des valeurs x qui peuvent ensuite être retournées en réponse à la requête. Plus la première estimation de la requête est proche de la vraie valeur plus la convergence sera courte, cependant quelles que soient les valeurs initiales l'algorithme va tendre vers la même valeur.
Exemple numérique
Après modification du réseau de l'exemple précédent, on a le réseau présenté à la figure 23.
La requête sera constituée de la sélection a.
On prendra comme première estimation X pour tous les scores.
La requête modifiée est la suivante : S P = SP + * ' \ * qp-* '„qp) . '* = * a " a + ' s " -( Vrgqaa-ι "gqaa) , -g = ι s'q = sq + s - (rqq-lgg )- q = - 4
Le score de q pour la requête s (en passant par les autorités) est {xa (p) -sp +xa ( ) -sa + xa (q) -sq y xa(q) = (y3 - sp + sa )- %6.
La première itération donne s'p = X2 , s'α = 1 et s'q = ~X2.
Le score de q pour cette requête est q = 3X92 s 0.1927.
La deuxième itération donne s'p = 3 68 , s'a = 1 et s'q = -3X68 •
Le score de q pour cette requête est q s 0.1988 , et ainsi de suite.
Prenant ç=0.1989 on obtient les résultats suivants pour la requête : js = (χ - ^ + * -xα O?) ≤ 1.0166 - X3 = 0.0884 a = (y - sp + sa )- xa(a) = 1.0166 -% = 0.5304 ? = ( - SP + * - «(<?) ≡ 1-0166 - %6 = 0.1989
Architecture
Le diagramme de la figure 24 représente l'ensemble des données gérées par le système ainsi que les dépendances qui les relient.
Les rectangles représentent des classes.
Un nom à l'intérieur d'une classe représente des données attachées à chaque instance de la classe.
L'astérisque * représente la multiplicité.
Une flèche représente une dépendance entre deux données (appelées source et cible de la dépendance). Une dépendance entièrement contenue dans une classe relie des attributs d'une même instance de la classe.
Lorsqu'une dépendance est déclenchée la donnée cible est recalculée.
Un symbole • ou ! à une extrémité d'une dépendance indique la force de la dépendance, respectivement faible ou forte.
Une dépendance est forte si son déclenchement rend la donnée cible inaccessible jusqu'à ce que sa mise à jour soit achevée, et faible si la donnée cible reste accessible pendant sa mise à jour
(dans ce cas si la donnée cible est interrogée l'ancienne valeur sera retournée tant que la mise à jour n'est pas achevée)
80 II n'est nécessaire de calculer que les Xj pour lesquels le facteur Ty-ly est non nul pour au moins un i
81 II peut être nécessaire de mettre un facteur d'inertie comme déjà vu dans les algorithmes précédents, afin d'éviter des oscillations
L'extrémité à laquelle se trouve le symbole de force indique le déclencheur (l'initiative) de la dépendance :
Il se trouve du côté de la cible s'il s'agit d'une dépendance « pull », ce qui signifie que la fraîcheur de la source est vérifiée (et le cas échéant une mise à jour de la cible est effectuée) à chaque interrogation de la donnée cible.
Le symbole de force se trouve du côté de la source s'il s'agit d'une dépendance « push », ce qui signifie que la cible est mise à jour lorsque la source change.
Le symbole ® placé sur une dépendance indique que la dépendance n'est vérifiée que si la dernière mise à jour de la cible est suffisamment ancienne.
Une dépendance dont la source est le symbole indique que la mise à jour de la cible est effectuée automatiquement à intervalles réguliers.
Une dépendance représentée en pointillés signale que la mise à jour est faite de façon synchrone, c'est-à-dire qu'une modification de sa source ne s'achève pas tant que la mise à jour de la cible n'est pas terminée (et peut être mise en œuvre par un simple appel de fonction, contrairement aux autres dépendances qui doivent être mises en œuvre par des threads séparés).
A noter que ces diagrammes montrent que toutes les données calculées peuvent être mémorisées et rafraîchies en fonction des besoins (décrits par les dépendances) ou non mémorisées et recalculées à chaque demande.
Le fonctionnement des serveurs en mode client et serveur est schématisé dans les diagrammes des dépendances des figures 24 et 25 respectivement.
Le système en mode client ne possède pas d'autorités et toutes ses requêtes sont déléguées à son serveur. De plus, il travaille sur le même réseau serveur que son serveur et il ne lui est donc pas nécessaire d'effectuer le calcul des conduits obtenus automatiquement : il peut les télécharger du serveur. Ainsi il ne lui reste plus que les conduits définis manuellement, les relations sémantiques et les abonnements à gérer.
Extension de la connaissance du web
Le système en mode serveur offre une fonction pour faire grandir l'ensemble des pages connues ainsi que l'ensemble A. Cette opération doit typiquement être effectuée au démarrage, car à cet instant l'ensemble A et l'ensemble de pages connues sont vides.
Algorithme d'extension du réseau
L'utilisateur donne un ensemble de sélections à partir desquelles l'extension sera effectuée.
Le système effectue ensuite l'algorithme relatif de calcul des scores82 en partant de cet ensemble, et en l'étendant le long des conduits partant de sélections ayant le plus grand score (ce qui, via les dépendances, provoquera une recherche de liens inverse et avant). On exécute ainsi en parallèle l'algorithme relatif de calcul de scores et l'extension du réseau.
On procède jusqu'à atteindre un nombre de sélections choisi par l'utilisateur, ou alternativement jusqu'à ce que le plus grand score à la frontière soit inférieur à un seuil choisi par l'utilisateur (le mot « frontière » signifie ici sélection dont l'ensemble de conduits sortants n'a pas été calculé). Le système pourra ensuite soit détruire un éventuel ensemble A déjà existant et lancer l'algorithme de sélection de l'ensemble A décrit dans la section « Le distilleur » ci-avant, soit simplement ajouter de nouvelles sélections dans cet ensemble, en reprenant l'algorithme à partir de l'ensemble
A déjà existant.
Immédiatement après une extension, le système doit recalculer toutes les valeurs de xa et xa . Le calcul de ces termes pourra déclencher le calcul de conduits en partant des autorités, en les suivant aussi loin que les scores sont assez grands (ce qui peut faire grandir le domaine connu au-delà de la frontière de celui qui avait été construit pour choisir les sélections de A)
82 On en utilise la version non optimisée bien sûr, étant donné qu'il s'agit ici de préparer les données utilisées par l' algorithme optimisé
Ensuite le système est prêt à recevoir des requêtes qui utiliseront les xa et 5 α ainsi obtenus. On peut optionnellement permettre (par exemple pour les employés de l'entreprise ou si l'utilisateur paie) de faire grandir le réseau en réaction à une requête se trouvant hors du domaine bien connu du système.
Comme déjà dit dans la description du traitement d'une requête (voir la section « Le Distilleur »), l'erreur sur le résultat et donc la connaissance du système sur la requête peut être mesurée à l'aide des termes ∑3ra(z) . A noter que si la requête est accompagnée d'une modification du réseau il a A est important de d'abord calculer la requête modifiée pour tenir en compte ces modifications avant de calculer ces termes.
Si la connaissance du système pour les sélections de la requête modifiée est trop faible cela signifie que les résultats seront de mauvaise qualité et on peut automatiquement lancer l'algorithme d'extension du réseau en partant de la requête modifiée de l'utilisateur.
Exemple :
Supposons qu'un utilisateur d'un système client a créé un document contenant deux transclusions
Sj et s2 de pages web pj et p2 dont l'une est dans le domaine connu du serveur et l'autre est inconnue du serveur. L'utilisateur a tracé un conduit de Si à s2 (et le conduit, comme expliqué précédemment, a été en réalité placé de pi à p2).
Tout d'abord, en créant Si et s2 il a inséré les références correspondantes dans le serveur.
L'utilisateur, qui est autorisé à provoquer une extension du réseau, demande des suggestions pour son document.
Son système va donc envoyer une requête contenant Si et s2 et les conduits (pι<->sι, p1->p2, p2<-
>s2) en tant que différences au réseau.
La requête modifiée par ces trois conduits aura un poids s non nul aux deux pages web en plus des deux transclusions (voir l'algorithme dans la section « Le traiteur de requêtes »), et si aucune extension n'est effectuée, seules des suggestions partant de la première page web seront données
(car c'est la seule à être connue du serveur).
Supposons maintenant que le serveur effectue une extension du réseau (l'algorithme d'extension du réseau, décrit ci-dessus)
Il va donc prendre la requête modifiée et effectuer l'algorithme de calcul de scores relatifs (non optimisé) à partir de ces quatre sélections, mais dans son réseau serveur (c'est-à-dire sans conduit entre pi et p2). Pour ce faire il va notamment devoir suivre les conduits partant de p2. Etant donné que les pages au voisinage de cette dernière auront un bon score pour cette requête et que les autorités existantes lui donneront un score nul, le système placera une ou plusieurs autorités dans cette région.
Algorithme de réduction du réseau
La section précédente expliquait comment étendre le réseau ou augmenter la précision en agrandissant l'ensemble des autorités. On va maintenant voir une fonction du système pour effectuer l'opération inverse (utile à un utilisateur par exemple s'il souhaite annuler l'effet d'une extension de réseau provoquée par un système client dans une région du web hors de son domaine d'intérêt).
L'utilisateur va définir le domaine qu'il souhaite retirer de son réseau en effectuant une requête, par exemple avec un document contenant des transclusion, ou avec un ensemble de sélections donné directement, etc. Il peut ensuite dire au système de supprimer les autorités qui ont été beaucoup utilisées pour produire les résultats, c'est-à-dire les sélections de A pour lesquelles ∑ R. • xa (i) est suffisamment grand (l'utilisateur peut soit spécifier un seuil soit une proportion isR d'autorités à supprimer). Pour l'aider à choisir le seuil on peut afficher un graphique indiquant en fonction du seuil la proportion d'autorités qui serait supprimée. Si le domaine qu'il a donné est
bien fermé (c'est-à-dire faiblement connecté au reste du réseau) le graphique présentera un plat autour du seuil à choisir (car le seuil doit être beaucoup diminué pour que des autorités d'un autre domaine commencent à être touchées à leur tour). Ceci est illustré à la figure 26.
Délégation en peer-to-peer
Alternativement, au lieu d'étendre le réseau du serveur, on peut utiliser un système en peer-to- peer pour déléguer des parties ou la totalité de la requête à d'autres systèmes. L'utilisateur peut relier son système à d'autres systèmes, formant ainsi un réseau peer-to-peer. On appelle les systèmes « voisins » ceux qui sont directement reliés par ce réseau. Lorsque le système choisit de déléguer une partie de requête à d'autres systèmes il va demander à ses voisins s'ils connaissent un système capable de gérer tout ou partie de cette requête, c'est-à- dire qui possède des valeurs de connaissance ∑ xa (i) suffisamment grandes. aeA
Si un système est capable de gérer une partie de la requête il en informe le système d'où la recherche avait démarré (en lui fournissant ses valeurs de connaissance pour ces sélections), et interroge ses voisins pour la partie de la requête qu'il ne connaissait pas.
La demande .circulera vers les voisins de ces voisins et ainsi de suite jusqu'à ce que pour toutes les sélections de la requête un système ait répondu, ou jusqu'à ce que tout le réseau ait été parcouru sans succès (ce qui est détecté si aucune réponse ne parvient après un certain délai). Le premier système (celui qui a initié la recherche) pourra ensuite répartir la requête entre les différents systèmes ayant répondu, puis, grâce à la linéarité des algorithme les différents résultats pourront être recomposés directement.
Afin d'optimiser la recherche dans le réseau peer-to-peer les systèmes peuvent mémoriser une table des requêtes qui leur parviennent le plus souvent, en y associant le système qui y avait répondu positivement. Ainsi les requêtes parviendront plus rapidement aux systèmes capables de les gérer.
Etant donné que toutes les sélections du premier système ne sont pas accessible à tous les voisins, il faudra que ce dernier ne fasse des requêtes ne contenant que les sélections accessibles à ses voisins, afin d'éviter du trafic inutile.
Architecture distribuée
Voici comment un système (on parle bien ici d'un système gérant un seul réseau) peut être distribué sur plusieurs machines.
Il est important que le traitement d'une requête (donc du calcul de
X R U) ' χ a (J) ) se fasse rapidement. De plus la mise à jour des fonctions xa et
xa prend beaucoup de ressources. Ces deux points suggèrent de répartir l'ensemble A sur plusieurs machines.
On obtient ainsi (comme schématiquement présenté à la figure 27) une machine pour un RequestHandler (R) principal, une machine pour le Piper (P), une machine pour le Crawler (C), et les Distiller (D) se partagent l'ensemble A et se trouvent chacun sur une machine différente. On prendra par exemple dix machines Distiller (dans la figure 27 il n'y en a que 3 pour des raisons de clarté du dessin) traitant chacune par exemple mille sélections de l'ensemble A (s'il en compte dix mille). Chaque Distiller sera accompagné d'un RequestHandler (R) secondaire pour gérer la partie des requêtes le concernant.
Ainsi le traitement d'une requête s'effectuera ainsi : Elle parvient au RequestHandler, qui va interroger simultanément tous les RequestHandler secondaires en leur donnant le contenu de la requête. Ces derniers vont effectuer leur partie de la somme et renvoyer le résultat (un ensemble de paires sélection-score) au RequestHandler primaire, qui va effectuer la somme de tous les résultats partiels et la renvoyer.
On peut envisager de mettre plus de deux niveaux de RequestHandler pour un plus grand nombre de machines, comme présenté schématiquement à la figure 28.
Enfin, chaque Distiller s'assurera de la mise à jour des scores xa et 3ca pour sa portion de l'ensemble A (selon les dépendances du diagramme de la figure 27 ). * * *
Ressources dérivées (premier système)
Un autre aspect de la présente invention vise à proposer des techniques dans lesquelles un utilisateur puisse modifier une page d'origine - il peut par exemple lui associer des annotations - et enregistrer les modifications en tant que page dérivée de la page d'origine.
Il vise aussi à permettre que la page dérivée lui soit spontanément présentée par le système quand il revisite la page d'origine.
Selon encore un autre aspect, l'invention vise à déterminer, en exploitant les liens qui se trouvent dans les pages du Web, le degré de pertinence des pages les unes par rapport aux autres et par rapport au contexte de navigation de l'utilisateur.
Ainsi, pour chaque page visitée, l'invention vise à présenter à l'utilisateur la page dérivée la plus pertinente ainsi que des annotations associées à d'autres pages pertinentes et des liens vers d'autres pages pertinentes.
A noter que bien que les méthodes de recherche de score de pertinence (distillation relative) et de transclusion sont ici différentes, elles peuvent être remplacées par les méthodes (conduits et transclusions) décrites plus haut, et vice versa.
Un autre but de l'invention est de permettre qu'une annotation puisse être par exemple un lien vers une ressource d'information tel qu'un fichier, de manière à ce que l'utilisateur puisse ainsi retrouver des ressources d'information simplement en se plaçant dans leur contexte de pertinence : lorsque l'utilisateur navigue et se rapproche du contexte de la ressource qu'il recherche, on vise un système qui la lui propose spontanément.
Plus globalement, l'invention vise ainsi à utiliser le système constituant, pour l'utilisateur, une
"mémoire associative".
On va maintenant décrire un premier système mettant en œuvre le procédé pour accéder sélectivement à l'une parmi une pluralité de ressources à partir d'une ressource de départ, caractérisé en ce qu'il comprend les étapes suivantes : (a) élaborer des scores de pertinence de la ressource de départ et d'autres ressources à l'aide d'un mécanisme de détermination de pertinence, lesdites autres ressources comprenant des ressources indépendantes et des ressources dérivées de la ressource de départ et/ou de ces ressources indépendantes, (b) en relation avec l'accès par un utilisateur à la ressource de départ, fournir ou non à l'utilisateur une information sur l'existence d'une autre ressource ou un accès à ladite autre ressource, en fonction desdits scores de pertinence.
Par ailleurs on va décrire comment, en relation avec l'accès par un utilisateur à une ressource contenant au moins une vue, à la place du (ou en relation au) contenu de chaque vue, ce système sélectionne ou non le contenu d'une autre ressource à présenter, en fonction notamment du score de pertinence de ladite autre ressource.
Suggestion d'une autre ressource
Comment sont déterminés les scores de pertinence
Les utilisateurs ont déclaré au système un certain nombre de centres d'intérêts, que l'on appelle « groupes support ». Chaque groupe support est initialement représenté par un ensemble
d'identifiants de ressources (il s'agit en général d'URL de pages Web populaires). Appelions R cet ensemble. On définit83
• R' par l'ensemble des ressources ayant un lien vers au moins une ressource de R,84
• R'+ par l'ensemble des ressources pointées par au moins une ressource de R",
• R~+~ par l'ensemble des ressources ayant un lien vers au moins une ressource de R"+. A chaque ressource de R"+ est associé un score autorité.
On définit le score autorité, indiquant « l'autorité relative à R », d'une ressource P par la valeur d'une équation d'homogénéité (définie plus loin) sur R {P}.
Pour chaque groupe support le système reçoit en entrée ces différents ensembles85 ou arpente
(crawl) le Web pour les déterminer (et les maintenir), puis calcule et mémorise les scores autorité des ressources constituant l'ensemble R"+ (sachant que les ressources qui ne sont pas dans R"+ ont implicitement un score nul).
Le score de pertinence d'une ressource86 pour un groupe support donné est le score autorité87 ainsi calculé pour cette ressource. En variante, le score de pertinence d'une ressource P pour un groupe support donné peut être déterminé plus simplement en comptant le nombre de fois que P est co- citée88 (par les ressources de R") avec les ressources de R caractérisant ce groupe support. 89
Comment sont élaborés les scores de pertinence des ressources dérivées
Chaque ressource dérivée d'une90 ressource de départ est construite • en reproduisant (et éventuellement en modifiant) une ressource de départ • en insérant dans une ressource quelconque une vue91 (éventuellement modifiée) d'une ressource de départ ou d'un élément d'une ressource de départ.
Les ressources de départ sont reliées par des liens directionnels pour former ensemble un graphe orienté de départ. (Les ressources de départ sont par exemple des pages Web et le graphe orienté de départ est alors le Web).
Dans le cas où la ressource dérivée est obtenue par reproduction d'une ressource de départ ou en insérant dans une ressource quelconque (P7, voir figure 29) une vue ou une copie d'une ressource de départ (P2) prise entièrement, le système crée un lien virtuel - dirigé vers ladite ressource dérivée (L5 dirigé vers P7) - partant de chaque ressource citant une ressource de départ (P2) ayant servi à construire ladite ressource dérivée.
Par « citant une ressource de départ » on entend « ayant un lien vers une ressource de départ », ce lien pouvant être réel ou virtuel. Ainsi dans la figure 29, non seulement le lien (réel) L5 est hérité92 par la page P7 mais aussi les liens virtuels Ll, L2 et L3 sont hérités par cette page P7.
83 On évoque ici la méthode de distillation relative par l'amont qui est décrite plus en détail à la section « Calcul du score de pertinence par rapport à un groupe support ». Cette méthode peut être avantageusement complémentée par la méthode symétrique : la distillation relative par l'aval.
84 R constitue les ressources initiales du groupe support.
85 (en fait il y a aussi besoin de R", et en partie de R"+", pour contrer le népotisme, ceci est décrit plus loin à la section « Anti-népostisme »)
85 (de départ ou d'autres ressources qui peuvent être des ressources indépendantes et des ressources dérivées de la ressource de départ et/ou de ces ressources indépendantes ; la création de ressources dérivées est décrite plus loin à la section « Elaboration et maintenance des ressources dérivées »)
87 (relative à l'ensemble R caractérisant ce groupe support)
88 Une première page est co-citée avec une deuxième page s'il y a une troisième page qui a un lien vers la première page et un lien vers la deuxième page.
89 Noter que les ressources qui ne sont pas dans dans R"+ ont un score nul puisqu'elles ne sont pas co-citées avec les ressources de R. On ne compte donc que les ressources de i?" pour ne calculer que les scores des ressources de i?"+.
90 Une ressource peut être dérivée de plusieurs ressources de départ à la fois, par exemple elle peut contenir plusieurs vues de ressources de départ différentes.
91 (ou une copie)
Dans le cas où la ressource dérivée est obtenue en insérant dans une ressource quelconque (PI) une vue ou une copie d'une partie d'une ressource de départ (P2), cette partie étant ou contenant elle-même une vue ou une copie d'une ressource indirecte de départ (P3) prise entièrement, le système crée un lien virtuel (L3) - dirigé vers ladite ressource dérivée (PI) - partant de chaque ressource citant une ressource indirecte de départ (P3).
Par « citant une ressource indirecte de départ » on entend ici : « ayant un lien vers une ressource indirecte de départ », ce lien pouvant être réel ou virtuel.
La figure 29 illustre l'héritage de liens réels et virtuels, dans le cadre d'un exemple présentant des vues imbriquées. La page P4 contient une vue de la page P3, cette vue contenant elle-même une vue de la page P5 ainsi qu'une vue de la page P6. Comme (dans la page P4) la vue de P5 prend P5 entièrement, elle contribue (à la page P4) le lien virtuel Ll. De même la vue de P6 contribue L2 et la vue de P3 contribue L3. Ainsi, la page P4 hérite93 des liens Ll, L2 et L3. Ensuite, comme la page P2 contient une vue sur la partie de la page P4 qui contribue les liens virtuels Ll, L2 et L3, cette vue contribue à son tour les liens virtuels correspondants (aussi notés Ll, L2 et L3). Enfin, comme la page P7 contient une vue sur P2 (prise entièrement), elle hérite de tous les liens (réels ou virtuels) dirigés vers P2, à savoir Ll, L2, L3 et L5. Par ailleurs, la page PI possède une vue d'une partie de la page P2, cette partie étant une vue de la page P3 prise entièrement et contribuant donc son lien L3. Ainsi PI hérite du lien virtuel L3 (via P2). Cependant, PI n'hérite pas des autres liens de P2 (L5, Ll et L2) car ni elle reproduit P2, ni une vue qu'elle contient prend
P2 entièrement.
Le système construit ainsi un « graphe dérivé virtuel » formé à partir du graphe orienté de départ et de liens virtuels.
Les scores de pertinence sont élaborés comme décrit à la section précédente (en constituant R", R"
+, etc.), mais sur la base dudit graphe dérivé virtuel.
On va maintenant décrire plus concrètement la construction et la maintenance de l'ensemble des liens entrants (réels et virtuels) d'une ressource.
Dans la suite de la description on va souvent utiliser le terme "page" à la place du terme
"ressource". En effet, ce terme est plus approprié puisque l'on voudrait parler de ressource présentable à l'utilisateur de manière autonome. Par "page" on entend ainsi "ressource" (de n'importe quelle sorte) vers laquelle un lien peut être dirigé (de manière à ce que la ressource soit activée lorsque l'utilisateur clique sur ledit lien).
Mécanisme d'héritage de liens entrants
Ce mécanisme est basé sur la notion d'ensemble de sources de liens d'un élément94. On dit qu'une page A est une source de liens pour un élément B si tout nouveau lien (réel ou virtuel) pointant vers la page A pointe également (sous forme de lien virtuel) vers B (et donc vers la page contenant B ainsi que vers toutes les vues contenant B), comme décrit plus haut.
Tout élément peut avoir des sources de liens mais seule une page peut être une source de liens.
D'autre part on dira qu'une page A est une source de liens directe d'un élément B si elle est une source de lien de B et qu'il n'existe pas de page X telle que X soit une source de lien de B et que A soit une source de liens de X.
L'ensemble étendu95 des liens entrants d'une page est ainsi égal à l'union des liens entrants réels de cette page et de l'union, pour toutes les sources de liens directes, de leurs ensembles étendus de liens entrants.
92 Une ressource dérivée hérite d'un lien (virtuel ou non) partant d'une ressource citante et dirigé vers une ressource citée, signifie que pour le système un lien virtuel existe (implicitement) de ladite ressource citante vers ladite ressource dérivée.
93 Lorsque l'on dit qu'une ressource hérite d'un lien, on entend qu'elle hérite d'un lien entrant (i.e. dirigée vers elle).
9 Par « élément » on entend « élément d'une page ».
95 Par liens étendu on entend les liens réels et les liens virtuels.
La construction de ces ensembles étendus est donc séparée en 1. la construction de ces sources de liens directes et 2. l'héritage de liens proprement dit.
Pour la première partie, chaque instance du système possède une fonction renvoyant l'ensemble de sources de liens directes d'un élément donné.
Cette fonction va renvoyer l'union de l'ensemble des pages dont une vue (entière) est contenue dans l'élément demandé et des ensembles de sources de liens directes des parties de pages dont une vue est contenue dans l'élément demandé.
L'ensemble des liens étendu est ensuite calculé comme défini ci-avant, à partir de ces sources de liens directes.
La figure 30 présente un exemple de huit pages. La première (PI) contient une vue entière de la deuxième (P2) ainsi qu'une vue partielle de la troisième (P3). P2 possède une vue entière de P4 ainsi que de P5. La partie de P3 vue par la deuxième vue de PI contient des vues entières de P6 et
P7. P3 contient de plus une vue de P8.
Notons e; l'ensemble étendu de liens entrants, et li l'ensemble de liens réels, d'une page Pi. Le signe + représente l'union d'ensembles.
Les sources de liens directes de PI sont P2, P6 et P7. L'ensemble étendu des liens de PI est l'union des liens entrants réels dirigés vers PI avec les ensembles étendus des liens de P2, P6 et
P7. On a donc : el=ll+e2+e6+e7. De la même façon pour les autres pages on obtient: e2= 2+e4+e5, e3=13+e6+e7+e8, e4=14, e5=15, e6=16, e7=17, e8=18. On voit qu'on obtient ainsi
(simplement en substituant les termes ej) el=ll+ 12+14+15+16+17. (A noter que el n'hérite pas de
L'ensemble des sources de liens directes des pages est stockée dans un cache et est remise à jour régulièrement (voir section « Description de la mise en œuvre du système »).
Quelles sont les autres ressources et comment le système les sélectionne
En relation avec l'accès par un utilisateur à la ressource de départ, le système sélectionne ou non une autre ressource à présenter, en fonction des scores de pertinence.
On va d'abord décrire comment le système sélectionne cette autre ressource96.
Avant l'accès par l'utilisateur à la ressource de départ, un score de pertinence a été attribué - explicitement ou implicitement- à chaque ressource pour chaque groupe support existant dans le système. Rappelons que dans le cas où pour un groupe support donné le score n'a pas été attribué explicitement, il est considéré comme étant nul ; le système sait par avance quelles sont les ressources dont le score est non nul : ce sont ceux qui appartiennent97 à l'ensemble R"+ d'au moins
95 (quelle qu'elle soit : indépendante, c'est-à-dire non dérivée de la ressource de départ), ou dérivée de la ressource de départ, ou encore dérivée d'une ressource indépendante)
97 (ou à l'ensemble R+" dans le cas de la distillation par l'aval).
98 On appelle somme logique le complément du produit des compléments (ceci évite que beaucoup de petits scores ne soient trop facilement meilleur que peu de grands scores). Par exemple, une ressource ayant un score de 10% pour dix groupes support aurait un score global de 1-(1-0.1)10=65% au lieu de 10% si on utilise la méthode du maximum, ou 100% si on utilisait une somme arithmétique.
99 Le contexte de navigation est aussi pris en compte dans la sélection, ceci est décrit à la section suivante.
100 (et un lien sur elle lui est offert ; noter qu'en variante, plusieurs P; ayant un fort score par rapport à P0 peuvent être sélectionnées)
système peut être configuré pour que (notamment si la somme logique pour j de XEJ(PI) est supérieure à la somme logique pour / deXEj(Po) ) Pi soit directement présentée à la place de P0. Optionnellement, on peut privilégier les ressources reproduites (puis modifiées) à partir de la ressource de départ (et à fortiori la ressource de départ elle-même), par exemple en multipliant leurs scores (par rapport à la ressource de départ) par un coefficient supérieur à 1. En effet, les versions reproduites de la ressource de départ (et la ressource de départ elle-même) sont à priori plus pertinentes pour l'utilisateur que les ressources indépendantes.
Remplacement du contenu des vues
En relation avec l'accès par un utilisateur à une ressource, le système sélectionne ou non le contenu d'une autre ressource à présenter le cas échéant à la place du (ou en relation avec le) contenu de chaque vue, en fonction des scores de pertinence.101
Par la méthode présentée plus haut (voir la section « Comment sont élaborés les scores de
L'information de l'existence du P,- ayant le meilleur score est signalée à l'utilisateur104 si ce score S{ est suffisant, ou le système peut être configuré pour que si ce score si est suffisant P,- soit directement présentée à la place de la vue en question.
En variante, on peut stocker (en cache) pour chaque vue son score pour chaque groupe support Ej, calculé comme étant, pour les sources de liens directes de cette vue, la somme logique (l- score de pertinence par rapport à ce
groupe support. Au moment de la présentation de la page contenant la vue, la sélection de la ressource Pt la plus pertinente pour la vue en question se base alors sur la somme logique (ou le maximum) pour j du produit du score de cette vue pour un groupe support Ej avec le score de pertinence XEJ(PI)-
Egalement, on peut privilégier les ressources reproduites (puis modifiées) à partir des sources de liens directes de la vue en question, par exemple en multipliant leurs scores par un coefficient supérieur à 1.
Cas de la prise en compte du contexte de navigation
Le contexte de navigation représente les centres d'intérêt courants de l'utilisateur quand il navigue et visite des ressources les unes après les autres. Un contexte de navigation d'un utilisateur est défini par une association d'un score à chaque groupe support. On peut initialiser le contexte de navigation avec un score 1 pour tous les groupes support pour signaler l'absence de contexte. Pour mettre à jour le contexte de navigation, lorsqu'une nouvelle ressource de départ PQ est visitée par
101 L'utilisateur a moyen, pour une vue particulière, d'indiquer s'il souhaite ou non que la vue puisse être remplacée par le système (si l'utilisateur ne précise pas, chaque vue suivra le comportement par défaut du système).
102 (plus précisément le sous-système « Resolver » qui est décrit plus loin à la section « Elaboration et maintenance des ressources dérivées »)
103 Le contexte de navigation est aussi pris en compte dans la sélection, ceci est décrit à la section suivante.
10 (et un lien sur elle lui est offert ; noter qu'en variante, plusieurs P; ayant un fort score peuvent être sélectionnées)
l'utilisateur, il faut remplacer le contexte K par une moyenne pondérée avec les scores XE(Po) de la ressource pour ces groupes support105 : KE * = λKEi + λXE (po)
Autrement dit, la sélection de ladite autre ressource P, la plus pertinente par rapport à la ressource de départ Po, en tenant compte du contexte de navigation, se fait comme suit : Si XEJ(PÙ est le score de pertinence de P,- par rapport au groupe support Ej, le système sélectionne la ressource P,- dont le score de pertinence par rapport à Po et au contexte de navigation, calculé comme étant la somme logique106 (ou le maximum) pour,/' de KEj -XEJ(PO) -XEJ(PÙ, est le plus élevé. L'information de l'existence de Pt est signalée à l'utilisateur107 si son score Si est suffisant, ou le système peut être configuré pour que (notamment si la somme logique pour j de KEJ -XEJ(PO) -XεjfPi) est supérieur à la somme logique pour./' de KEj -XEJ(PQ) -XEJ(PO) ) Pi peut soit directement présentée à la place de P^.108
Dans le cas de la sélection de vues alternatives (décrite plus haut à la section « Remplacement contenu des vues »), l'équation
Dans le cas où ι*>
scores des vues sont mis en cache, la sélection de la ressource Pi la plus pertinente pour une vue se base sur la somme logique (ou le maximum) pour./ du produit • du score de la vue en question pour un groupe support Ej , • avec le score de pertinence K J -XEJ(P^.
Cas de la prise en compte du contexte d'édition
L'idée est la suivante : lorsqu'une ressource dérivée d'une ressource de départ est créée, ses scores de pertinence (pour les groupes supports respectifs) deviennent une combinaison des scores de pertinence de la ressource de départ et du contexte courant de navigation de l'utilisateur109, ce qui lui permet de se distinguer de la ressource de départ. Ainsi lorsque l'utilisateur visite la ressource de départ, le système sélectionne plutôt sa ressource dérivée quand elle est plus pertinente par rapport au contexte courant (K) de sa navigation.
Ceci est mis en œuvre de la manière suivante. A chaque ressource créée par l'utilisateur est associé un contexte d'édition D. Lorsque l'utilisateur crée une ressource son contexte d'édition est initialisé au contexte de navigation de l'utilisateur à l'instant de cette création. Lors d'une modification d'une ressource, son nouveau contexte d'édition D+ devient la moyenne pondérée de l'ancien contexte d'édition D et du contexte de navigation K actuel (au moment où la nouvelle
105 Le facteur de pondération λ est un nombre entre 0 et 1 décrivant la sensibilité au passé; par exemple on prendra et le présent pour 2/3.
du produit des compléments (ceci évite que beaucoup de petits scores ne soit trop facilement meilleur que peu de grands scores). Par exemple, une ressource ayant un score de 10% pour dix groupes support aurait un score global de 1-(1-0.1)10=65% au lieu de 10% si on utilise la méthode du maximum, ou 100% si on utilisait une somme arithmétique.
107 (et un lien sur elle lui est offert ; noter qu'en variante, une pluralité de P; ayant un fort score par rapport à P0 peuvent être sélectionnées)
108 En variante, comme déjà décrit on peut privilégier la ressource de départ et les ressources qui y sont dérivées par reproduction.
109 (d'autres méthodes, comme l'analyse du contenu des modifications, peuvent aussi être mises en oeuvre)
version est enregistrée) : D+ = KK + KD , où K est un nombre entre 0 et 1 représentant le poids du présent par rapport au passé.
Pour calculer le score de pertinence d'une page P,- pour un groupe support Ej , on prend alors une moyenne pondérée entre : - le score XEJ(PI) défini plus haut comme étant la valeur d'une équation d'homogénéité sur REj J{Pi}, (REJ étant l'ensemble des liens initiaux caractérisant le groupe support Ej) - et son contexte d'édition DEJ(PÏ) pour ce groupe support.
Chaque score XEJ(PÎ) étant ainsi remplacé par sa moyenne pondérée avec le contexte d'édition Εj(Pi), on applique les mêmes équations (décrites ci-avant).
Sélection de ressources dont le contenu a changé
On a décrit comment, en relation avec l'accès par un utilisateur à une ressource de départ, le système fournit ou non à l'utilisateur une information sur l'existence d'une autre ressource ou un accès à ladite autre ressource, en fonction des scores de pertinence.
On a aussi décrit comment, en relation avec l'accès par un utilisateur à une ressource contenant au moins une vue, à la place du (ou en relation au) contenu de chaque vue, le système sélectionne ou non le contenu d'une autre ressource à présenter, toujours en fonction des scores de pertinence.
On va maintenant décrire comment le système présente une autre ressource seulement si elle est nouvelle pour l'utilisateur ou si le contenu de ladite ressource a changé depuis le dernier accès à ladite ressource par l'utilisateur.
Typiquement, l'utilisateur va par exemple visiter une page d'un site de vente en ligne de livres et décide de surveiller un élément d'une page (PI) présentant des livres de science fiction. Plus tard, lorsqu'il va visiter une autre page (P2) qui est pertinente par rapport au même domaine (de la science fiction), le système lui présente la page (PI) du libraire dont il avait sélectionné un élément à surveiller. Toutefois cette dernière (PI) ne lui est présentée que si le contenu de cet élément à surveiller a changé depuis la dernière fois que l'utilisateur l'avait visité.
On va aussi décrire comment le système présente un autre contenu dans une vue seulement s'il est nouveau ou s'il a changé depuis le dernier accès par l'utilisateur audit contenu.
Par exemple, une vue d'une page (P3) à laquelle l'utilisateur accède reflète le contenu d'une page
(P2) pertinente par rapport à la page (PI) du libraire de l'exemple précédent. Le système va remplacer le contenu de cette vue par celle de la page (PI) du libraire pourvu qu'elle ait changée depuis la dernière fois que l'utilisateur l'a vue.
C'est à l'utilisateur de déclarer au système qu'il a vu une page. Ainsi, tant qu'il ne le fait pas, le système va considérer que l'utilisateur ne l'a pas encore étudiée et va continuer à la proposer, et sitôt que la page est déclarée vue, elle ne sera plus affichée tant que son contenu n'a pas changé.
Ainsi le système offre à l'utilisateur un moyen de déclarer qu'il a déjà vu une page (et qu'il ne souhaite donc pas que le système la lui propose spontanément sauf si son contenu a changé).
Régulièrement, le système télécharge sur le serveur toutes les pages « vues » par les utilisateurs et les compare à leur version précédente téléchargée. Lorsque le système observe un changement dans une page il va enregistrer avec cette page la date où le changement a été observé.
Lorsqu'un utilisateur déclare avoir vu une page, le système va mémoriser la date de cet instant (en relation avec ledit utilisateur), ce qui permet de savoir si la page a changé depuis le moment où l'utilisateur l'a vue.
Plus finement (et comme dans l'exemple de la page du libraire donné plus haut), l'utilisateur peut spécifier des éléments de page particuliers dont il faut surveiller le changement. Ainsi le système mémorise dans une table la liste des éléments à surveiller (globalement pour tous les utilisateurs) pour chaque page déjà vue, avec pour chaque élément la dernière date où un changement a été détecté110.
110 Régulièrement, le système télécharge sur le serveur toutes les pages contenant au moins un élément à surveiller et les compare à leur version précédente téléchargée. Lorsque le système observe un changement, il va enregistrer la
Lorsqu'il s'agit de présenter une « autre page » (plus pertinente) à l'utilisateur, le système va sélectionner le cas échéant (en fonction des scores) une autre page dans laquelle au moins un élément que l'utilisateur a voulu surveiller a changé depuis la dernière fois que l'utilisateur a vu la page (ou l'élément en question spécifiquement).
Enfin, dans le cas de la sélection de vues alternatives (décrite plus haut à la section « Remplacement du contenu des vues »), ladite page P,- (la plus pertinente pour la vue en question) sélectionnée doit également satisfaire la condition de changement décrite ci-dessus.
Annotation
Chaque modification d'une page d'origine est montrée à l'utilisateur de manière solidaire à la page dans laquelle ladite modification a été enregistrée, sauf pour le cas des annotations111 qui peuvent aussi être montrées de façon autonome (i.e. de manière adjacente ou superposée à une autre page affichée).112
Le système est apte à présenter des annotations pertinentes113, en plus des procédés déjà décrits.
Par défaut ces annotations peuvent notamment: • être affichées de manière adjacente à la page affichée, • occuper dans la page des espaces réservés à la publicité, • se positionner selon des spécifications données par l'utilisateur au moment de la création de l'annotation, • ou encore être disposées d'une manière spéciale spécifiée ou choisie par l'utilisateur (en sélectionnant parmi des options de configuration d'affichage).
Typiquement, pour créer une annotation associée à une page, l'utilisateur • sélectionne une partie de la page (en y glissant la souris avec le bouton appuyé) • et/ou fournit au système un (ou plusieurs) commentaire (contenant éventuellement un lien), • et donne optionnellement un ensemble de mots-clés (ou une position d'affichage).
Une page dérivée (par modification de la page d'origine) contenant ces informations est alors créée. Lorsque l'utilisateur accède à une page pour laquelle cette page dérivée est sélectionnée comme étant pertinente, le système recherche dans la page l'occurrence d'un de ces mots-clé et affiche la sélection et/ou le commentaire de- manière adjacente à la position de ce mot clé de la manière la moins intrusive possible: par exemple, le mot-clé est simplement souligné et l'annotation apparaît lorsque l'on amène le curseur de la souris sur lui (par roll-over). Le système est apte à ne sélectionner que des annotations dont le contenu a changé depuis la dernière fois que l'utilisateur les a vues (comme décrit à la section « sélection de ressources dont le contenu a changé »).
date où le changement a été observé. Lorsqu'un utilisateur déclare avoir vu une page (ou plus précisément, un élément sous surveillance), le système va mémoriser la date de cet instant, ce qui permet de savoir si l'élément a changé depuis le moment où l'utilisateur l'a vue. Ainsi le système est apte à n'afficher que des pages dont au moins un élément sous surveillance a changé.
111 L'annotation est mise en œuvre comme un cas particulier de modification d'une page. Ainsi chaque annotation associée à une page est enregistrée dans le cadre d'une page dérivée de cette page (i.e. dérivée par reproduction/modification) .
112 Créer une annotation peut consister à simplement mettre en exergue une partie d'une page. Typiquement, l'utilisateur sélectionne une partie d'une page (en y glissant la souris, le bouton étant tenu appuyé) et déclare au système que c'est une annotation associée à cette page. Le système crée alors une page dérivée de cette page, dans laquelle est spécifié l'emplacement de cette annotation dans la page. Bien entendu, l'utilisateur peut aussi modifier le contenu de l'annotation ainsi créée, ou encore créer une annotation quelconque contenant de nouvelles informations, par exemple un lien sur une autre ressource (voir le dernier paragraphe de cette section). Ladite page dérivée créée contient alors en plus ces modifications ou ces nouvelles informations.
113 (c'est-à-dire, des annotations contenues dans des pages qui soient pertinentes par rapport à la page courante visitée et au contexte)
En cliquant sur une annotation avec le bouton droit de la souris l'utilisateur peut (sélectionner dans le menu contextuel l'option lui permettant de) visionner l'intégralité de la page contenant cette annotation114.
Une annotation peut être simplement textuelle, ou encore visuelle ou sonore, par exemple un message oral ou une vidéo (ou avoir n'importe quels autres effets sur les sens) et peut comporter un ou plusieurs lien(s) cliquable(s) par l'utilisateur.
Les annotations sont aptes à comporter du code exécutable directement et permettent ainsi d'étendre l'interface utilisateur.
Une annotation peut contenir un lien vers une ressource115. Par exemple, l'annotation peut consister en une icône représentant un document (et comportant un lien vers lui), icône que l'utilisateur a associée à la page en effectuant un glisser-déposer (de cette icône) à partir de son bureau.
Le système offre l'option de télécharger (sur le serveur du système) la ressource qui se trouve au bout de ce lien, de manière à ce que, lorsque l'annotation contenant ce lien est présentée, l'utilisateur puisse automatiquement retourner cette ressource sur son poste client et l'ouvrir directement, simplement en cliquant dessus (comme il fait d'habitude pour ouvrir un document).
Calcul du score de pertinence par rapport à un groupe support
Homogénéité
Equation scalaire
Ayant E l'ensembles des pages dont on cherche l'homogénéité E) I(E) est le cardinal de l'intersection
des liens entrants des pages de E, U(E) de runion, S(E) le cardinal des liens entrants de la page qui en compte le moins, B(E) de celle qui en compte le plus,
constante.
L'introduction de la pondération par ω est nécessaire car sinon l'équation ne fait pas de différence entre le cas d'une page ayant peu de liens entrants mais dont tous sont des liens entrants des autres pages de l'ensemble (devrait donner une forte homogénéité mais donne une faible valeur) et le cas où toutes les pages ont beaucoup de liens entrants mais seul un petit sous-ensemble leur est commun (l'équation donne correctement une faible homogénéité). La correction avec la pondération par ω augmente le score dans le premier cas (car plus le rapport est petit plus la correction est forte). Le facteur ^indique la force de la correction. Plus il est grand (maximum 2) plus forte est la correction. 0.6 est sans doute une bonne valeur.
Equation par les raisons d'aimer. , où p(S) est le rapport entre le cardinal de l'union des liens entrants des
pages de S divisé par le cardinal de l'espace de travail (l'ensemble des pages dont on considère qu'il est possible qu'elles aient pu pointer sur une page de S, c'est-à-dire qu'elles les connaissent). Etant donné qu'il n'est pas possible d'obtenir la taille exacte de cet espace de travail on va généralement prendre l'ensemble des pages connues par le système.
114 Et à partir de la page dérivée il peut remonter à la page d'origine à laquelle l'annotation avait été associée. US (telle qu'un document de traitement de texte ou de tableur, une image ou encore un document audio-visuel)
Distillation absolue/relative
On décrit ci-dessous les méthode de distillation vers l'arrière (i.e. vers l'amont) pour obtenir des scores. A noter que les méthodes symétriques vers l'avant (vers l'aval) peuvent aussi être utilisées pour obtenir des scores ou pour complémenter les scores obtenus par l'amont.
Distillation absolue dans un certain domaine de pages
A chaque page est associé un score pivot et un score autorité et le but de l'algorithme est de trouver des valeurs pour ces scores tels que 1. le score pivot d'une page est égal à la somme (à un facteur de proportionnalité près) des scores autorité des pages vers lesquelles elle a un lien 2. le score autorité d'une page est égal à la somme (au même facteur de proportionnalité près) des scores pivot des pages qui ont un lien vers elle.
Afin de parvenir à ce résultat, on initialise les scores au hasard (par exemple tous à la même valeur), puis on recalcule alternativement les scores pivot et les scores autorité des pages, en additionnant des scores respectivement autorité et pivot, jusqu'à ce que les valeurs se stabilisent. A chaque étape on divise tous les scores pivot par leur somme et tous les scores autorité par leur somme afin d'éviter que les valeurs explosent.
Distillation relative à un ensemble de pages R
Rappelons que l'on définit R" par l'ensemble des pages ayant un lien vers au moins une page de
R,116 R'+ par l'ensemble des pages pointées par au moins une page de R'.
A chaque page de R' est associé un score pivot.
A chaque page de R'+ est associé un score autorité.
On définit l'autorité relative à R pour une page P par la valeur d'une équation d'homogénéité sur
R .{P}, où le cardinal d'un ensemble de pages est remplacé par la somme des scores pivot de ces pages.
Le but de ralgorithme est de trouver des valeurs pour ces scores tels que 1. le score pivot d'une page est égal à la somme (à un facteur de proportionnalité près) des scores autorité des pages vers lesquelles elle a un lien 2. le score autorité d'une page est égal à l'autorité relative à R pour cette page.
Pour ce faire on utilise une méthode similaire à celle de la distillation absolue sauf que le recalcul des scores autorité utilise l'autorité relative et non plus simplement la somme des scores pivot. La pondération des scores s'effectue comme avant.
Extension à R" '
Pour la distillation relative il peut être intéressant, afin d'obtenir des résultats plus précis, d'étendre l'ensemble des pages pivot à R_+". Etant donné que cet ensemble risque d'être trop grand, on effectue quelques itérations de l'algorithme (qui sont effectuées avec R" comme ensemble de pages pivot) puis on remplace l'ensemble R" par l'ensemble des pages ayant un lien vers au moins une page de R"+ ayant un score autorité suffisamment grand. Cette opération peut être effectuée plusieurs fois au cours du déroulement de ralgorithme.
Elaboration et maintenance des ressources dérivées
Introduction
Lorsque l'utilisateur demande à modifier une page en utilisant un outil externe, le système va créer une page dérivée117.
116 R constitue les pages initiales du Groupe Support.
Ses modifications sont automatiquement déterminées en comparant le document avant modification et sa nouvelle version après modification, et sont mémorisées dans une structure
XML.
On va maintenant notamment décrire le procédé pour l'affichage d'une ressource personnalisée obtenue à partir d'une ressource d'origine (page externe), caractérisé en ce qu'il comprend les étapes suivantes :
- charger la ressource d'origine à partir d'un site mettant ladite ressource d'origine à disposition de l'utilisateur, enregistrer dans une mémoire une ressource de travail obtenue à partir d'une copie de la ressource d'origine,
- mettre en œuvre des outils de modification de ressource pour produire à partir de la dite ressource de travail une ressource modifiée,
- enregistrer dans une mémoire un ensemble d'informations représentatif des différences entre la ressource d'origine ou la ressource de travail et la ressource modifiée, et
- lors d'un accès ultérieur à la ressource d'origine, engendrer, à partir de la ressource d'origine dans sa version courante et dudit ensemble d'informations représentatif desdites différences, une nouvelle ressource modifiée.
Pour bien séparer les données XML "classiques" de celles relatives aux spécificités de notre système on sépare la définition d'un site (par site on entend un ensemble de pages, tel qu'un site
Web) en des données XML de deux types :
Les "legacy XML" contiennent toutes les données brutes ayant été créées pour un site (le « legacy
XML » remplace ici la « version courante » décrite dans la première partie du rapport). Par exemple, dans le cas d'une page contenant une vue vers une autre page du site, les contenus de ces deux pages se trouvent dans des legacy XML, mais pas le fait que la première contienne une vue vers la seconde.
Le "XML des différences" (c'est l'équivalent de l'objet des différences décrit dans la première partie du rapport), contient tout ce qui manque dans les legacy XML pour décrire le site complètement, c'est-à-dire ne contient aucun contenu (texte, etc.) mais plutôt tout ce qui est référence entre éléments, l'emplacement et la référence de toutes les vues. Il contiendra les pages dérivées et une description des différences (d'où son nom) présentes dans les pages dérivées par rapport aux pages d'origine118. La structure de ces fichiers XML sera décrite dans les sections suivantes.
A noter que ce qui est appelé "fichier XML", en particulier pour les legacy XML, peut être stocké et organisé de façons diverses, non nécessairement sous forme de fichiers XLM séparés, par exemple en les regroupant tous dans un fichier unique, sous un même nœud, ou encore dans une base de données XML.
A noter enfin que, l'utilisateur pouvant créer des version dérivées de pages externes, le XML des différences pourra contenir des références vers des pages/éléments ne se trouvant pas dans un legacy XML mais dans une page externe (html).
Finalement; cette section décrit comment construire une description d'une page dérivée à partir d'une version modifiée par l'utilisateur (en utilisant n'importe quel éditeur du commerce) mais un éditeur spécialisé, permettant notamment de créer des vues, peut également modifier ces structures.
117 A partir de ce point, l'expression "page dérivée d'une page X" désigne uniquement une version modifiée de X (et non une page contenant une vue éventuellement modifiée de X).
118 Encore une fois, si l'utilisateur a ajouté/modifié un élément, le contenu de son élément se trouvera dans un legacy
XML et le fait qu'il a ajouté ou modifié un élément, ainsi que l'emplacement du nouvel élément sera dans le XML des différences.
Comment identifier un élément qui doit être référencé
Afin de pouvoir décrire les modifications effectuées par un utilisateur sur une page il est nécessaire de placer, dans cette description, des références à des éléments de la page originale.
Deux cas de figure peuvent se produire pour une référence particulière :
Soit l'élément référencé possède un identifiant unique, et la référence est complètement définie par cet identifiant.
Dans le cas contraire il faut donner une description soit du contenu de l'élément soit de sa position dans la page.
Plus précisément, en l'absence d'identifiant, on a trois façons d'identifier un élément dans un document : • deep-d-ref ("référence directe profonde") : si on parle d'un élément à supprimer, on donne le contenu complet de cet élément, ainsi que (nécessaire dans le cas où plusieurs éléments possèdent ce même contenu) le numéro de l'élément voulu. Traduite en français, une telle référence pourrait ressembler à "la troisième occurrence de <p>hello<br/>world</p>". • shallo -d-ref ("référence directe superficielle"): si on parle d'un élément à modifier, on donne l'élément ainsi que son texte intérieur (mais pas ses enfants) • p-ref ("référence par les parents") : si on parle d'un élément à déplacer, ou alors de l'endroit où placer un élément, on donne le xpath de l'élément.
XML des différences
Le XML des différences décrit la partie dynamique du système, en particulier tout ce qui est référence. Il décrit quelles données utiliser et comment les modifier afin de construire la structure
XML finale qui permettra de construire ce qui sera présenté à l'utilisateur (cette dernière sera appelée "structure résolue" par la suite).
Chaque nœud dans le XML des différences correspond à un nœud dans la structure résolue et spécifie
1. Comment construire le contenu, c'est-à-dire les données à placer pour cet élément dans la structure résolue. 2. A quel endroit il doit être placé dans la structure résolue.
La première information est spécifiée à l'aide du nom de l'élément et éventuellement un attribut ref qui indique une source de données.
Le fichier XML de différences peut contenir les éléments suivants119 : • deported : Ceci signifie que le contenu de l'élément doit apparaître comme une copie de l'élément pointé par l'attribut ref (avec tous les enfants) • imported : Cet état est similaire à deported, à cette différence que l'élément est une version dérivée de la source (pointée par ref), il peut donc être une version modifiée de la source (i.e. en plus de ref, il peut être défini par des modifications à apporter à la source). • created : Indique que l'élément a été élément créé à partir de rien par l'utilisateur. Il contient un attribut ref indiquant à quel endroit prendre l'élément dans un legacy XML. (Tous les enfants du nœud pointé dans le legacy XML seront pris avec) • rejected : Indique que l'élément ne doit pas être affiché. L'élément possède alors un attribut replacing pour supprimer (avec ses enfants) l'élément qui serait venu implicitement via une importation. • propagated : indique que cet élément a été suggéré vers l'amont par l'auteur d'une page dérivée. Cet élément se comporte de la même façon qu'un élément deported • moved : Un élément contenu dans un élément importé peut être à cet état. Il indique que
119 Cette manière de faire constitue une variante de l'objet diff définit dans la première partie du rapport.
l'élément correspondant, à la source de l'importation, n'a pas été modifié mais seulement déplacé à l'intérieur de l'élément importé.
Seuls les éléments imported, created et moved peuvent avoir des enfants.
La seconde information (sur l'emplacement) peut être définie ainsi : • A l'aide d'une référence de l'attribut replacing : Si un enfant d'une importation possède cet attribut, l'élément correspondant à la source de l'importation contenant cet élément sera remplacé par celui-là. En particulier, si l'élément est dans l'état rejected, cet attribut signifie que l'élément pointé par replacing doit être supprimé dans la structure résolue (un attribut replacing se réfère toujours à un enfant de la source de l'importation la plus proche contenant l'élément ayant cet attribut) • De façon implicite : Si A précède immédiatement un élément C, dans la structure résolue il va également précéder immédiatement cet élément C. Si un élément A est un enfant d'un élément B, ceci signifie que dans la structure résolue l'élément A sera également un enfant de B.
Pour placer un élément de façon implicite il peut être nécessaire de placer des "marqueurs", qui sont juste des références à des éléments de la source d'une importation ou d'un legacy XML (un marqueur pointe toujours vers un enfant de la référence du plus proche nœud created ou imported contenant ce marqueur)
A noter que les marqueurs ne possèdent pas d'identifiants car leur unique utilité est de placer les autres.
La figure 31 présente un élément 10 étant une importation d'un élément 1. L'élément 1 possède un enfant 11 qui lui-même contient des enfants 2, 3 et 4, et l'élément 3 contient des enfant 7, 8 et 9. Dans le fichier XML, l'élément 10 contient un enfant (marqueur) pointant vers 3, et ce marqueur contient un élément (12) par exemple dans l'état imported suivi d'un marqueur pointant vers 8. Ces marqueurs indiquent que l'élément 12 doit être placé juste avant 8, et si ce dernier n'est pas trouvé, alors 12 doit être placé comme enfant de 3.
La structure résultante (voir figure 32) est donc la suivante : 10 possède un enfant 10:11 qui lui- même contient trois enfants 10:2, 10:3 et 10:4, et 10:3 contient quatre enfants 10:7, 12, 10:8 et 10:9. A noter que l'élément 10:11 est absent du fichier XML même sous forme de marqueur. Finalement, si un élément doit remplacer un élément dans la source d'une importation tout en étant placé ailleurs (le nouvel emplacement étant spécifié de façon implicite), la référence vers l'élément à remplacer se trouve dans l'attribut movedRepIacing et replacing n'est pas présent dans la description de l'élément.
Plusieurs informations d'emplacement peuvent être présentes pour un même élément, et elles sont considérées dans l'ordre suivant, la première pouvant s'appliquer étant utilisée : 1. si l'attribut replacing pointe un élément se trouvant toujours dans la structure importée, l'élément va se trouver placé comme l'élément pointé 2. sinon, si l'élément est un enfant d'un élément Bι et est suivi (directement ou non) d'un autre élément E2, (également enfant de Ε ), alors il doit précéder E2 si à ce dernier correspond un élément dans la source de l'importation. 3. sinon, si l'élément est un enfant d'un élément Et alors il doit être placé comme enfant de l'élément correspondant dans la structure résolue.
A noter, pour la seconde règle, si l'élément E2 existe dans la source de l'importation mais pas dans la structure résolue (par exemple parce que, dans la source de l'importation, E2 s'est déplacé comme enfant d'un élément ayant été supprimé dans cette version dérivée), alors il ne sera pas visible dans la structure résolue.
Contenu des Legacy XML
Chaque legacy XML définit une structure XML dépourvue de références, qui pourra être placée telle quelle dans une structure résolue (en fait tous les éléments d'une structure résolue se trouveront soit dans un legacy XML soit dans une page (html) externe).
Tous les éléments d'un legacy XML vont de préférence contenir un identifiant afin de permettre au XML des différences de les référer, par exemple pour indiquer où placer une vue dans cette structure.
Par exemple si l'utilisateur a créé une page P contenant une vue V, et à l'intérieur de cette vue a ajouté un paragraphe, la page P sans la vue se trouvera dans un legacy XML, et le paragraphe ajouté par l'utilisateur se trouvera dans un autre legacy XML. En effet il n'est pas possible de placer le nouveau paragraphe et le reste de la page dans un même legacy XML car ils sont séparés par des nœuds provenant d'ailleurs (la source de la vue).
Si maintenant l'utilisateur ajoute deux paragraphes dans la vue, ils devront être placés dans deux legacy XML différents (car, encore une fois, ils ne forment pas une structure en un seul morceau).
Exemple de structures XML
La figure 33 présente un exemple de petit site web illustrant le rôle des différents fichiers.
Supposons tout d'abord que l'utilisateur crée une version dérivée d'une page externe et modifie un élément (2) : Pour la page dérivée on va créer un élément imported, et pour la modification on va créer un élément created avec un attribut replacing. Le nouveau contenu (DIV) se trouve dans un legacy XML et est pointé par l'attribut ref.
Les modifications effectuées sur une page d'origine sont traitées un nœud à la fois :
Supposons que l'utilisateur n'a pas modifié l'enfant 4 de 2. Etant donné que l'attribut replacing signifie seulement un remplacement d'un nœud (sans ses enfants), il n'est pas nécessaire de faire une copie de 4 (et si à l'avenir 4 change dans la page d'origine, les changements seront reflétés dans la version modifiée).
Si l'utilisateur avait également modifié 4 on aurait créé un autre élément created comme enfant du premier, pointant (ref) vers un autre legacy XML.
La figure 34 présente ce qui se passe si l'utilisateur déplace 3 comme enfant de son nœud div :
Pour signaler que l'élément n'a pas été modifié mais a été déplacé, on utilise un élément moved.
Pour indiquer que l'utilisateur a placé l'élément comme enfant de l'élément created on place l'élément moved à cet endroit (si 2 n'avait pas été modifié il aurait fallu créer un marqueur pour 2 à l'emplacement de ce nœud created.
Finalement, la figure 35 présente le cas où l'utilisateur crée des éléments (par exemple un paragraphe contenant une image) à l'intérieur de cet élément 3.
A nouveau il faut créer un legacy XML et y placer ces éléments, et ensuite placer un élément created à l'endroit où ces nouveaux éléments doivent se trouver. Contrairement au cas de la modification d'un élément, lors d'une création il est possible de créer plusieurs éléments simultanément, avec un seul élément created. Pour pouvoir placer des éléments (par exemple moved, imported, ete) dans une telle structure il est possible d'utiliser des marqueurs. Comme déjà dit brièvement, un marqueur se réfère toujours à un élément de la plus proche importation ou création, contrairement aux références d'éléments moved qui s'appliquent exclusivement à l'importation la plus proche (en effet, pour déplacer un élément dans une structure created il suffit de la déplacer dans le legacy XML directement).
Manipulation de vues dans une page
Comme déjà évoqué, le système permet de créer dans des pages des vues vers d'autres pages. Du point de vue XML, cela revient à ajouter dans le legacy XML un nœud deported à l'endroit en question.
Lorsqu'une vue est modifiée, le système va créer une page dérivée (donc une importation) de la source de cette vue, contenant les modifications effectuées par l'utilisateur, et changer la définition de la vue pour la faire pointer vers cette nouvelle version dérivée.
Construction du fichier XML à partir d'une version HTML modifiée d'une version HTML existante
(Algorithme Diff)
L'utilisateur a effectué des modifications sur une page web et le système doit maintenant construire la définition de cette version dérivée. Les éléments du fichier original possèdent tous un identifiant unique, et le système considère que ces attributs sont conservés lorsque l'utilisateur effectue des modifications sur les éléments.
Ceci se fait en trois étapes.
1.Tout d'abord il s'agit d'établir les correspondance entre les éléments du fichier modifié (qui sera appelé H' par la suite) et ceux du fichier original (H).
2.Ensuite il s'agit, indépendamment du contenu, d'établir les changements de structure effectués sur le document. Ces changements seront décrit à l'aide d'une structure contenant des marqueurs et des éléments dans l'état moved.
3. Finalement, une fois les changements de structure établis il s'agit de décrire les changements de contenus (c'est-à-dire les changements d'attributs ou de texte). Ceci se fera par-dessus la structure déjà partiellement construite à l'étape précédente.
A noter que pour éviter de devoir créer des marqueurs pour les supprimer ensuite il est en fait préférable d'effectuer les deux dernières étapes en parallèle.
D'autre part, dans les explications ci-dessous, placer un élément dans un certain état signifie créer un élément XML dont le nom est celui de l'état en question. En effet, une production de cet algorithme ira toujours dans le fichier XML des différences, car il s'agit d'une importation.
1) Etablissement des correspondances
La première étape consiste à établir une table indiquant, pour chaque élément de H, le ou les éléments de H' possédant le même identifiant, puis de construire l'ensemble des éléments de H' qui soit ne possèdent pas d'identifiant soit en possèdent un qui est absent de H.
On pourra ainsi classer les éléments de H' ou H en quatre catégories :
A)Les éléments se trouvant dans H mais pas dans H' (c'est-à-dire ayant été supprimés par l'utilisateur)
B)Les éléments se trouvant dans H et exactement une fois dans H'.
C)Les éléments se trouvant dans H et plus d'une fois dans H' (c'est-à-dire qu'il y a plusieurs éléments de H' possédant le même identifiant - seul l'identifiant est considéré pour l'établissement de ces correspondances)
D)Les éléments se trouvant dans H' et absents de H, i.e. soit ne possédant pas d'identifiant soit possédant un identifiant inconnu. Ce dernier cas peut se produire si l'utilisateur a effectué un copier-coller à partir d'un autre document, ainsi l'identifiant est externe.
2) Détection des changements de structure
La deuxième étape se base exclusivement sur la structure (i.e. quel noeud est le successeur / parent d'un autre) et sur les correspondances établies à l'étape précédente. • Tout élément de H' se trouvant dans le cas A est placés à la racine de la structure XML
sous forme d'un élément rejected.
Ensuite, tous les éléments de l'arbre ' sont parcourus de la racine aux feuilles puis de droite à gauche (afin que les successeur d'un noeud soient traités avant ce dernier) • Pour tout élément se trouvant dans le cas B, Il faut chercher si l'élément a été déplacé. Désignons par l' l'élément de H' et 1 l'élément de H. Soit P(l') le parent de l' et P(l) le parent de 1. Soit finalement S(l') le successeur de l' (s'il existe) et S(l) le successeur de 1, si ce dernier existe. Le successeur de l' est le premier enfant du même parent suivant l' et étant ni créé ni déplacé. Le successeur de 1 est le premier enfant du même parent suivant 1 et n'ayant pas été supprimé dans H'. Créer dans la structure XML des marqueurs pour les correspondants dans H de S(l') et P(l'). Ces marqueurs ne doivent être créés que s'il n'existe encore aucun élément dans la structure XML correspondant aux mêmes éléments de H'. Si S(l') ne correspond pas à S(l) ou si P(l') ne correspond pas à P(l), l'élément doit être placé dans l'état moved120, comme enfant de P(l') et comme prédécesseur de S(l') (créer ces éléments sous forme de marqueurs s'ils n'existent pas déjà explicitement. Si P(l') n'existait pas il peut être placé comme enfant de la racine de l'arbre) • Pour une classe d'éléments dans le cas C (par classe on entend un ensemble d'éléments possédant le même identifiant), il faut en choisir un qui sera traité comme étant dans le cas B. Le plus simple est de chercher si l'un d'eux n'aurait pas été placé dans l'état moved par la description de l'algorithme pour le cas précédent. Si un tel élément n'est pas trouvé alors prendre le premier121 Pour tous les autres éléments de la classe, leur donner un nouvel identifiant et les traiter comme dans le cas D. Ils seront à l'étape suivante vus comme des éléments created et une copie de leur contenu sera effectué. A noter que, comme le reste de l'algorithme, on travaille nœud par nœud, et que si l'utilisateur a effectué une copie d'un arbre entier, il faudra effectuer cette opération un nœud à la fois et non pour tout l'arbre. • Finalement, pour les éléments se trouvant dans le cas D, il faut les placer à l'aide de marqueurs comme déjà décrit. Leur état sera created.
3) Détection des changements de contenu
L'étape précédente s'est contentée de construire une structure vide ne contenant que des références vers H II s'agit à présent de créer des legacy XML, lorsque c'est nécessaire, avec le nouveau contenu des éléments que l'utilisateur a modifiés ou créés, et de décider quel sera l'état des éléments.
Les éléments se trouvant dans le cas A ne possèdent pas de contenu, ayant été supprimés par l'utilisateur.
Pour les éléments se trouvant dans le cas B ou C, il faut comparer l'élément avec celui du document original (H), c'est-à-dire son texte intérieur et ses attributs. Si ce contenu diffère, l'élément doit être placé dans l'état created et il faut faire pointer son attribut replacing (ou movedReplacing si l'étape précédente l'avait placé dans l'état moved) vers l'élément original. Le nouveau contenu de l'élément doit être placé dans un nouveau legacy XML et pointé par l'attribut ref. Sinon, si l'élément avait été placé dans l'état moved à l'étape précédente, le laisser dans cet état. Sinon, si l'élément n'avait pas reçu d'état, il peut être supprimé de la structure.
120 Dans le cas contraire, l'état est simplement non encore spécifié et obtiendra une valeur à l'étape suivante 121 On peut ensuite raffiner cette méthode, idéalement il faudrait choisir celui qui ressemble le plus à l'élément original, tant en terme de position dans le fichier qu'en terme de contenu
Pour le cas C, tous les éléments d'une classe sauf un seront traités comme des éléments créés, comme s'ils se trouvaient dans le cas D (Si l'étape d'analyse de structure et l'étape d'analyse de . contenu sont séparées alors ceci viendra implicitement par le fait que ces éléments auront reçu un identifiant fiais, donc absent de H)
Finalement, pour les éléments dans l'état D, il est nécessaire d'en placer le contenu dans un legacy XML. Leur état sera created et ils ne possèdent pas d'attribut replacing. (Le contenu de cet élément sera pointé par l'attribut ref).
Si le parent d'un élément D est également dans le cas D, ils peuvent partager le même legacy XML, et seul le parent doit être présent dans le XML des différences. Si le prédécesseur ou un enfant (1) d'un élément D (2) ayant été ainsi caché dans la structure des différences n'est pas le cas D alors il faut créer un marqueur pointant vers 2 dans le legacy XML, qui permette de placer 1 dans la structure résolue.
Propagations vers l'amont
Lorsqu'un utilisateur a fait une version modifiée (c'est-à-dire dérivée) d'une page originale, il peut suggérer ses modifications à l'intention du propriétaire de ladite page originale. Ce dernier a ensuite la possibilité d'accepter des modifications qui lui ont été suggérées, les intégrant ainsi à la page originale.
Ainsi, chaque fois qu'une page est ouverte en mode d'édition, l'ensemble de toutes les suggestions provenant de pages dérivées est affiché à l'intérieur de la page.
La figure 36 présente un exemple ou cinq auteurs de pages dérivées d'une page originale ont suggéré leurs modifications. Dans cet exemple : 1. Le premier utilisateur a suggéré de supprimer le premier élément de la page 2. Le second utilisateur a suggéré de remplacer ce premier élément par une autre version 3. Le troisième utilisateur a suggéré un élément à ajouter avant le deuxième 4. Le quatrième utilisateur a suggéré un autre élément, également à ajouter avant le deuxième. 5. Le cinquième utilisateur a suggéré de remplacer le premier élément par encore une autre version, et en plus d'ajouter une paire d'élément (dont le premier est une version dérivée du second) avant le quatrième
La figure 37 présente ce que voit l'utilisateur à l'amont (c'est à dire l'auteur de la page originale):
On voit en particulier qu'il a trois versions alternatives au premier élément, entre autres la suggestion de le supprimer.
Ensuite, concernant la suggestion du cinquième utilisateur, l'utilisateur a la possibilité d'accepter soit les deux pages (dont la première est une version dérivée de la seconde) mais ne peut accepter la première sans accepter la seconde.
Voici une brève description de la façon dont les propagations vers l'amont fonctionnent du point de vue de l'XML.
Tout fonctionne au niveau du nœud, ce qui signifie que si l'utilisateur active la propagation vers l'amont pour tout un sous-arbre, en réalité il va activer la propagation vers l'amont de chaque élément de ce sous-arbre individuellement.
Lorsqu'un élément est propagé, un élément propagated avec un attribut ref pointant vers l'élément propagé va être placé à l'endroit correspondant à l'amont (éventuellement à l'aide de marqueurs, si la page à l'amont est elle-même une page dérivée).
Plus précisément, cet élément sera placé comme enfant de l'élément correspondant au parent à l'aval, et immédiatement avant l'élément correspondant au successeur à l'aval.
Si le parent de l'élément propagé existe déjà à l'aval, l'élément propagated sera placé comme enfant de cet élément. Dans le cas où l'utilisateur à l'aval a lui-même créé le parent, les deux éléments propagated correspondants seront placés comme enfants l'un de l'autre.
Par conséquent, si l'utilisateur modifié un élément dans la page et ajoute un enfant à cet élément, et ensuite active la propagation pour ces deux éléments, il va tout d'abord créer un élément propagated frère de l'élément original, puis un élément propagated enfant de l'élément original (et non enfant de l'élément propagated correspondant à sa modification - ainsi il sera possible pour l'utilisateur à l'amont d'accepter le nouvel enfant et de refuser la modification du parent) A l'aval, lorsqu'un élément est propagé, il reçoit un attribut back=" active" pour indiquer qu'il a été propagé vers l'amont.
L'utilisateur à l'amont a ensuite la possibilité de refuser cette propagation (auquel cas l'élément propagated à l'amont est supprimé, et l'élément à l'aval reçoit un attribut back="rejected"). Enfin, si l'utilisateur à l'amont accepte cette propagation, l'élément à l'aval va être déplacé à l'amont, c'est-à-dire que l'élément propagated à l'amont va être remplacé par celui se trouvant à l'aval et l'élément à l'aval va être supprimé du fichier XML des différences. Il sera alors rendu visible dans la page de la même façon que s'il avait été créé à l'amont.
Si l'élément possédait un attribut replacing, il va effectivement remplacer l'élément original, c'est- à-dire que les enfants de ce dernier vont être déplacés comme enfants de la nouvelle version, et l'ancien va être supprimé. 122 L'identifiant à l'amont va rester le même au cours de cette opération.
Construction de l'XML à renvoyer à l'utilisateur
Cet algorithme est utilisé tant pour traiter les pages dérivées de pages html (ou plus généralement de toute structure XML dépourvue d'identifiants) que de pages dérivées de pages XML (dotées d'identifiants), la seule différence étant la nature des références vers la page originale, qui sont des références relatives à la position ou au contenu dans le premier cas et des références vers des identifiants dans le deuxième cas.
Les algorithmes construisant le XML stocké sur disque ayant été décrits, il s'agit maintenant de voir comment reconstruire, à partir de ce XML, la structure XML à renvoyer à l'utilisateur, où par exemple tout ce qui était implicite a été rendu explicite, où les différences d'une page dérivée sont réalisées sur la version actuelle de la source de cette page dérivée, et ainsi de suite.
Cette partie du système est appelée le Resolver.
Plus précisément, le resolver est un système capable de trouver un élément étant donné son identifiant, et, une fois un élément connu, peut en retourner une partie des enfants sélectionnés par des filtres et une profondeur maximale.
Il fonctionne de façon paresseuse, c'est-à-dire qu'il reçoit une requête, et qu'au cours du traitement de cette requête un sous-ensemble du site complètement résolu est construit et agrandi en fonction des besoins.
Il peut être partagé en trois parties, qui sont : 1. Construction d'un nœud à partir de sa définition
C'est le contraire de la deuxième partie de l'algorithme diff présenté plus haut, c'est-à-dire il s'agit, ayant un élément dans le XML des différences, de construire son contenu (mais pas ses enfants) 2. Construction de la liste des enfants d'un élément déjà résolu
Cette partie doit être capable de gérer les déplacements d'éléments (éléments moved). 3. Recherche d'un élément à partir de son identifiant
Cette dernière partie est en fait la première chose à faire par le resolver. Ayant un identifiant, il s'agit de trouver la définition de l'élément ayant cet identifiant (il peut arriver que l'identifiant soit celui d'un élément qui n'est pas présent dans le fichier des différences mais vient à travers une importation). Une fois ceci fait on peut utiliser la première partie pour construire l'élément, puis la seconde partie autant que nécessaire pour obtenir toute la structure demandée par l'utilisateur dans sa requête au resolver.
122 A noter que l'on peut, à l'aide de marqueurs qui donnent des identifiants aux éléments, éviter les changements d'identifiants à l'aval lors d'une propagation à l'amont.
Pour chaque élément imported de la structure paresseuse le système doit stocker la liste des modifications à la source qui n'ont pas encore été appliquées. Au début cette liste est l'ensemble des descendants de cette importation (dans le fichier des différences) n'étant pas des marqueurs et n'en étant pas séparés par une autre importation.
Il faut en outre séparer le déplacement d'un élément en deux différences qui sont : supprimer l'élément à la source du déplacement ; et replacer l'élément à la destination du déplacement. Ceci est nécessaire car si seule une partie de l'arbre contenant la source du déplacement a été résolue alors seule la première partie du déplacement peut être réalisée (et si plus tard la structure résolue grandit pour recouvrir la cible du déplacement alors la deuxième moitié du déplacement pourra être réalisée). A l'inverse, si seule la cible du déplacement a été résolue, la première moitié du déplacement devra rester dans la liste des différences, de sorte que, si la source du déplacement est résolue alors l'élément pourra être supprimé de cet endroit.
En pratique il est possible de définir ces deux moitiés de déplacement en disant que la première moitié est une suppression et la deuxième moitié est effectivement moved (ou movedReplacing), tout en gardant à l'esprit que la sémantique de moved change dans le cadre de cet algorithme.
Construction d'un nœud à partir de sa définition
Comme déjà évoqué dans l'algorithme diff, le contenu d'un élément dans la structure résolue est défini par son état, c'est-à-dire par le nom de l'élément dans le fichier des différences. • S'il s'agit d'un élément created alors le contenu est le nœud XML (se trouvant dans un legacy XML) pointé par l'attribut ref. • S'il s'agit d'un élément moved, imported ou propagated alors le contenu de cet élément est le même que celui de l'élément pointé par son attribut ref. A noter que lorsqu'un élément imported est rencontré il faut stocker dans une structure associée la liste des différences que décrit cette importation, comme dit à la section précédente. • S'il s'agit d'un élément rejected cela signifie qu'il faut considérer que l'élément n'existe pas (demander cet élément produit une erreur)
Liste des enfants d'un élément déjà résolu
Pour cette partie il s'agit de prendre la liste des enfants se trouvant à la source (comme vu à la partie précédente, chaque élément possède une source. Il s'agit toujours d'une structure complètement résolue, et non par exemple d'une partie d'un fichier de différences), ensuite chercher les différences qui concernent cette liste d'enfants et les appliquer. Il faut donc prendre la liste des différences non encore appliquées du plus proche élément dans l'état importé égal ou contenant l'élément, et y sélectionner celles qui correspondant à l'un des critères suivants: 1. Les modifications, suppressions, déplacements d'un élément de cette liste d'enfants, donc tous les éléments possèdent un attribut replacing ou movedReplacing pointant vers un enfant de la liste, et tous les éléments moved possédant un attribut ref pointant vers un enfant de la liste. 2. Les déplacements ou créations d'éléments vers l'intérieur de cette liste d'enfants, c'est-à- dire tous les éléments précédant immédiatement (dans le fichier des différences) un élément de cette liste d'enfants, et n'ayant pas d'attribut (moved)replacing pointant vers un élément existant à la source de l'importation 3. Les déplacements ou créations d'éléments comme enfants de l'élément dont on construit les enfants, c'est-à-dire tous les éléments devant être placés à l'aide de leur parent dans le fichier des différences (pouvant être un marqueur par exemple), et dont le successeur n'existe pas dans le fichier des différences ou n'existe pas à la source de l'importation, et finalement n'ayant pas d'attribut (moved)replacing pointant vers un élément existant à la source de l'importation.
Il faut donc appliquer toutes les différences correspondant à un de ces critères, et les retirer de la liste des différences devant encore être appliquées. ...
Recherche d'un élément à partir de son identifiant
La première chose devant être effectuée par le resolver est de localiser l'élément dont l'identifiant est donné dans la requête.123
Si l'élément est présent explicitement dans l'XML des différences, il suffit d'utiliser la méthode décrite en première partie (construction d'un nœud à partir de sa définition).
Si l'élément n'est pas présent mais contient un identifiant composite (disons h:t), il faut tout d'abord chercher l'élément h, puis chercher l'élément pointé par la référence de cet élément, et finalement son enfant (dans la structure résolue) ayant t pour identifiant.
A noter qu'il est possible de demander directement un élément ayant été rejeté dans une page, et la requête sera tout de même acceptée. Une justification de ceci est que le fait de rejeter une partie d'une page est considéré comme si l'utilisateur avait placé un cache devant l'élément, le rendant invisible mais sans vraiment le supprimer. Ainsi, lorsque la page entière est affichée, l'élément rejeté ne s'y trouvera pas, mais il est possible d'afficher quelque chose se trouvant sous ce cache.
Cependant, si l'utilisateur avait créé cet élément lui-même, afin d'éviter d'occuper de la place inutilement, il peut être supprimé complètement.
Recherche du parent d'un élément
Pour trouver le parent d'un élément ayant été résolu, il faut regarder si l'élément a été placé par son attribut replacing (auquel cas le parent correspond au parent de l'élément pointé par cet attribut replacing) ou par des marqueurs (auquel cas le parent est celui référencé par le parent de l'élément dans le fichier diff).
Description de la mise en oeuvre du système
Glassbox
Le concept de glassbox (de serveur de glassbox, de dérivation de glassbox, de délégation à une autre glassbox, etc.) est décrit dans le cadre de la variante présentée plus loin (le lecteur est prié de s 'y référer) mais s'applique aussi entièrement au système décrit ici.
Construction et mises à jour du corpus
Il y a un corpus unique pour tout le système124 (commun à toutes les glassbox qu'il héberge). Il associe à chaque url un identificateur, les liens avant et arrière125, et les importations/déportations
(c'est-à-dire les vues) qu'il effectue (ceci est utilisé pour hériter les liens des vues).
Ensuite, chaque groupe support (d'une glassbox) stocke les liens associés initiaux (notés R), l'union de leurs liens entrants (R"), et l'union des liens avant de R", .
Pour chaque page de R"+ est associé un score autorité. Si l'algorithme de distillation vers l'aval126 est également utilisé alors il faut également stocker les ensembles R+ et R+" et associer aux pages du deuxième ensemble leurs scores pivot autorité correspondant.
123 Une importation peut spécifier que seul un élément, ses enfants et ses ancêtres doivent être retournés, à l'aide d'un attribut derivedOfElt (ceci est décrit plus en détail dans le cadre du deuxième système). Voici comment il doit être géré par le resolver. Si on cherche à construire un enfant d'une importation dont cet attribut existe et est distinct de la valeur de ref, il faut tout d'abord chercher (par un appel au resolver) l'élément pointant vers la cible de derivedOfElt, puis connecter cet élément à l'importation en construisant la chaîne de parents jusqu'à atteindre l'élément imported. Si l'algorithme cherche à atteindre directement un descendant de cet élément imported via l'identifiant, on peut déterminer s'il est un enfant de derivedOfElt en plaçant ce dernier dans M et l'importation dans R plutôt que dans M.
124 On entend ici la partie du Système géré sur un serveur (sachant qu'il peut y avoir plusieurs serveurs).
125 (c'est-à-dire les liens sortants et entrants)
Ces ensembles doivent être mis à jour régulièrement. Une page (i.e. ses liens avant et arrières) doit être mise à jour si127: la dernière mise à jour est suffisamment ancienne, - un élément support la contient et est fréquemment utilisé pour obtenir des résultats, - la page a un (ou des) bons scores, - le système est inactif depuis un certain temps.
Tous les travaux de mise à jour se feront de façon asynchrone c'est-à-dire qu'une requête au système peut déclencher une mise à jour mais que le traitement de la requête n'attendra pas que la mise à jour soit achevée. (La mise en œuvre du système est exposée plus loin). Les scores étant ainsi disponibles par rapport aux groupes supports (de la glassbox), le système peut identifier, comme déjà décrit plus haut, les pages P{ les plus pertinentes par rapport à la page courante Po visitée ainsi que par rapport au contexte de navigation K en calculant la somme logique (ou le maximum) des produits des scores relativement à un groupe support Ej avec le score Kj de ce groupe support dans le contexte de navigation : st = 1 - J~[ [1 - Kj • E. (P0 ) • E - {P. )] j ou si = maX iκj • EJ ( o ) • Ej (^ )], comme déjà décrit. j
Architecture
La figure 38 présente schématiquement rarchitecture du système complet
Corpus, Groupes supports
Dans l'exemple de structure XML ci-dessous, ce qui est en gras représente des données qui sont stockées lors de la sérialisation dans un fichier XML, alors que les caractères plus fins représentent des données ne se trouvant qu'en mémoire (et construites paresseusement). <GlassBoxServβr> < Support s > <SupportGroup id="lπ distillationNeeded="true" supportElt≈ " ttp : / /démo . gbx . f r/resolvβ? id=8 " > <Page id=" l" /> <Page id=n8" /> </Req> <Rejβctθd> <Page id=" 5" /> <Page id=" 6" /> </Rajecfced> <ReqB> <Hub id="3 " hubScore= " 0 . 025643 " /> <ReqBF> <Authority p=" l" hyperScore=" 0.00764" /> <Authority p="2 " hypβrScorθ≈" 0. 00002" wordScore≈" 0.09135 " /> </ReqBF> <ReqBFB>
126 D s'agit du symétrique de l'algorithme décrit à la section précédente où, au lieu de R-, R-+ et R-+-, on prend R+,R+- et R+-+ et on évalue dans quelle mesure les pages candidates R+- citent les pages de R+ citées par les pages de R.
127 (tous ces facteurs doivent être présents dans une certaine mesure, par exemple on peut en faire une somme et choisir les pages ayant la plus grande valeur)
<Hub id= " 3 " hubScore= " 0 . 025643 " /> <Hub id=" 350 " hubScore=" 0. 00769 " /> </ReqBFB> </SupportGroup> • • * </Supports> <Derived> <page id="l"> <Page id="ll" />
</Dβrivθd> <Corpus> <Pagβ id="l" url="http://cocaσola.com/index.htm" £reshness="oldPage"> <Fwd> <Page id≈"2" weight≈"0.99653" /> </Fwd> <Page id="4" eight="0.87451" /> </Bc > <eFwά> <Page id="2" weight="0.99653" /> </eF d> <eBck>...</eBck> <Words> < ord w="Hello" f="0.011" /> • • • </Words> <Al Url> <ϋrl="http://www.cocacola.com/" /> <Url="http://cocacola.com/" /> //www. cocacola.com/index.htm" /> </Altϋrl> </Page>
transToθldDate="27/02/2003"> <Fwd>...</ITwd> <Bck> <Page id="l" weight=" 0.99653 "/> </Bck> </Page> <Page id="ll" url="http: //démo.gbx. fr/resolve?id=143" freshness="oldPage"> <Views> <Page id="l" /> </Views> <Fwd>.. ,</Fwd> <Bck/> <eFwd/> <eBck> <Page id="4" weight=" 0.87451" /> </eBck> </Page> • • • </Corpus>
<TrustβdPages> <Page id="8"> <SupportGroup id="3"/> </Page> • • • </TrustedPages> <Friendship> <Nθighbours> <FriendServer xp="1.2.3.4" /> <FriendServer ip="1.2.3.5" /> ... </Neighbours> <Evils> <FriendServer ip="6.6.6.6" /> • • • </Evils> <FriendCaσhe> <FriendCacheEntry url="http: //fraises-des-bois.com" s="l.2.3.4" birth="23/05/2003"> <ϋsage> <UsageEntry date="12/6/2003" count="2" /> • • * </ϋsage> </FriendCacheEntry> </FriendCache> </Friendship>
</GlassboxServer>
Voici une brève description des différents éléments apparaissant dans la structure ci-dessus : GlassBoxServer : La structure de donnée associée à un système. Supports : l'ensemble des groupes support du système.
SupportGroup : un groupe support, avec une référence vers l'élément support associé. Req : Les liens associés initiaux du groupe support.
Rejected : l'ensemble des pages qui ne doivent pas être présentées en association avec ce groupe support.
ReqB : l'ensemble R", i.e. les pages pointant sur au moins un lien associé initial. Hub : une page pivot pour un groupe support. On stocke son score pivot en mémoire. ReqBF : l'ensemble R"+.
Authority : une page autorité pour un groupe support. On connaît son score autorité par les liens et (dans le cas où la page est nouvelle) son score par les mots.
ReqBFB : le sous-ensemble de R"+" qui est connu (le système ne cherche les liens internes d'une page que si cette dernière se trouve dans les liens initiaux d'un groupe support ou possède un bon score autorité pour au moins un groupe support)
Derived : stocke la table de pages dérivées du système (dans l'exemple, 11 et 19 sont des pages dérivées de 1)
Corpus : Il s'agit de l'ensemble des pages connues dans le système.
Page : Une page se trouvant dans le corpus. Elle a un identifiant par lequel elle est référencée depuis d'autres points de la structure de donnée. Freshness indique s'il s'agit d'une nouvelle page, et transToOldDate indique le cas échéant à quelle date la page deviendra ancienne. F d : L'ensemble des liens partant d'une page. On stocke également le poids du lien (pour antinépotisme)
Bck : L'ensemble des liens arrivant sur une page (liens inverses). eF d : L'ensemble "étendu" des liens partant d'une page, i.e. Fwd auquel sont additionnés les liens virtuels.
eBck : L'ensemble "étendu" des liens arrivant sur une page, i.e. Bck auquel sont ajoutés les liens virtuels.
Words : La distribution de mots de la page.
Word : Un mot auquel est associé une fréquence (dont la somme des carrés pour tous les mots donne 1)
AltUrl : Si le système a détecté que plusieurs adresses différentes correspondent à une même page, cet élément va stocker les autres url de la page.
Les éléments ci-dessous se réfèrent à la section « Délégation à un autre serveur en peer-to-peer » présentée plus loin :
Friendship : Regroupe les informations correspondant au réseau peer-to-peer de serveurs dont ce serveur fait partie.
Neighbours : Il s'agit de l'ensemble des serveurs voisins, i.e. auxquels ce serveur peut renvoyer des requêtes (voir description plus loin).
FriendServer : Décrit un serveur voisin.
Evils : Les serveurs de glassbox que le serveur courant va retirer de la liste des résultats d'une recherche avant de la retourner, par exemple des serveurs de sites concurrents.
FriendCache : Un cache des requêtes les plus récentes et les plus demandées, associées au serveur de glassbox ayant pu y répondre.
FriendCacheEntry : Une entrée du cache, spécifiant la requête puis le serveur ayant pu y répondre, et la date depuis laquelle cette entrée se trouve dans le cache.
Usage : décrit l'utilisation récente de cette entrée du cache.
Us geEntry : Donne le nombre de requêtes pour cet url à une date donnée. L'intervalle entre la plus ancienne et la plus récente entrée dans la liste Usage est soumise à un maximum et lorsqu'il est sur le point d'être dépassé il faut enlever les entrées trop anciennes.
Les dépendances entre entités
Le système fonctionne sur la base d'un réseau de dépendances. Ainsi, le système construit un réseau de dépendances, et en fonction des requêtes et des besoins, en suivant les arcs de ce réseau, décide quelle partie du système doit être construite / mise à jour.
Formalisme
Comme dit ci-dessus, il s'agit de décrire le réseau de dépendances du système.
On va appeler ressource un nœud de ce graphe, auquel correspond un certain ensemble de dom ées.
On va appeler dépendance un arc (orienté) de ce graphe. S'il s'agit d'un arc de a à b alors b
(appelé cible de la dépendance) dépend de a (appelé source de la dépendance) si un changement dans les données associées à b peuvent impliquer un changement dans les données associées à a.
Une dépendance sera donc représentée comme à la figure 39.
Pour chaque dépendance une de ses extrémités est appelée initiatrice de cette dépendance.
L'initiatrice est la ressource qui va activer la dépendance : - * S'il s'agit de la source on parle de dépendance en push et sitôt que la source détecte un changement dans ses données elle va en informer la cible. Ceci est représenté comme à la figure 40 ; - * S'il s'agit de la cible on parle de dépendance en pull et sitôt qu'une requête lui parvient, elle va demander à la source si elle doit se mettre à jour (ce qui peut, en cascade, la forcer elle-même à se mettre à jour). Ceci est représenté comme à la figure 41. - * Il peut arriver dans certains cas que ies deux extrémités soient initiatrices de la dépendance, ce qui signifie que la source va notifier la cible de ses changements et que la cible va envoyer une requête à la source pour lui demander si elle est à jour. Sur un schéma, ce type de dépendance est représenté comme à la figure 42.
La force d'une dépendance indique si elle justifie de faire attendre l'utilisateur dans le cas où une mise à jour est nécessaire : - * Une dépendance est forte si le système doit faire attendre l'utilisateur dans le cas où elle n'a pas été réalisée (c'est-à-dire si la requête est appliquée sur la cible d'une dépendance forte, la requête ne répondra que lorsque cette dépendance est à jour). (Dans ce cas le point des schémas ci-dessus est remplacé par un point d'exclamation, voir figure 43). - * Une dépendance est faible si une requête peut provoquer un calcul de mise à jour mais les requêtes répondent immédiatement même si le système sait que la donnée est mise à jour.
Finalement, une dépendance en pull peut être temporisée, c'est-à-dire qu'elle ne va être activée que si la dernière activation est plus ancienne qu'un certain temps (ceci sera représenté par le symbole d'une horloge)
Dans les graphes de dépendance qui suivent, la flèche sera utilisée pour symboliser le fait que l'objet à gauche peut modifier directement les données de l'objet de droite (et ensuite informer la cible qu'elle a changé). Ceci diffère d'une dépendance forte et en push car dans ce cas, l'action de la dépendance est juste de dire à la cible qu'elle doit se mettre à jour.
Dépendances
La figure 45 présente une représentation du réseau de dépendances (interne à un serveur de glassbox).
Une boîte grise représente une instance de la classe dont le nom est inscrit en titre, et les noms non encadrés représentent des attributs des objets de cette classe.
Une flèche entièrement contenue dans une instance représente une dépendance entre deux attributs du même objet.
Une flèche dont les extrémités sont contenues dans une classe mais passant par l'extérieur de cette dernière représente une dépendance pouvant relier deux instances différentes de cette classe.
Un triplet de segments non fléchés (comme à la figure 44) partant d'un attribut vers une classe signifie que cet attribut est un ensemble d'instance de cette classe, et la boîte de la classe représente un élément dans cet ensemble.
Un nom entre parenthèses signifie qu'il s'agit d'une représentation incomplète d'une entité (dont la représentation complète est décrite ailleurs sous le même nom)
Enfin, une flèche en traits tiretés signifie une dépendance dont la source peut, lorsqu'elle est mise à jour, décider si cette dépendance doit être suivie ou non (en particulier, ceci permet d'avoir des cycles dans le réseau de dépendances, et un tel cycle est suivi en boucle jusqu'à ce qu'une dépendance de ce type ne soit pas activée par sa source)
A chaque entité correspond la structure du même nom dans le document XML décrit ci-dessus. Il y a en plus deux entités Bck et F d (" eighted backward" et "weighted forward") auxquelles sont associées les mêmes données que Bck et Fwd, c'est-à-dire les liens inverses128 et avant. La différence est qu'un' requête à Fwd ou Bck ne garantit pas que les poids des liens soient calculés, alors qu'une requête à wFwd ou wBck va s'assurer que les poids sont bien mis sur tous les liens avant de retourner. Req, ReqB, ReqBF et ReqBFB ont été renommés R, R", R"+ et R"+", respectivement, pour des raisons de lisibilité.
L'entité Temps est quelque chose qui, pour le gestionnaire de dépendances, semble avoir changé après un intervalle de temps réglable. Elle permet ainsi de représenter (dans le cas de dépendances push) des mises à jour à effectuer périodiquement, et (dans le cas de dépendances pull) des mises à jour à n'effectuer au moment d'une requête que si la dernière mise à jour est plus ancienne qu'un certain intervalle de temps.
128 Les liens inverses sont les liens entrants.
L'entité Publisher représente l'éditeur de pages : Lorsque l'utilisateur modifie une page (y ajoute/en retire un lien ou une vue), le Publisher va en informer l'objet Page (qui fera éventuellement les mises à jour nécessaires)
Les dépendances internes et en traits pleins des schémas ci-dessus suivent la description décrite dans le formalisme vu plus haut, et voici une description des autres dépendances (les numéros se réfèrent au dessin) :
Le système s'assure que le graphe des liens reste consistant en permanence : 1) Lorsque l'ensemble des liens inverses d'une page se modifie, les liens de toutes les pages qui y sont apparues ou en ont disparu sont immédiatement modifiés en conséquence. 2) Dans l'autre sens également : lorsque l'ensemble des liens partant d'une page se modifie les liens inverses de toutes les pages qui y sont apparues ou en ont disparu sont immédiatement modifiés en conséquence. 3) Lorsque le poids d'un lien partant d'une page est calculé ou mis à jour, le poids de ce même lien arrivant sur l'autre page est également mis à jour à cette valeur (en effet, le poids d'un lien est stocké pour les pages aux deux extrémités) 4) Dans l'autre sens également, si le poids d'un lien inverse change, le poids du même lien est mis à jour pour la page à l'autre extrémité. 5) Si l'ensemble étendu des liens inverses d'une page change, les liens avant étendus des pages y étant apparues ou en ayant disparu sont mis à jour.
La réciproque de 5 n'est pas nécessaire car le seul moyen de découvrir un nouveau lien avant virtuel est de trouver d'abord le lien arrière correspondant
Lorsque d'un changement des poids des liens intervenant dans le calcul des scores de pages autorité, il faut recalculer ce score : 6) Lors d'une requête pour les scores autorité pour un groupe support, le système va vérifier si les poids des liens partant des pages de R" ont changé et si c'est le cas il va relancer une distillation. Il n'effectue la vérification que si la dernière est suffisamment ancienne.
A titre d'exemple du comportement de ce réseau de dépendance, voici le comportement du. système lorsque un utilisateur fait une requête pour avoir les bonnes pages autorité d'un groupe support.
Le système va donc tout d'abord demander l'ensemble ReqBF de ce groupe support.
A cause des dépendances push reliant Req à ReqB puis ReqB à ReqBF, le système a travaillé dès l'instant de création du groupe support pour construire tous ces attributs d groupe support et les scores des pages. Si la construction des ensembles n'est pas achevée au moment de la requête, le système ne répondra pas à l'utilisateur tant que ce n'est pas terminé (car il s'agit de dépendances fortes).
Ensuite, quand l'utilisateur demande les scores des pages autorité, il risque de relancer l'algorithme de distillation si le système s'aperçoit que les poids des liens ou les liens eux-mêmes ont changé. (Cette vérification n'est faite que si la précédente est suffisamment ancienne). Si l'algorithme de distillation est relancé, l'utilisateur ne recevra la réponse que lorsqu'il s'est achevé.
Dépendances entre serveurs de glassbox
On va maintenant byièvement décrire les dépendances entre serveurs de glassbox.
Si deux glassbox telles que la première est une dérivée de la seconde sont sur des serveurs de glassbox différents, certaines des dépendances vont se situer entre les deux serveurs de glassbox.
Par super-groupe support on entend le groupe support correspondant se trouvant dans la super- glassbox.
Etant donné que ces dépendances transportent des relations à des pages il faut que, si une mise à jour d'un groupe support est transmise depuis une glassbox à une sous-glassbox se trouvant sur une autre machine, que les pages concernées soient transmises avec.
Concrètement cela signifie l'union de R, R", R" (le sous ensemble qui en est connu - ceci est utilisé pour calculer les poids des liens de R" à R_+), R" et R"+" (le sous-ensemble qui en est connu). Pour chaque page, l'ensemble des liens avants et arrières. Par contre il n'est pas utile d'envoyer les scores des pages pivot ou autorité, ni d'envoyer les poids des liens, car ceux-ci peuvent être calculés rapidement une fois les liens connus et peuvent être différents d'un serveur à l'autre.
Afin d'éviter du trafic inutile la super-glassbox pourrait tenter de n'envoyer que les variations des liens des pages de cette union (ce qui exigerait de stocker pour chaque page la date de dernier changement intervenu dans les liens). ,
Variante (deuxième système)
On va maintenant décrire un deuxième système mettant en œuvre certains des procédés de l'invention. Noter que les descriptions données pour chaque système peuvent être alternativement appliquées dans l'autre système. Autrement dit, pratiquement chaque section de la description du premier système peut être adoptée pour le deuxième système et inversement chaque section de la description du deuxième système peut être adoptée pour le premier système. De plus, les méthodes de recherche de score de pertinence (distillation relative) ou de transclusion peuvent ici aussi être remplacées par les méthodes (conduits et transclusions) décrites dans la première partie du rapport, et vice versa.
On va d'abord introduire l'approche :
Mémoire associative
L'utilisateur peut modifier une page d'origine - il peut par exemple lui associer des annotations - et enregistrer les modifications en tant que page dérivée de la page d'origine. La page dérivée lui est spontanément présentée par le système quand il revisite la page d'origine. Le système est par ailleurs apte à déterminer, en exploitant les liens qui se trouvent dans les pages du Web, le degré de pertinence des pages les unes par rapport aux autres et par rapport au contexte de navigation de l'utilisateur. Grâce à cela, le système peut
1. fournir à l'utilisa . te . ur leπs annotations associées aux pages qui sont pertinentes par rapport à la page courante visitée .
2. et quand plusieurs pages dérivées de la page d'origine existent, le système peut en sélectionner la plus pertinente par rapport au contexte de navigation de l'utilisateur.
Ainsi, pour chaque page visitée, le système est apte à présenter à l'utilisateur d'une part la page dérivée la plus pertinente par rapport au contexte de navigation et d'autre part les annotations pertinentes131.
Une annotation peut notamment être un lien vers une ressource d'information (tel qu'un document). L'utilisateur peut ainsi retrouver des ressources d'information simplement en se plaçant dans leur contexte de pertinence : lorsque l'utilisateur navigue et se rapproche du contexte de la ressource qu'il recherche, le système la lui propose spontanément. Le système est ainsi une
"mémoire associative".
Le système permet aussi de communiquer entre utilisateurs leurs modifications et créations de pages via un système que l'on appelle glassbox est qui est décrit dans la suite.
129 (ou page de départ)
130 (plus exactement, des associations contenues dans des pages dérivées pertinentes par rapport à la page courante visitée)
131 Bien entendu, l'utilisateur peut aussi visionner les pages pertinentes elles-mêmes (ou encore leurs pages dérivées contenant les annotations).
Manipulation des pages
Le contenu des pages132 dérivées est automatiquement tenu à jour par rapport à leur origine. On peut dériver une page à partir d'une page qui est elle-même dérivée, et ainsi de suite. Dans une page on peut créer une vue d'une page133 qui possède elle-même une vue d'une autre page134. Les modifications de la source se propagent automatiquement en cascade. Inversement, les modifications effectuées dans les pages dérivées peuvent être "suggérées" pour acceptation aux propriétaires de leurs pages d'origine. Les modifications se propagent ainsi dans les deux sens: de l'amont vers l'aval et de l'aval vers l'amont.
Chaque nouvelle propagation entraîne avec elle la propagation de nouvelles données (notamment les "liens entrants virtuels", décrits dans la suite) permettant de déterminer de nouvelles relations de pertinence pour les pages. Ainsi, la fonction de mémoire associative mentionnée plus haut est étendue aux pages créées par l'utilisateur lui-même : pour retrouver une ressource, l'utilisateur peut simplement consulter ses propres pages (et pas forcément naviguer sur le Web).
Utilisation de pages dérivées et Mémoire associative
Les pages Web peuvent être modifiées
Le système que l'on va décrire permet, à partir d'une page135 quelconque (que l'utilisateur y ait droit d'écriture ou non), de l'ouvrir dans un éditeur, d'y apporter des modifications et de les enregistrer sous la forme d'une page dérivée (de ladite page quelconque). La page dérivée peut garder des références vers la page dont elle dérive et reste alors automatiquement tenue à jour par rapport à elle.
A chaque fois que l'utilisateur crée une nouvelle page dérivée, il peut spécifier dans quelle "glassbox" il souhaite la mettre. En pratique cela se fait avec une notion de glassbox courante, dans laquelle est placée toute nouvelle page dérivée.
Glassbox
Le Web est un graphe orienté dans lequel les nœuds sont les pages Web et les arcs sont les liens hypertextes situés dans les pages Web. Une glassbox est une "boîte" dans laquelle sont enregistrées les modifications de ce graphe effectuées par les utilisateurs; c'est aussi une "boîte de verre" à travers laquelle il voit le Web ainsi modifié.
Comme ces modifications sont enregistrées, non pas sur les pages Web elles-mêmes, mais sous forme de pages qui sont dérivées de celles-ci, une glassbox est une extension (i.e. une vue enrichie) du Web constituée par l'ensemble de ces pages dérivées.
A noter qu'une glassbox peut aussi contenir de nouvelles pages (i.e. qui ne sont pas dérivées d'une autre page mais créées ex-nihilo).
Une glassbox est aussi caractérisée en ce que des centres d'intérêts (ou catégories), appelés
« groupes supports », lui sont associés, de manière à ce que le système puisse associer aux pages des scores de pertinence par rapport à ces groupes support.
Affichage de la page dérivée à la place de la page visitée
Lorsque l'utilisateur visite une page à travers une glassbox, le système lui affiche à la place la page dérivée (de cette page) qui le cas échéant est enregistrée dans cette glassbox136. S'il y a
132 Par page on entend n'importe quelle ressource d'information visualisée par l'utilisateur de manière autonome, tel qu'un document de traitement de texte, une image, un fichier ou même une base de données.
133 (ou d'un élément d'une page)
134 On peut également insérer une vue au sein d'une vue existante dans une page.
135 II peut s'agir d'une page Web, d'une page de traitement de texte, d'une vue de données de bases de données, etc.
136 ' ( . ou dans une Glassbox amont, comme on va le décrire plus loin)
plusieurs pages dérivées de cette page visitée, la glassbox sélectionne la plus pertinente par rapport au contexte de navigation de l'utilisateur.137
Annotation
Chaque modification d'une page d'origine est montrée à l'utilisateur de manière solidaire à la page dérivée dans laquelle ladite modification a été enregistrée, sauf pour le cas des annotations13 qui peuvent aussi être montrées de façon autonome (i.e. de manière adjacente ou superposée à une autre page affichée).139
Ainsi, en plus de la page dérivée qui est présentée à la place de la page visitée140, le système est apte à présenter à l'utilisateur des annotations contenues dans d'autres pages qui ont été dérivées à partir de la même page visitée1 l. Ces annotations sont par défaut superposées à la page affichée, au niveau de l'emplacement où elles avaient été créées.
Par ailleurs, le système est apte à afficher des annotations associées à des pages pertinentes142
(comme décrit ci-après aux sections « Liens pertinents » et « Contexte de navigation »). Par défaut ces annotations peuvent notamment: • être affichées de manière adjacente à la page affichée, • occuper dans la page des espaces réservés à la publicité, • se positionner selon des spécifications données par l'utilisateur au moment de la création de l'annotation,143 • ou encore être disposées d'une manière spéciale spécifiée ou choisie par l'utilisateur (en sélectionnant parmi des options de configuration d'affichage).
137 Lorsqu'une nouvelle page dérivée est enregistrée dans une glassbox: son contexte de pertinence devient une combinaison de celui de la page d'origine et du contexte courant de navigation de l'utilisateur ; le contenu de la page (e.g. sa distribution de mots) peut être caractérisé; l'utilisateur peut, par de simples glisser-déposer, créer des liens vers elle à partir d'autres pages et indiquer ainsi plus explicitement par rapport à quelles autres pages elle est pertinente ; et surtout, l'utilisateur peut y insérer des vues d'autres pages, notamment de pages Web externes et hériter ainsi de leur propre contexte de pertinence (voir la section « Héritage de relations de pertinence » Ces moyens permettent ainsi de caractériser les pages dérivées et la glassbox peut donc ensuite sélectionner la page dérivée d'une page, qui soit la plus pertinente selon le contexte courant de navigation de l'utilisateur. Cette approche a été décrite dans le cadre du premier système.
138 L'annotation est mise en œuvre comme un cas particulier de modification d'une page. Ainsi chaque annotation associée à une page est enregistrée dans le cadre d'une page dérivée de cette page. En cliquant sur une annotation avec le bouton droit de la souris l'utilisateur peut (sélectionner dans le menu contextuel l'option lui permettant de) visionner l'intégralité de la page dérivée contenant cette annotation. Et à partir de la page dérivée il peut remonter à la page d'origine à laquelle l'annotation avait été associée.
139 Créer une annotation peut consister à simplement mettre en exergue une partie d'une page. Typiquement, l'utilisateur sélectionne une partie d'une page (en y glissant la souris, le bouton étant tenu appuyé) et déclare au système que c'est une annotation associée à cette page. Le système crée alors une page dérivée de cette page, dans laquelle elle spécifie l'emplacement de cette annotation dans la page. Bien entendu, l'utilisateur peut aussi modifier le contenu de l'annotation ainsi créée, ou encore créer une annotation contenant de nouvelles informations (par exemple un lien sur une autre ressource, voir section suivante « bureau virtuel »). Ladite page dérivée créée contient alors en plus ces modifications ou ces nouvelles informations.
140 (comme décrit ci-avant à la section « affichage de la page dérivée à la place de la page visitée »)
141 (ainsi que des annotations contenues dans des pages dérivées de la page dérivée affichée à la place de la page visitée, et ainsi de suite)
142 (plus exactement, des annotations contenues dans des pages dérivées qui soient pertinentes par rapport à la page courante visitée)
143 Typiquement, pour créer une annotation associée à une page, l'utilisateur sélectionne une partie de la page (en y glissant la souris avec le bouton appuyé) et ou fournit au système un (ou plusieurs) commentaire (contenant éventuellement un lien), et donne optionnellement un ensemble de mots-clés (ou une position d'affichage). Une page dérivée contenant ces informations est alors créée. Lorsque l'utilisateur accède à une page pour laquelle cette page dérivée est sélectionnée comme étant pertinente, le système recherche dans la page l'occurrence d'un de ces mots-clé (le cas échéant) et affiche la sélection et/ou le commentaire de manière adjacente à la position de ce mot clé et de la mamère la moins intrusive possible (le mot-clé est souligné et l'annotation apparaît par roll-over de la souris sur lui).
Bureau virtuel
Une annotation peut contenir un lien vers une ressource d'information144. Par exemple, l'annotation peut consister en une icône représentant un document (et comportant un lien vers lui), icône que l'utilisateur a associée à la page en effectuant un glisser-déposer (de cette icône) à partir de son bureau.
Le système offre l'option de télécharger sur le serveur (de glassbox) la ressource qui se trouve au bout de ce lien, de manière à ce que, lorsque l'annotation contenant ce lien est présentée, l'utilisateur puisse automatiquement télécharger cette ressource sur son poste client et l'ouvrir directement, simplement en cliquant dessus (comme il fait d'habitude pour ouvrir un tel document).
Glassbox dérivée
De la même façon qu'une glassbox étend le Web, une glassbox peut étendre une autre glassbox en contenant des pages dérivées supplémentaires (ainsi que des groupes supports éventuellement différents).
Ainsi, à partir d'une glassbox existante à laquelle il a accès, l'utilisateur peut "dériver" une autre glassbox qui en représentera une extension.
Les glassbox peuvent ainsi être dérivées en cascade, de l'amont vers l'aval.
Chaque glassbox représente (et couvre) un "Web étendu" composé du Web et de toutes les extensions apportées par les glassbox amonts et par elle-même.
Lorsque l'utilisateur visite une page, les pages dérivées et annotations enregistrées dans les glassbox lui sont présentées en suivant la chaîne de dérivation des glassbox, dans l'ordre de l'aval vers l'amont. Autrement dit, les pages dérivées (et leurs annotations) se trouvant plus à l'aval sont privilégiées.
Liens pertinents
A travers une glassbox, le système propose des liens vers des pages pertinentes par rapport à la page affichée à l'écran145 et au contexte de navigation de l'utilisateur.
Ceux-ci sont triés par score de pertinence.
Le système distingue le score "page autorité" (i.e. pertinence d'une page citée par d'autres pages) du score "page pivot" (i.e. pertinence d'une page citant d'autres pages). Le système est apte à présenter, avec chaque page pertinente proposée, les pages pivots les plus pertinentes et/ou la page pivot qui a permis de la découvrir.
Pour déterminer les scores de pertinence, le système arpente (crawl) le Web étendu couvert par ladite glassbox, autour d'un ensemble de catégories dites groupes supports propres à ladite glassbox146, et par rapport à chaque groupe support, détermine les scores de pertinence des pages qui sont co-citées avec les pages qui caractérisent ce groupe support.147
Pour chaque page affichée à l'écran, les groupes supports pour lesquels elle a un bon score
(compte tenu du contexte de sa navigation) sont pris en considération et les liens vers les pages ayant les meilleurs scores de pertinence pour ces groupes supports sont présentées à l'utilisateur
1 4 (telle qu'un document de traitement de texte ou de tableur, une image ou encore un document audio-visuel)
145 (qui peut être une page dérivée de la page que l'utilisateur avait déclaré vouloir accéder)
146 Lorsque l'utilisateur crée une nouvelle glassbox en la dérivant d'une glassbox existante (glassbox amont), les groupes supports de cette dernière sont automatiquement dérivés dans la nouvelle glassbox. Ensuite l'utilisateur peut les modifier. L'algorithme de calcul de score de pertinence (voir section « Distillation absolue / relative ») est incrémental en ce sens qu'il est apte à réutiliser les résultats de calcul de la glassbox amont et les affiner selon les différences découlant desdites modifications.
147 C'est l'algorithme de « distillation relative vers l'arrière » décrit plus loin. D'autres méthodes sont aussi utilisées, notamment la méthode symétrique qui consiste à mesurer dans quelle mesure une page candidate cite les pages qui sont citées par les pages du groupe support (c'est « l'algorithme de distillation vers l'avant »).
en tant que "liens pertinents". Ceci se fait comme déjà décrit dans le cadre du premier système, mais relativement à une glassbox.
Pour chaque page pouvant être suggérée est calculé un score dépendant de la page courante et du contexte, les pages ayant obtenu les meilleurs scores globaux sont sélectionnées. Ensuite pour chacune d'entre elles le ou les groupes support sont sélectionnés en fonction de la pertinence de la page sélectionnée par rapport à eux. L'utilisateur a la possibilité de rejeter un résultat pour un groupe support, où il ne sera plus proposé à l'avenir (tout en gardant la possibilité d'annuler cette opération, en éditant les groupes support).
Les liens pertinents sont présentés à l'utilisateur en suivant la chaîne de dérivation des glassbox, dans l'ordre de l'aval vers l'amont. Autrement dit, les liens vers les pages pertinentes enregistrées dans une glassbox plus à l'aval sont privilégiés.148
Chaque groupe support peut être présenté à l'utilisateur comme un lien vers un élément support qui se trouve dans une page d'un site (par exemple dans un site appartenant au propriétaire de la glassbox).
Prise en compte du contexte
Un contexte de navigation relativement à une glassbox est défini par une association d'un score à chaque groupe support de la glassbox, comme déjà décrit ci-avant dans le cadre du premier système, mais de manière relative à une glassbox. Idem pour le contexte d'édition.
Délégation à un autre serveur en peer-to-peer
Dans le cas où la glassbox (et les glassbox amonts) ne possède(nt) aucun groupe support pour laquelle la page courante a un bon score, et donc aucun lien pertinent n'a pu être proposé à l'utilisateur, le système délègue la fourniture de liens pertinents, à une autre glassbox. Ceci se fait selon une approche en peer-to-peer.149
Si le système (i.e. un serveur de glassbox) constate qu'une page, à laquelle aucune glassbox du système ne peut fournir de liens pertinents, est fréquemment demandée, il peut suggérer aux propriétaires des glassbox (ayant le droit d'y ajouter des groupes support) de créer un nouveau groupe support pour cette page.
Mémoire associative
Les liens pertinents décrits ci-avant peuvent en fait être des liens vers une version modifiée de pages pertinentes (se trouvant dans la glassbox courante ou une glassbox à l'amont). L'utilisateur peut ainsi profiter de leurs enrichissements.
148 Autrement dit, cette liste de liens pertinents commence par les versions modifiées se trouvant dans la glassbox de l'utilisateur (groupées par élément support), puis celles se trouvant dans la glassbox héritée par celle de l'utilisateur
(toujours groupés d'après les groupes supports), jusqu'à parvenir aux pages du Web public, présentées en dernier.
149 Chaque glassbox est géré par un serveur de glassbox (comme décrit plus loin). Chaque serveur de glassbox connaît un certain nombre d'autres serveurs de glassbox.
Chaque serveur peut dire s'il est capable de suggérer des liens pertinents pour une page (sans les donner effectivement).
Lorsqu'une telle situation (de non fourniture de lien pertinent) se produit, le serveur va tout d'abord se demander s'il héberge une autre glassbox capable de proposer des liens pertinents. Si ce n'est pas le cas, il va envoyer la requête aux autres serveurs qu'il connaît, qui eux-mêmes pourront faire la même chose, jusqu'à ce qu'un serveur capable de gérer la requête soit touché, ou que le réseau entier soit couvert sans trouver de réponse. Chaque serveur répond à ces requêtes à celui qui l'a envoyée (plutôt que de répondre directement au serveur initial), afin de laisser une trace dans les caches (décrits plus bas) des serveurs intermédiaires.
Un serveur peut également avoir une liste de serveurs qu'il refuse de proposer en réponse à une requête, et qu'il va donc retrancher des résultats qu'il a obtenus.
Afin d'éviter du trafic inutile, le serveur peut stocker dans un cache quels serveurs ont été capables de fournir des liens pertinents pour une page particulière. Ce cache a une capacité maximale, et lorsqu'il arrive à saturation, la page se trouvant depuis suffisamment longtemps dans le cache et qui a été la moins demandée récemment sera retirée du cache.
De plus, les annotations les plus pertinentes sont présentées directement (in extenso) avec la page150 affichée à l'écran.
Ainsi, en allant visiter une page, telle qu'une page Web, l'utilisateur peut retrouver une annotation telle qu'un lien151 ou un message textuel ou audiovisuel, qu'il avait enregistrée, ou qui était enregistrée dans une glassbox amont, et qui est pertinente par rapport à la page qu'il est en train de visiter.
La glassbox permet ainsi d'accéder aux ressources, simplement en se plaçant dans leur contexte.
Lorsque l'utilisateur navigue sur le Web et se rapproche du contexte de la ressource qu'il recherche, sa glassbox la lui propose spontanément. Sa glassbox est ainsi une "mémoire associative".
Héritage de relations de pertinence
Lorsqu'une vue d'une page source est créée dans une page destination (par page on entend n'importe quelle ressource d'information visualisée par l'utilisateur de manière autonome, tel qu'un document de traitement de texte, un fichier ou même une base de données), les scores de pertinence (par rapport à des catégories ou à des groupes supports) de la source sont hérités par la page destination. Ainsi, la mémoire associative est étendue aux ressources d'informations « privées » de l'utilisateur : par exemple lorsque l'utilisateur visite un document au sein duquel se trouve une vue d'une page Web publique152, le système lui présente spontanément (le cas échéant) des annotations pertinentes par rapport à cette page Web publique153. Le procédé et le mécanisme sont déjà décrits plus haut dans le cadre du premier système (liens entrants virtuels), mais ils s'appliquent maintenant relativement à une glassbox.
Communication via une glassbox amont
Chaque glassbox dérivée contient implicitement toutes les pages qui se trouvent dans la glassbox dont elle dérive, plus encore ses propres pages154.
Les pages ajoutées dans une glassbox (glassbox aval) qui est dérivée d'une autre glassbox
(glassbox amont) peuvent être suggérées (par l'utilisateur de la glassbox aval155) à la glassbox amont. Celles qui y sont acceptées (par le responsable de la glassbox amont) y font alors partie et sont donc mis à la disposition des utilisateurs de toutes glassbox qui sont à l'aval.156
Comme dans l'exemple présenté schématiquement dans la figure 46, dans une entreprise on aura typiquement : • une première glassbox (Gbx Publique) pour y stocker les pages dérivées publiques, • une glassbox (Gbx Extranet) qui en est dérivée pour y contenir les pages auxquelles peuvent accéder certains clients et partenaires de l'entreprise (accès restreint sur le Web par mot de passe ou autre moyen d'authentification), • une glassbox (Gbx Global) pour y mettre les pages accessibles - sur l'intranet de l'entreprise, • une glassbox (Gbx Dept X ; Gbx Dept Y) par département de l'entreprise, ou par thème, et contenant les pages dérivées destinées aux employés du département en question, ou aux personnes intéressées par le thème en question,
150 (d'origine ou dérivée)
151 (vers une ressource d'information telle qu'un fichier, un document de traitement de texte ou de tableur)
152 (ou une vue d'un élément d'un autre document dans lequel se trouve une vue d'une page Web publique...)
153 Rappelons que le système associe automatiquement des scores de pertinence aux pages du Web en analysant les liens dirigées vers elles et les liens qu'elles contiennent. C'est ainsi que le système peut déterminer quelles sont les annotations pertinentes...
154 Plus exactement, les glassbox contiennent les références des pages et non pas les pages elles-mêmes avec leur contenu. On dit qu'une glassbox « contient » des pages pour faciliter la lecture.
155 (ou optionnellement ces pages peuvent être suggérées d'office)
156 Précisons que lorsqu'une page (suggérée à travers une glassbox aval) est acceptée dans une glassbox (amont), elle y fait partie et ne fait plus partie de la glassbox (aval) à travers laquelle elle avait été suggérée.
• enfin une glassbox par individu (Gbx Gl, Gbx G2, Gbx G3).157
La figure 46 présente le scénario selon lequel une nouvelle page dérivée (en l'occurrence une annotation A) créée au niveau d'une glassbox individuelle (Gbx Gl) est suggérée à l'amont (Gbx Dept X, puis Gbx Global) puis est présentée d'office à un autre utilisateur à travers sa propre glassbox individuelle qui se trouve à l'aval (Gbx G3).
Bien entendu, comme mentionné à la section « Liens pertinents », l'utilisateur peut refuser l'annotation ou la page dérivée que lui suggère une glassbox. Dans ce cas elle ne lui sera plus suggérée. S'il y a beaucoup d'utilisateurs qui la refusent (à travers les autres glassbox du système) alors elle ne sera pas présentée non plus aux utilisateurs qui ont configuré leur glassbox pour filtrer les suggestions qui ont été rejetées par plus d'un nombre donné de personnes durant une période de temps donnée.
Un utilisateur peut aussi faire dériver sa glassbox de plusieurs glassbox amont.158 Ainsi l'utilisateur peut alors recevoir des suggestions de multiples sources, voire de multiples serveurs.
Manipulations de données
L'approche
Les structures de données ont été conçues pour permettre au système d'efficacement remplacer une page courante par une page dérivée (de cette page courante) pertinente, ou remplacer une « vue » d'une page source par une vue d'une page dérivée (de cette source) pertinente, et de fournir des liens vers -et des annotations d'- encore d'autres pages pertinentes. Ainsi, la granularité des manipulations est conçue plus au niveau des pages que des éléments contenus dans les pages. Notamment, les liens entrants (et les liens entrants virtuels - ceci est décrit plus loin) sont considérés au niveau des pages et non pas au niveau des éléments.
La page dérivée est définie par ses différences par rapport a sa page d'origine
La structure (par exemple en XML) d'une page dérivée à partir d'une page d'origine, n'est pas une copie de cette dernière mais ne contient que ses différences par rapport à elle. Pour présenter à l'utilisateur la page dérivée, le système applique les différences de la page dérivée sur les données de la page d'origine.
La figure 47 illustre schématiquement une page dérivée (P') d'une page d'origine (P) ainsi que leur structure de données XML.159 Dans cet exemple, les seules différences de la page dérivée par rapport à la page d'origine sont qu'elle possède en plus une annotation (A) et qu'elle a supprimé (on dit « rejeté ») le deuxième élément (2).
Il est a noter que si, dans le futur, un autre élément est ajouté dans P, il est automatiquement reflété dans P'. En effet, comme P' est défini par ses différences par rapport à P, tout élément de P qui n'est pas rejeté dans P' fait implicitement partie de P'. Ainsi P' reste constamment tenu à jour par rapport à sa source P.
Lien et visite guidée
157 II est à souligner que les pages contenues dans la glassbox le plus à l'amont (Gbx Publique) sont présentables par toutes les glassbox qui lui sont à l'aval (notamment par toutes les glassbox individuelles : Gbx Gl, Gbx G2, Gbx G3), tandis que la réciproque n'est pas vraie : par exemple une page contenue au niveau de la glassbox de l'intranet global de l'entreprise (Gbx Global) ne sera pas présentée aux clients (via Gbx Extranet) ou au public (via Gbx Publique).
158 Plus précisément, la glassbox est dérivée d'une seule glassbox mais elle peut importer le contenu d'autres glassbox.
159 Légende : les nœuds en trait fin (ici l'élément 1 dans la page P') représentent les données qui ne figurent pas dans les données XML (enregistrées sur disque) mais existent dans la structure de manière implicite (i.e. elles peuvent être dérivées (c'est a dire automatiquement recréées a partir) des données explicites).
Le système permet de créer sur une page un lien qui invite à faire une "visite guidée" d'une page cible d'origine, c'est-à-dire un lien vers une page dérivée de la page cible d'origine (cette page dérivée pouvant elle-même contenir des liens vers des pages dérivées et ainsi de suite). Lorsque l'utilisateur clique sur ce lien, la cible est remplacée par une page160 qui spécialise la visite guidée d'avantage et/ou ajoute des annotations.
On va maintenant illustrer les cas de présentation de page suite à un clic sur un lien. On verra plus loin que la structure de données est en fait identique à celle du cas des vues présentées à la section suivante (puisque le choix de placer une vue ou de placer un lien est en général implémenté dans le code effectuant la transformation des données XML en code de présentation à l'utilisateur, c'est-à-dire en HTML, scripts, etc.). Cas de présentation d'un lien
La figure 48 illustre un exemple selon lequel dans la page PO, se trouve un lien vers une page PI.
La figure 49 illustre un exemple selon lequel, quand l'utilisateur visite la page PO à travers une glassbox et clique sur le lien vers PI qui se trouve sur cette page, le système lui présente une page
(PT) dérivée de PI, qui se trouve dans cette glassbox161. La page PI' possède une annotation (A).
Par ailleurs, une162 annotation (A2) pertinente par rapport à PI' (compte tenu du contexte de navigation), ou associée163 à PI et pertinente par rapport au contexte de navigation, est présentée avec cette dernière.164
Cas de visite guidée
La figure 50 illustre un exemple selon lequel dans la page PO se trouve un lien vers une version modifiée (Pl i) d'une page PI. Une annotation (A) se trouve dans le contenu de la page dérivée
Pli.
La figure 51 illustre un exemple selon lequel, quand l'utilisateur visite la page PO à travers la glassbox et clique sur le lien vers PI 1, le système lui présente une page (PU') dérivée de PI 1 et se trouvant dans cette glassbox. Observez que dans cet exemple PU' possède une annotation supplémentaire Al.
Par ailleurs, une165 annotation (A2) pertinente par rapport à PU' (compte tenu du contexte de navigation), ou associée à Pli et pertinente par rapport au contexte de navigation, est présentée avec cette dernière.
Vue
Dans le cadre de l'édition d'une page (PO), le système permet de placer, au sein de cette page, une vue d'une page source (PI) (ou d'un élément d'une page source). Lorsque l'utilisateur visite la page modifiée (PO) à travers une glassbox, le système remplace cette vue par la vue de la page dérivée la plus pertinente (PI') -s'il y en a dans cette glassbox- de la page source (PI).
La page source (PI) présentée à travers la vue peut être modifiée directement à travers cette vue
(c'est à dire dans PO). Cette modification peut donner lieu à une page dérivée (PU) de la page source (PI), notamment dans le cas où l'utilisateur n'a pas le droit de modifier la page source (PI).
Lorsque l'utilisateur visite la page PO à travers une glassbox, le système remplace cette vue (de
Pli) par une vue de la page dérivée la plus pertinente (PU') -s'il y en a dans cette glassbox- de la page source modifiée (PU).
De plus, le système présente, en relation avec cette vue (de PI' ou PU'), des annotations (A2) pertinentes.
On va maintenant illustrer par des exemples les cas de présentation de vue. La structure de données est illustrée schématiquement sous forme de parties d'arbre XML et de références entre nœuds XML.
160 (dérivée de ladite page dérivée de la page cible d'origine)
161 (ou dans une glassbox amont - ceci sera sous-entendu dans la suite)
162 (ou plusieurs)
163 Par « associée à » on entend « contenu dans une autre page dérivée de ».
164 Dans l'illustration de la structure XML, l'élément a droite de A est explicitée (trait épais) pour servir de repère. Ceci est décrit au chapitre présentant les algorithmes.
165 (ou plusieurs)
Cas de présentation d'une vue
La figure 52 illustre une page PO dans laquelle se trouve une vue d'une page PI. Cette vue est dotée d'un lien (e.g. intitule « En savoir plus ») vers sa source. La ligne en trait-point représente le lien (hypertexte).166
La figure 53 illustre un exemple selon lequel, quand l'utilisateur visite la page PO à travers une glassbox, le système remplace la vue de PI par la vue d'une page (PT) dérivée de PI et se trouvant dans cette glassbox.
En conséquence, le lien hypertexte « En savoir plus » change de cible et pointe sur PI '.
Une167 annotation (A2) pertinente par rapport à PI' compte tenu du contexte de navigation, ou associée à PI ou encore à PI' (et qui soit pertinente par rapport au contexte de navigation), est présentée avec cette vue.
Cas de présentation d'une vue modifiée
La figure 54 illustre un exemple selon lequel dans la page PO se trouve une vue modifiée d'une page PI.168 On suppose ici que, soit l'utilisateur n'a pas le droit de modifier PI (par exemple PI peut être une page Web externe) et alors une page dérivée (Pl i) est créée d'office, soit il peut la modifier mais décide (cela peut être l'option par défaut) d'en créer une page dérivée (PU) et de modifier plutôt cette dernière. 169 Le système présente dans PO la vue de la page dérivée (PI 1). Une annotation (A) se trouve dans le contenu de la page dérivée Pli et se trouve ainsi présentée dans la vue dans PO. La vue possède un lien « En savoir plus » dirigée vers sa source Pl i.
La figure 55 illustre un exemple selon lequel quand l'utilisateur visite la page PO à travers la glassbox, le système lui présente la vue d'une page (PU') dérivée de PI 1 et se trouvant dans cette glassbox. Observez que dans cet exemple PU' possède une annotation supplémentaire Al qui est ainsi reflétée dans la vue dans PO. La vue possède un lien « En savoir plus » dirigée maintenant vers sa source P 11 '.
Par ailleurs, une annotation (A2) pertinente par rapport à PU' compte tenu du contexte de navigation, ou associée à Pli ou encore à PU' (et qui soit pertinente par rapport au contexte de navigation), est présentée avec cette vue.
Liens entrants virtuels
On a mentionné plus haut le fait que le système détermine le score de pertinence de chaque page par rapport à chaque groupe support de la glassbox. Différents scores peuvent être calculés, dont notamment le score de pertinence calculé par analyse des co-citations (qui indique dans quelle mesure la page est co-citée avec les pages qui caractérisent le groupe support en question). Dans ce cas, les calculs se font en comptant les liens dirigées vers la page, qu'on appelle les « liens entrants » de la page.
Pour les calculs de pertinence, chaque page dérivée hérite des liens entrants de la page d'origine170.
De plus, chaque page hérite des liens entrants des pages dont elle possède une vue.
166 L'interface utilisateur permet de créer une telle vue par glisser-déposer d'un objet graphique représentant la page source (PI) vers/dans la page destination (PO). Plus loin (a la section "vue d'un élément d'une page"), on décrit aussi l'opération de glisser-déposer d'un élément de la page source (au lieu de glisser-déposer la page entière).
167 (ou plusieurs)
168 Cet exemple représente le cas typique d'un extrait d'une page pour laquelle le contenu de la page d'origine a dû être remanié pour tenir dans un espace restreint.
169 Le système permet de modifier une vue directement dans la page (PO) où elle se trouve et la modification de la source (PI ou Pli) se fait en conséquence et de manière transparente.
170 Autrement dit, chaque page dérivée hérite des liens qui se trouvent sur d'autres pages et pointent vers la page de laquelle elle dérive.
Ces liens hérités sont appelles« liens virtuels » ou « liens entrants virtuels ».
Chaque page hérite également des liens virtuels de la page dont elle dérive ainsi que des liens virtuels des pages dont elle possède une vue.
La figure 56 illustre schématiquement le cas d'une page (Pli) dérivée d'une page (PI) et possédant une vue d'une page (P21) dérivée d'une autre page (P2). On y voit que P21 hérite du lien entrant (L2) de P2 et que PI 1 hérite des liens entrants (Ll) de PI et (L21) de P21 ainsi que du lien virtuel (L2) de P21.
Optionnellement (notamment dans le cas des annotations), les pages héritent également des liens entrants (et des liens virtuels) des pages vers lesquelles elles contiennent un lien.
Ainsi, le fait d'hériter des liens entrants permet aux pages dérivées d'avoir un score par rapport aux groupes supports de la glassbox et de pouvoir ainsi être sélectionnées pour être affichées à la place de la page courante.
De la même manière que les modifications des pages dérivées se propagent (automatiquement) de l'amont vers l'aval et (sur suggestion) de l'aval vers l'amont des dérivations, les liens entrants virtuels (hérités grâce aux dérivations et aux vues) se propagent d'une dérivation à l'autre.
Vue d'un élément d'une page
La figure 57 illustre schématiquement une opération de glisser-déposer d'un élément (El) quelconque d'une page source (PI), tel qu'un paragraphe ou une image se trouvant dans un document de traitement de texte, dans le but de la reproduire dans une page destination (P2).171
Lorsqu'un utilisateur final visite la page destination (P2), le système remplace cette vue par une vue d'une page dérivée (PI') de la page source (PI) (ceci n'est pas illustré dans la figure 57 mais dans la figure 58).
Le système présente également, en relation avec cette vue (e.g. de manière adjacente à la vue), des annotations (A) pertinentes par rapport à la page source (PI), ou associées à PI ou encore à PI'
(et qui soient pertinentes par rapport au contexte de navigation).
La figure 58 illustre schématiquement la structure XML de l'exemple décrit ci avant. Le noeud PI contient l'élément El. L'élément E2 (dans P2) représente la vue en question. Comme c'est l'élément El qui est visé par la vue et non pas la totalité de la page PI, bien que E2 pointe sur
PI172 il possède en plus un attribut « vue de » qui est une référence vers l'élément El.
Le système sélectionne dans la glassbox une page dérivée PI' (comme toujours, s'il y en a plusieurs il sélectionne la plus pertinente par rapport au contexte de navigation) qui contient un élément El' référençant El, de manière à remplacer la vue de PI par une vue de PI', avec l'attribut « vue de » pointant sur l'élément El'.
La figure 59 présente une variante de cette approche, consistant à utiliser un attribut "page contenante" au lieu de l'attribut "vue de". On place la référence vers l'élément (plutôt que vers la page) et on a rattribut « page contenante » pour spécifier la page contenante174. Cette variante est donc équivalente.
La figure 57 illustrait le fait que les liens entrants (Ll) de la page (PI) contenant l'élément source
(El) sont hérités par la page destination (P2).
La figure 60 illustre le fait que dans le cas où l'élément (El) dont une vue est insérée dans la page destination (P2), est elle-même une vue d'une autre page (P3) (ou d'un élément d'une autre page) alors ce sont les liens entrants (L3) de ladite autre page qui sont hérités par la page destination.
171 A noter que la page source et la page destination peuvent être la même page, et l'opération de glisser-déposer peut se faire au sein de la même page.
172 Selon cette approche, une vue pointe sur une page de manière à ce que le système puisse remplacer la page visée par une page dérivée et puisse aussi déterminer les pages pertinentes par rapport a la page visée. Néanmoins la vue possède un attribut indiquant quel est l'élément source (dont l'utilisateur a pris une vue par l'opération de glisser- déposer).
173 Cette variante est utilisée dans le resolver décrit plus loin au chapitre présentant les algorithmes utilisés. Par contre dans les figures suivantes de ce chapitre on adopte l'approche « Vue de ».
174 (qui sera utilisé pour calculer les liens entrants virtuels etc.)
Ainsi le lien entrant Ll de la page PI n'est pas hérité par P2. On évite d'hériter des liens entrants qui ne correspondent pas au contenu réutilisé.
Vue modifiée d'un élément d'une page
La figure 61 illustre l'option selon laquelle lorsque l'utilisateur modifie la vue insérée dans la page destination P2, le système crée175 une nouvelle176 page dérivée (PI 1) de la page source (PI), et place dans la page destination (P2) un lien (présentée en trait-point dans la figure 61) vers cette page dérivée (PI 1), ce lien étant placé au niveau de177 l'élément (E2) déposé. Comme déjà décrit, la nouvelle page dérivée (Pli) hérite des liens entrants de la page source (PI). Lorsqu'un utilisateur final visite la page destination (P2), par défaut178 le système remplace la vue (E2) par une vue d'une page dérivée (PU') de ladite nouvelle page dérivée (Pli). De plus, le système présente, en relation avec cette vue, des annotations (A) pertinentes par rapport à la page dérivée (PU') (compte tenu du contexte de navigation), ou encore des annotations associées à179 la page source (PI) ou encore à ladite nouvelle page dérivée Pli et qui, bien entendu, soient pertinentes par rapport au contexte de navigation.1
La figure 62 illustre schématiquement la structure XML de l'exemple décrit ci-dessus. Le noeud PI (représentant la page PI) contient l'élément El. Le noeud Pl i (représentant la page Pl i) contient l'élément El 1 qui représente le contenu modifié de la vue et qui possède une référence à El. L'élément E2 représente la vue qui se trouve dans la page destination P2 et possède une référence a la page dérivée Pli ainsi qu'un attribut « vue de » pointant sur l'élément visé El i. Lorsqu'un utilisateur final visite la page destination P2, le système remplace la vue E2 par une vue d'une page dérivée Pli ' l'attribut « vue de » pointant alors sur El 1 '.
Application de type catalogue
Une application de cette approche est la création d'un catalogue de produits. La figure 63 illustre schématiquement la création d'une page catalogue (P2). L'élément El (dans la page PI) est un modèle de produit (i.e. une présentation d'un produit par défaut). L'utilisateur reproduit et modifie ce modèle dans la page P2 plusieurs fois (E21, E22, E23) -il le reproduit autant de fois qu'il y a de produits correspondant a ce modèle- et construit ainsi la page (P2) du catalogue. En résultat, l'utilisateur possède une page dérivée (Pli, PI 2, PI 3) par produit et toutes ces pages dérivées sont accessibles par les liens de la page P2 (la page P2 a ainsi le rôle de regrouper les produits).
Par ailleurs, l'utilisateur publie une page P3 contenant une vue (non modifiée) de ce modèle de produit (El).
Quand l'utilisateur final visite la page P3 à travers la glassbox dans laquelle le catalogue a été construit, ou a travers une glassbox dérivée de cette glassbox, le système lui présente le produit
(E21, E22 ou E23) qui est le plus pertinent par rapport à son contexte de navigation182.
La figure 64 présente la structure XML de l'exemple de la figure 63. Lorsque l'utilisateur visionne la page P3, le système détermine la référence vers P12 (avec l'attribut « vue de » pointant sur E12) automatiquement comme étant la plus pertinente par rapport au contexte de navigation.
175 (dans la glassbox courante)
176 Si dans la Glassbox courante il y a déjà une page dérivée de ladite page source a laquelle il a l'autorisation d'accès en écriture, l'utilisateur peut la modifier directement a travers la vue qu'il a créée; le système ne créera alors pas de nouvelle page dérivée.
177 (ou en relation avec)
178 (mais l'utilisateur peut changer les options par défaut; voir section "interface utilisateur")
179 (c'est-à-dire contenues dans d'autres pages dérivées de)
180 Bien entendu, ces actions ont lieu quand ces pages ou annotations existent dans la glassbox.
181 (voir variante possible mentionnée plus haut)
182 (ou alors le modèle lui-même (i.e. la présentation d'un nτoduit par défaut) si le contexte de navigation est vide)
Vue dans une vue
La figure 65 illustre schématiquement le fait que l'on peut insérer dans une vue (d'une page ou d'un élément d'une page) une autre vue.
La figure 66 illustre schématiquement la structure XML de l'exemple décrit ci-dessus. On voit que le nouvel élément (E23) inséré figure en réalité (E13) dans la page dérivée (Pli)183. Lorsqu'au moment de l'affichage le système remplace la page dérivée Pli par une page (PU') dérivée de cette dernière, il remplace également la vue E13 (et indirectement E23, ce que ne montre pas la figure) par la vue correspondante d'un élément (E3') se trouvant dans une page dérivée (P3') de la page (P3) contenant l'élément source (E3).
Vue modifiée dans une vue
La figure 67 illustre schématiquement qu'une nouvelle page dérivée (P31) est automatiquement créée lorsqu'on modifie une vue (E23) insérée dans une autre vue (E21).
La figure 68 illustre schématiquement la structure XML de l'exemple décrit ci-dessus. On voit que ce n'est plus le contenu d'une page dérivée (P3') de P3 qui remplace le contenu de la vue E13
(et indirectement E23 qui n'est pas dans la figure), mais le contenu d'une page dérivée (P31') de
P31.
Interface Utilisateur
Visite d'une page
Illustration
La figure 69 illustre schématiquement un exemple d'interface utilisateur. En plus de la page Web affichée sont présentés:
- un lien "MyGlassbox" (c'est le nom donné par l'utilisateur à sa glassbox), permettant notamment de visualiser et modifier les groupes supports et autres composants de la glassbox courante;
- un lien sur la page d'origine de la page courante (si elle est une page dérivée)
- un lien (ou bouton) "Versions modifiées..." permettant de visualiser et réorganiser l'ensemble des versions modifiées (pages dérivées) de la page courante, et quelques liens directs vers celles qui sont les plus pertinentes par rapport au contexte de navigation;
- un lien (ou bouton) "Liens pertinents..." permettant d'accéder aux liens vers les meilleures pages dérivées (en fonction du contexte de navigation) de pages pertinentes, classés par groupes supports, ainsi qu'un certain nombre de liens directs vers les meilleures pages dérivées (en fonction du contexte de navigation) des pages les plus pertinentes;
- un lien "Glassbox amonts...", permettant de visionner les versions dérivées de la page courante ainsi que les liens pertinents, proposés par les glassbox se trouvant à l'amont (présentés dans l'ordre de l'aval vers l'amont);
- un bouton permettant d'éditer la page affichée;
- et un bouton permettant de réinitialiser184 ou manipuler le contexte.
De plus, et comme illustré sur la figure 69, sur la page courante et/ou de manière adjacente sont présentées des annotations (Annotationl, Annotation2, etc.) qui sont associées à la page courante ou à des pages pertinentes ayant un très bon score (par rapport à la page courante et au contexte de navigation).
Se connecter à une glassbox
Lorsque l'utilisateur souhaite visionner des pages web à travers une glassbox et obtenir des suggestions par elle, il se loggue dans cette glassbox (en fournissant un mot de passe).
183 (et il est automatiquement reflété sous E21 ce que ne montre pas la figure) 184 (i.e. réinitialiser tous les scores de tous les groupes supports).
Options d'affichage d'une page requise par URL ou par clic sur un lien
Par URL
Quand l'utilisateur entre l'URL d'une page directement, le système va lui présenter sa version modifiée la plus pertinente (par rapport au contexte de sa navigation).
Lorsque le système choisit la version modifiée la plus pertinente d'une page il va également remplacer chaque vue qu'elle contient par sa version modifiée la plus pertinente (par rapport au contexte de navigation).
Le système offre une option "afficher la version d'origine" pour changer globalement ce comportement par défaut et demander que la page d'origine soit affichée. Dans tous les cas seront affichés des liens pertinents.
Par clic sur un lien
Pour chaque lien, si l'utilisateur y clique (avec le bouton gauche) le système va lui afficher la version modifiée la plus pertinente de la page cible, mais une option dans le menu contextuel (affiché avec un clic droit) lui permet de visualiser la page cible comme normalement. Si l'option "afficher la version d'origine" est activée, le comportement est inversé, la page d'origine est affichée par un clic gauche et le menu contextuel permet de voir une version modifiée.
Suggestions de liens pertinents
Pour chaque page Web visitée (page courante), le système présente de plus, de manière adjacente à la page, un ensemble de liens pertinents.
Par défaut185, les liens pertinents sont sélectionnées comme suit. Pour chaque page pouvant être suggérée est calculé un score dépendant de la page courante et du contexte de navigation. Les pages ayant obtenu les meilleurs scores globaux sont sélectionnées. Ensuite pour chacune d'entre elles le système choisit le ou les groupes support avec lesquels elle va être présentée, en fonction de sa pertinence par rapport à ce groupe support. Le système présente d'abord les (liens vers des) pages dérivées pertinentes se trouvant dans la glassbox de l'utilisateur (groupées par groupe support), puis celles se trouvant dans la glassbox héritée par celle de l'utilisateur (toujours groupés d'après les groupes supports de l'utilisateur), jusqu'à parvenir aux pages du Web, présentées en dernier. Chaque lien pertinent est présenté avec des liens vers les meilleures pages pivots sur lesquelles il a été trouvé. Il est également présenté avec un lien, si la page visionnée est une version modifiée, vers la page d'origine.
L'utilisateur a la possibilité de rejeter un résultat pour un groupe support, où il ne sera plus proposé à l'avenir (tout en gardant la possibilité d'annuler cette opération, en éditant les groupes support).
Modification de page au moyen d'un outil interne au système
L'interface offre un bouton pour entrer en mode d'édition de la page affichée, ainsi qu'un moyen pour afficher un éditeur des groupes support.
En mode d'édition, le système offre des moyens pour ajouter des éléments dans une page, en modifier, en supprimer ou les déplacer.
A côté de chaque élément pouvant être modifié, déplacé ou supprimé se trouve un bouton permettant ces différentes opérations.
Afin de permettre l'ajout, un bouton est placé à chaque emplacement pouvant accueillir un nouvel élément.
Un éditeur d'élément est ouvert lorsque l'utilisateur souhaite soit modifier soit créer un élément. Il se présente comme un éditeur de texte, permet d'ajouter des images etc. L'utilisateur a également la possibilité de modifier le code HTML directement.
185 L'utilisateur peut changer le procédé de sélection et ô présentation des liens pertinents.
Le système va seulement stocker les différences avec la page originale, ce qui fait que lorsque l'utilisateur regardera à nouveau sa page modifiée, si la page originale a changé entre temps ses changements seront appliqués sur la page originale actuelle.
Modification de page au moyen d'un outil externe
On présente ci-dessous un scénario de modification d'une page courante dans le cas où une extension au navigateur, telle qu'une barre d'outil, est disponible sur le poste client. Ensuite on présente un scénario où aucune extension n'est installée ou utilisée. Cas d'une extension au navigateur installée 1. L'utilisateur visite une page d'un site quelconque http://www.somewebsite.com/somewebpage18 2. L'utilisateur souhaite en faire une version modifiée, pour ce faire il clique sur le bouton « Edit » qui fait partie de l'extension à son navigateur. Automatiquement, l'extension au navigateur fournit (au serveur « someglassbox.com » gérant la glassbox courante de l'utilisateur) la requête suivante : http ://som eglassboxserver. coin/? glassbox=mvglassbox&url=http ://www. somewebsite. com /somewebpage187 3. En réponse à cette requête, le serveur de glassbox someglassboxserver.com clone la page www.somewebsite.com/somewebpage et retourne la page clonée someglassboxserver.com/pagel23456 à l'utilisateur 4. L'utilisateur la modifie en utilisant son outil d'édition favori, puis enregistre sa version modifiée sur le serveur someglassboxserver.com (par exemple en utilisant le protocole webdav) en utilisant les moyens classiques offerts par l'outil d'édition (comme par exemple en pressant sur les touches Ctrl et S) 5. Le système (someglassboxserver.com compare la version modifiée avec la version avant modification, détermine ainsi quelles sont les modifications effectuées par l'utilisateur (i.e. les différences) et crée une version dérivée188 de http://www.somewebsite.com/somewebpage définie par ces différences: http://someglassboxserver.com/?glassbox=myglassbox&page:=myversion.htm 6. La version dérivée créée à l'étape précédente peut optionnellement être retournée (en mode d'édition189) à l'utilisateur pour correction éventuelle et validation190 - à noter que par défaut le système interprète les copies d'éléments comme de vraies copies et qu'à cette étape l'utilisateur peut les transformer en des déportations/importations (décrits plus loin) qui restent tenues à jour par rapport à leur source 7. Dans le cas particulier où l'utilisateur possède le droit d'écriture sur la page http://www.somewebsite.com/somewebpage et qu'il préfère modifier cette page directement, le système someglassboxserver.com transmet ladite page dérivée définie par ces différences, au serveur http://www.somewebsite.com qui se charge alors de fusionner ces différences automatiquement (c'est le cas d'acceptation par
186 On fait ici l'hypothèse que pour obtenir une version dérivée de la page requise, l'utilisateur doit la demander explicitement, par exemple en cliquant sur un bouton dénommé « page dérivée » faisant partie de l'extension au navigateur. Dans ce cas, à l'étape suivante soit il demandera à éditer la page dérivée plutôt que la page d'origine (et le reste du procédé reste inchangé sauf qu'il s'applique à la page dérivée au lieu de la page requise), soit il demandera de voir la page d'origine et effectuera ensuite les autres étapes. En variante le système peut directement présenter une version dérivée pertinente que l'utilisateur peut aussi modifier....
187 A cette étape, le système peut optionnellement présenter à l'utilisateur une version dérivée pertinente à la place de la page requise. Mêmes remarques que dans la note précédente.
188 (qui par la suite pourra servir à remplacer la page lorsque l'utilisateur la demandera)2 1 (comme décrit à la section précédente)
190 (avant de valider, l'utilisateur peut corriger le cas échéant l'interprétation qu'a faite le système de ses modifications)
http://www.somewebsite.com/somewebpage d'une suggestion vers l'amont). Ladite page dérivée peut ensuite être supprimée. 8. Sinon (l'utilisateur ne possède pas le droit d'écriture), si http://www.somewebsite.c6m somewebpage est apte à recevoir les suggestions par l'aval, l'utilisateur peut aussi soumettre ladite page dérivée définie par ces différences et une notification (telle qu'un email) sera alors envoyée au responsable de cette page pour demander d'accepter ou refuser de fusionner ces différences (globalement ou partiellement). Cas sans extension au navigateur 1. L'utilisateur demande d'abord à pouvoir manipuler sa glassbox http://someglassboxserver.com ?glassbox=myglassbox 2. Il y spécifie la page http://www.somewebsite.com/somewebpage qu'il souhaite visiter. La requête envoyée au serveur devient automatiquement http://someglassboxserver.com/? glassbox=myglassbox&url=http://www.somewebsite.com /somewebpage191 Les étapes 3 à 8 sont les mêmes que dans le cas avec extension au navigateur (décrit ci-avant). Optionnellement, les liens http://www.someotherwebsite.com/someotherwebpage contenus dans les pages ainsi visitées sont automatiquement transformés en httn://someglassboxserver.coιrι/?glassbox=τnvglassbox&url=http://www.someotheιwebsite.com/s omeotherwebpage de manière à ce que l'utilisateur n'ait pas à re-spécifier dans sa glassbox l'URL d'un lien qui l'intéresse, et qu'il puisse simplement le cliquer pour accéder au clone qu'il pourra modifier.
Bien entendu, les différents aspects de la présente invention tels que décrits dans ce qui précède pourront adopter de nombreuses variantes ou modifications. En outre l'homme du métier saura, à l'aide de ses connaissances générales dans le domaine, effectuer toute combinaison appropriée de fonctionnalités ou d'étapes décrites indépendamment les unes des autres dans ce qui précède.
191 II aurait d'ailleurs pu la donner directement. 192 (http://someglassboxserver.com/? glassbox=mvglassb~" comme décrit à l'étape 1)
Introduction 10
Transclusion 11 Etat de l'art 11 Résumé de l'invention 11 Transclusion enrichie 14 Relation sémantique associée à une transclusion 15 Caractérisation sémantique des objets 16 Approche directe 17 Approche indirecte 17 Manipulation d'objets 18 Réifier une sélection 18 Présentation des sélections réifiées à l'utilisateur 18 Procédé de réification 19 Transclusion par "click&drag" 19 Etape "click" 19 Etape "drag" 19 Modifier le résultat d'une transclusion 20
Recherche d'information 20 Recherche explicite 20 Recherche par propagation de score 20 Normalisation 22 Variante préférée 23 Scores absolus 23 Echelle globale 23
Méthode de personnalisation 23 Profil de l'utilisateur 23 Profil de chaque objet 24 Score d'un objet par rapport au profil de l'utilisateur 24 Sélection d'option en fonction du profil de l'utilisateur 24
Algorithmes utilisés pour les transclusions 24 Identifiants 25 Transclusions 25 Transclusions implicites, transclusions internes 25 Equivalence d'identifiants 26 Sources d'un objet 26 Information présente dans un objet 27 Calcul d'un objet 27 Calcul de priorités de chemins 28 Détermination des objets à calculer 29
Réseau de conduits 31 Principe du calcul de scores de pertinence 35 Exemple numérique 36 Présentation des résultats à l'utilisateur 38 Contexte de navigation 38 Interface utilisateur 39 Editeur de documents 39 Visionneur de réseau 39 Requêtes 40 Gestionnaire de contexte 40 Composantes principales du système 40 Le crawler 40 Anti-népotisme 40 Le poseur de conduits 41 Conduits spéciaux entre sélections et requêtes 42 Favorisation des nouvelles pages 42 Définitions 42 Construction des régions fiables 43
Le distilleur 43 Algorithme de sélection d'autorités 44 Algorithme de calcul relatif optimisé 44 Exemple numérique 45 Le traiteur de requêtes 46 Exemple numérique 47 Architecture 47 Extension de la connaissance du web 48 Algorithme d'extension du réseau 48 Algorithme de réduction du réseau 49 Délégation en peer-to-peer 50 Architecture distribuée 50
Ressources dérivées (premier système) 51 Suggestion d'une autre ressource : 51 Comment sont déterminés les scores de pertinence .' 51 Comment sont élaborés les scores de pertinence des ressources dérivées 52 Mécanisme d'héritage de liens entrants 53 Quelles sont les autres ressources et comment le système les sélectionne 54 Remplacement du contenu des vues 55 Cas de la prise en compte du contexte de navigation 55 Cas de la prise en compte du contexte d'édition 56 Sélection de ressources dont le contenu a changé 57 Annotation 58 Calcul du score de pertinence par rapport à un groupe support 59 Homogénéité 59 Equation scalaire 59 Equation par les raisons d'aimer 59 Distillation absolue/relative 60 Distillation absolue dans un certain domaine de pages 60 Distillation relative à un ensemble de pages R 60 Extension à R"+" 60 Elaboration et maintenance des ressources dérivées 60 Introduction 60 Comment identifier un élément qui doit être référencé 62 XML des différences 62 Contenu des Legacy XML : 64 Exemple de structures XML 64 Manipulation de vues dans une page 64 Construction du fichier XML à partir d'une version HTML modifiée d'une version HTML existante 65 1) Etablissement des correspondances 65 2) Détection des changements de structure 65 3) Détection des changements de contenu 66 Propagations vers l'amont 67 Construction de l'XML à renvoyer à l'utilisateur 68 Construction d'un nœud à partir de sa définition 69 Liste des enfants d'un élément déjà résolu 69 Recherche d'un élément à partir de son identifiant 70 Recherche du parent d'un élément 70 Description de la mise en œuvre du système 70 Glassbox 70 Construction et mises à jour du corpus 70 Architecture 71 Corpus, Groupes supports 71 Les dépendances entre entités 74 Formalisme 74 Dépendances 75 Dépendances entre serveurs de glassbox 76
Variante (deuxième système) 77 Mémoire associative 77 Manipulation des pages 78
Affichage de la page dérivée à la place de la page visitée 78 Annotation 79 Bureau virtuel 80 Glassbox dérivée 80 Liens pertinents 80 Prise en compte du contexte 81 Délégation à un autre serveur en peer-to-peer 81 Mémoire associative 81 Héritage de relations de pertinence 82 Communication via une glassbox amont 82 Manipulations de données .- 83 L'approche 83 La page dérivée est définie par ses différences par rapport a sa page d'origine 83 Lien et visite guidée 83 Cas de présentation d'un lien 84 Cas de visite guidée 84 Vue 84 Liens entrants virtuels 85 Vue d'un élément d'une page 86 Vue modifiée d'un élément d'une page 87 Application de type catalogue 87 Vue dans une vue 88 Vue modifiée dans une vue 88 Interface Utilisateur 88 Visite d'une page 88 Illustration 88 Se connecter à une glassbox 88 Options d'affichage d'une page requise par URL ou par clic sur un lien 89 Suggestions de liens pertinents 89 Modification de page au moyen d'un outil interne au système 89 Modification de page au moyen d'un outil externe 90 Cas d'une extension au navigateur installée 90 Cas sans extension au navigateur 91
Claims
1. Procédé mis en œuvre dans un environnement informatique pour engendrer une vue courante à partir d'au moins un objet d'information source susceptible de varier, caractérisé, en ce qu'il comprend les étapes suivantes : établir et mémoriser une référence de la vue à l'objet d'information source, mettre en œuvre par un utilisateur au moins un outil de modification d'objet d'information pour produire à partir de l'objet d'information source un objet d'information transformé, enregistrer dans une mémoire un ensemble d'informations de différence (diff) représentatif de l'effet des actions de modification effectuées par l'utilisateur à l'aide du ou des outils, et engendrer une vue courante à partir du ou de chaque objet d'information source dans sa version courante et dudit ensemble d'informations de différence.
2. Procédé selon la revendication 1, caractérisé en ce que l'outil de modification d'objet d'information comprend un programme d'édition de document.
3. Procédé selon la revendication 2, caractérisé en ce que le programme d'édition est apte à engendrer un journal des modifications apportées à chaque document, et en ce que l'étape d'enregistrement est mise en oeuvre en utilisant les données de journal.
4. Procédé selon la revendication 1, caractérisé en ce que l'outil de modification d'objet d'information comprend une pluralité d'opérateurs de modification sélectionnables individuellement par l'utilisateur.
5. Procédé selon la revendication 1, caractérisé en ce qu'il est mis en oeuvre sur un objet d'information source lui-même constitué par une vue courante engendrée par une mise en oeuvre précédente du même procédé.
6. Procédé selon la revendication 1, caractérisé en ce que la vue courante est engendrée au sein d'un objet d'information plus grand contenant ladite vue.
7. Procédé selon la revendication 6, caractérisé en ce que l'objet comprend plusieurs vues et en ce que le procédé est répété pour chacune des vues courantes à engendrer.
8. Procédé selon la revendication 1, caractérisé en ce que la vue courante est constituée par une référence à l'objet d'information source, ladite référence étant associée à un objet d'information contenant.
9. Procédé selon la revendication 8, caractérisé en ce que la référence est constituée par un lien hypertexte.
10. Procédé selon la revendication 1, caractérisé en ce qu'il comprend en outre une étape d'établissement et de mémorisation d'une relation entre un objet d'information contenant directement ou indirectement ladite vue et l'objet d'information source.
11. Procédé selon la revendication 10, caractérisé en ce que ladite relation est une relation sémantique.
12. Procédé selon la revendication 1, caractérisé en ce qu'il comprend en outre une étape d'établissement et la mémorisation d'une relation entre la vue et l'objet d'information source.
13. Procédé selon la revendication 12, caractérisé en ce que la relation est une relation d'équivalence sémantique.
14. Procédé selon la revendication 13, caractérisé en ce qu'il comprend en outre la mise en œuvre d'un processus d'inférence basé sur une pluralité de relations sémantiques entre vues et objets d'information sources.
15. Procédé selon la revendication 1, caractérisé en ce que l'objet d'information source est dérivé d'un autre objet d'information.
16. Procédé selon la revendication 1, caractérisé en ce que la référence de la vue à l'objet d'information source est constituée par une requête en réponse à laquelle un ou plusieurs objets d'information sources sont délivrés.
17. Procédé selon la revendication 16, caractérisé en ce que la requête est une requête appliquée à un moteur de recherche, ce dernier délivrant le ou les objets d'information sources.
18. Procédé selon la revendication 16, caractérisé en ce que la requête est constituée par un groupe d'objets d'information, et en ce qu'il comprend une étape de recherche d'au moins une autre objet d'information présentant le meilleur score de pertinence par rapport audit groupe.
19. Procédé selon la revendication 1, caractérisé en ce qu'il comprend une étape de mémorisation de la vue courante engendrée, et en ce que ledit ensemble d'informations de différence contient un ou plusieurs pointeurs vers un ou plusieurs objets d'information dont le contenu et la position sont contenus dans la vue courante.
20. Procédé selon la revendication 1, caractérisé en ce que lesdits objets d'information sont structurés en sous-objets hiérarchiques, et en ce que, dans le cas où ledit ensemble d'informations de différence contient une information de différence visant une partie d'un objet, alors l'étape de génération de la vue courante conserve la dernière version du plus petit sous-objet contenant une telle partie d'objet.
21. Procédé selon la revendication 20, caractérisé en ce que ladite information de différence visant une partie d'un objet comprend une information de changement d'attribut de l'objet.
22. Procédé selon la revendication 20, caractérisé en ce que ledit attribut est un nom d'objet.
23. Procédé selon la revendication 20, caractérisé en ce que ladite information de différence visant une partie d'un objet comprend une information de position d'objet.
24. Procédé selon la revendication 1, caractérisé en ce que, dans le cas où l'objet d'information source comprend plusieurs sous-objets, le procédé est mis en œuvre autant de fois qu'il y a de sous-objets.
25. Procédé selon la revendication 24, caractérisé en ce que l'ensemble d'informations de différence contient, pour un objet comprenant une pluralité de sous-objets, des attributs modifié/non modifié pour chacun de ces objets de objets.
26. Procédé selon la revendication 1, caractérisé en ce que chaque objet d'information possède un identifiant d'objet.
27. Procédé selon la revendication 26, caractérisé en ce que chaque identifiant d'objet est unique dans l'environnement informatique.
28. Procédé selon la revendication 26 ou 27, caractérisé en ce que l'étape de génération de vue courante se réfère à un identifiant de modification.
29. Procédé selon la revendication 28, caractérisé en ce que chaque identifiant de modification est unique dans l'environnement informatique.
30. Procédé selon la revendication 26 ou 27 prise en combinaison avec la revendication 28 ou 29, caractérisé en ce que chaque vue courante possède au moins un identifiant composite comprenant un identifiant de modification et un identification d'objet auquel la modification par l'ensemble d'informations de différence correspondant s'applique.
31. Procédé selon la revendication 28 ou 29, caractérisé en ce qu'une vue courante possède un identifiant renvoyant vers une pluralité d'identifiants de modification et une pluralité d'identifiants d'objets auquel les modifications par les ensembles d'informations de différence correspondants s'appliquent respectivement.
32. Procédé selon la revendication 26 ou 27 prise en combinaison avec la revendication 28 ou 29, caractérisé en ce que dans le cas où un objet d'information source de départ est lui-même issu de l'application d'un ensembles d'informations de différence à un autre objet d'information source, alors un identifiant composite correspondant comprend un identifiant d'objet possédé par ledit autre objet d'information de départ et un double identifiant d'ensembles d'informations de différence.
33. Procédé mis en œuvre dans un environnement informatique pour affecter à des objets d'information des scores de pertinence, caractérisé en ce qu'il comprend les étapes suivantes : - affecter à au moins certaines paires d'objets d'information une capacité (conduit) de propagation de score de pertinence d'un objet d'information vers l'autre, - affecter à au moins un objet d'information un score de pertinence, et - calculer, pour au moins un autre objet d'information, un score de pertinence à partir de scores de pertinence d'objets d'information ayant avec ledit autre objet d'information une capacité de propagation et des valeurs (grosseurs de conduits) desdites capacités de propagation.
34. Procédé selon la revendication 33, caractérisé en ce qu'on affecte une capacité de propagation à chaque paire d'objets d'information, une capacité de propagation pouvant avoir une valeur nulle.
35. Procédé selon l'une des revendications 33 et 34, caractérisé en ce qu'au moins certains objets d'information sont reliés entre eux par des liens d'objet d'information citant vers objet d'information cité, et en ce que la capacité de propagation entre deux objets d'information est calculée à partir d'un critère de nombre d'objets d'information citants communs entre ces deux objets d'information.
36. Procédé selon l'une des revendications 33 à 35, caractérisé en ce qu'au moins certains objets d'information sont reliés entre eux par des liens d'objet d'information citant vers objet d'information cité, et en ce que la capacité de propagation entre deux objets d'information est calculée à partir d'un critère d'existence d'un lien entre ces deux objets d'information.
37. Procédé selon l'une des revendications 33 à 36, caractérisé en ce qu'au moins certains objets d'information possèdent un contenu textuel, et en ce que la capacité de propagation entre deux de tels objets d'information est calculée à partir d'un critère de distribution de mots dans ces deux objets d'information.
38. Procédé selon l'une des revendications 33 à 37, caractérisé en ce que la capacité de propagation entre deux objets d'information est calculée à partir d'un critère de relation entre objets d'information établie par l'utilisateur.
39. Procédé selon la revendication 38, caractérisé en ce que la relation entre objets d'information établie par l'utilisateur est dérivée d'un classement ou d'un regroupement d'objets d'information effectué par l'utilisateur.
40. Procédé selon l'une des revendications 33 à 39, caractérisé en ce que la capacité de propagation entre deux objets d'information est calculée à partir d'une combinaison d'au moins deux critères.
41. Procédé selon l'une des revendications 33 à 40, caractérisé en ce que l'étape de calcul comprend une somme des scores de pertinence pondérée avec les capacités de propagation.
42. Procédé selon la revendication 41, caractérisé en ce que les capacités de propagation sont normalisées.
43. Procédé selon l'une des revendications 33 et 34, caractérisé en ce qu'il comprend une étape d'élaboration, par l'utilisateur, d'une capacité de propagation entre deux objets d'information d'une paire.
44. Procédé selon la revendication 34, caractérisé en ce qu'à chaque paire d'objets d'information sont affectées deux capacités de propagation, l'une dans une première direction et l'autre dans la direction opposée.
45. Procédé selon l'une des revendications 33 et 34, caractérisé en ce qu'il est mis en œuvre a priori sur un sous-ensemble d'objets d'information représentatif d'un ensemble d'objets d'information plus grand pour prédéterminer des valeurs intermédiaires utilisées ultérieurement pour calculer les scores de pertinence.
46. Procédé pour accéder à des objets d'information dans un environnement informatique, caractérisé en ce qu'il comprend : - l'élaboration d'un groupe d'objets d'information de départ, - la mise en œuvre du procédé selon l'une des revendications 33 à 45 pour identifier d'autres objets d'mformation ayant les scores de pertinence les plus élevés par rapport au groupe d'objets d'information de départ, et - l'affichage d'éléments représentatifs desdits objets d'information identifiés pour accès à ceux-ci par l'utilisateur.
47. Procédé selon la revendication 46, caractérisé en ce qu'il comprend l'étape préalable consistant à mettre en œuvre un processus de recherche pour élaborer le groupe d'objets d'information de départ.
48. Procédé selon l'une des revendications 46 et 47, caractérisé en ce que le groupe d'objets d'information de départ est élaboré à partir d'un classement manuel et/ou automatisé d'objets d'information dans un système d'exploitation de l'environnement informatique ou dans une application informatique.
49. Procédé selon l'une des revendications 46 à 48, caractérisé en ce qu'il comprend en outre : - la détermination d'une relation de pertinence affinée entre l'une au moins des objets d'information identifiés et l'un au moins des objets d'information de départ, et - la représentation graphique desdites relations de pertinence affinées.
50. Procédé selon l'une des revendications 46 à 49, caractérisé en ce que l'étape d'affichage comprend : - la détermination de l'existence de capacités de propagation non nulles entre les objets d'information de départ et lesdits objets d'information identifiés, et - la représentation graphique de liaisons entre lesdits objets d'information identifiés et les objets d'information de départ en fonction des capacités de propagation.
51. Procédé selon l'une des revendications 46 à 50, caractérisé en ce qu'il comprend en outre : - la détermination de l'existence d'une capacité de propagation préexistante nulle entre au moins un objet d'information de départ et un objet d'information identifié, et - la modification de cette capacité de propagation nulle en une capacité de propagation non nulle.
52. Procédé selon la revendication 51, caractérisé en ce que ladite étape de modification est effectuée en fonction du score de pertinence de l'objet d'information identifié par rapport à l'objet d'information de départ.
53. Procédé selon revendication 46, caractérisé en ce que l'ensemble d'objets d'information est formé par un réseau de base comprenant des objets d'information et les capacités de propagation correspondantes, et par des modifications/adjonctions/suppressions apportées à ce réseau de base pour former un réseau modifié, et en ce que la mise en œuvre du procédé selon l'une des revendications 1 à 32 est effectuée à partir du groupe d'objets d'information de départ et desdites données de modifications/adjonctions/suppressions.
54. Procédé pour accéder à des objets d'information dans un environnement informatique, caractérisé en ce qu'il comprend : - la mise en œuvre du procédé selon l'une des revendications 33 à 45 pour déterminer des scores de pertinence absolus de l'ensemble des objets d'information, - la mise en œuvre d'un processus de recherche utilisant une requête, - le tri des objets d'information satisfaisant à ladite requête en fonction de leur score de pertinence absolu, et - l'affichage d'éléments représentatifs des objets d'information triés pour accès à ceux-ci par l'utilisateur.
55. Procédé pour accéder à des objets d'mformation dans un environnement informatique, caractérisé en ce qu'il comprend : - l'élaboration d'un groupe d'objets d'information de départ, - la mise en œuvre d'un procédé de calcul de scores de pertinence pour identifier d'autres objets d'information ayant les scores de pertinence les plus élevés par rapport au groupe d'objets d'information de départ, - la création d'un objet d'information supplémentaire représentative du groupe d'objets d'information de départ, et - la création de capacités de propagation, établie en fonction desdits scores de pertinence, entre les objets d'information identifiés et l'objet d'information supplémentaire.
56. Procédé selon la revendication 55, caractérisé en ce que le procédé de calcul de scores de pertinence est conforme à l'une des revendications 33 à 45.
57. Procédé selon l'une des revendications 33 à 45, appliqué à un ensemble d'objets d'information comprenant des objets d'information supplémentaires établis par le procédé selon l'une des revendications 55 et 56, caractérisé en ce que le calcul d'un score de pertinence pour un objet d'information appartenant à un groupe d'objets d'information de départ pour lequel un objet d'information supplémentaire a été créé est effectué en prenant en compte le score de pertinence calculé pour cet objet d'information supplémentaire.
58. Procédé selon la revendication 57, caractérisé en ce que ledit calcul d'un score de pertinence pour un objet d'information appartenant à un groupe d'objets d'information de départ pour lequel un objet d'information supplémentaire a été créé est effectué en prenant en compte uniquement le score de pertinence calculé pour cet objet d'information supplémentaire.
59. Procédé selon l'une des revendications 55 à 58, caractérisé en ce que le groupe d'objets d'information de départ est établi à partir d'une requête appliquée à une base de données, et en ce que l'objet d'information supplémentaire représente et contient ladite requête.
60. Procédé, mis en œuvre dans un environnement informatique comportant des objets d'information ayant des références vers d'autres objets d'information, et notamment des premiers contenus ayant au moins une référence vers un second contenu telle qu'un lien vers le second contenu ou telle qu'une transclusion du second contenu, pour la gestion de telles références en fonction de l'existence de modifications apportées aux objets d'information par l'utilisateur, caractérisé en ce qu'il comprend les étapes suivantes : - visualisation par l'utilisateur d'un second contenu courant via une référence possédée par un premier contenu, dans un mode permettant la modification dudit second contenu; - quand ledit second contenu est modifié dans ledit mode, création d'une nouvelle version du second contenu et remplacement de ladite référence par une référence vers cette nouvelle version.
61. Procédé selon la revendication 60, caractérisé en ce que ladite référence est une requête telle qu'une requête dans un langage standard, à une base de données.
62. Procédé selon l'une des revendications 60 et 61, caractérisé en ce que ladite nouvelle version du second contenu est représentée par une structure de marqueurs contenant les différences entre ladite nouvelle version du second contenu et ledit second contenu courant, pour ainsi présenter à l'utilisateur un second contenu dans lequel lesdites différences ont été appliquées à la version courante du second contenu.
63. Procédé mis en œuvre dans un environnement informatique pour accéder sélectivement à un objet d'information dérivé créé dans l'environnement informatique à partir d'un objet d'information de départ, caractérisé en ce qu'il comprend les étapes suivantes : (a) élaborer des scores de pertinence de l'objet d'information de départ et de l'objet d'information dérivé à l'aide d'un mécanisme de détermination de pertinence donné ; (b) en relation avec l'accès par un utilisateur à l'objet d'information de départ, fournir ou non à l'utilisateur une information sur l'existence de l'objet d'information dérivé ou un accès audit objet d'information dérivé, en fonction desdits scores de pertinence.
64. Procédé selon la revendication 63, caractérisé en ce que l'étape (a) élabore également un score de pertinence d'au moins un autre objet d'information, et en ce que l'étape (b) comprend en outre la fourniture ou non à l'utilisateur d'une information sur l'existence dudit autre objet d'information ou d'un accès audit autre objet d'information, en fonction desdits scores de pertinence.
65. Procédé selon la revendication 63, caractérisé en ce que l'étape (a) élabore également un score de pertinence d'au moins un autre objet d'information, et en ce qu'il comprend en outre, en liaison avec l'accès à l'objet d'information de départ ou à l'objet d'information dérivé, une étape (c) de fourniture ou non à l'utilisateur d'une information sur l'existence dudit autre objet d'information, en fonction desdits scores de pertinence.
66. Procédé selon la revendication 63, caractérisé en ce que l'étape (a) élabore également un score de pertinence d'au moins une autre objet d'information, et en ce qu'il comprend en outre, en liaison avec l'accès à l'objet d'information de départ ou à l'objet d'information dérivé, une étape (c) d'affichage ou non d'au moins une partie (annotation) du contenu dudit autre objet d'information, en fonction desdits scores de pertinence.
67. Procédé selon la revendication 63 ou selon l'une des revendications 64 à 66 prises dans la dépendance de la revendication 63, caractérisé en ce que l'étape (b) est mis en œuvre en relation avec l'existence d'une modification apportée audit objet d'information dérivé ou de départ depuis sa fourniture précédente à l'utilisateur.
68. Procédé selon l'une des revendications 65 ou 66, caractérisé en ce que l'étape (c) est mise en œuvre en relation avec l'existence d'une modification apportée audit autre objet d'information depuis sa fourniture précédente à l'utilisateur.
69. Procédé selon la revendication 63, dans lequel les objets d'information de départ sont reliés par des liens directionnels pour former ensemble un graphe orienté de départ, caractérisé en ce qu'il comprend en outre l'étape consistant à construire un graphe dérivé virtuel formé à partir du graphe orienté de départ et de liens virtuels partant de objets d'information citant l'objet d'information de départ et dirigés vers l'objet d'information dérivé, et en ce que les scores de pertinence sont élaborés sur la base dudit graphe dérivé virtuel.
70. Procédé selon l'une des revendications 63 et 69, caractérisé en ce que l'objet d'information dérivé est obtenu par modification de l'objet d'information de départ.
71. Procédé selon l'une des revendications 63 et 69, caractérisé en ce que l'objet d'information dérivé est un objet d'information possédant au moins une vue vers au moins une partie de l'objet d'information de départ.
72. Procédé selon l'une des revendications 63 et 69, caractérisé en ce que l'objet d'information dérivé est un objet d'information possédant au moins une copie d'au moins une partie de l'objet d'information de départ.
73. Procédé selon la revendication 69, caractérisé en ce que, dans le cas où l'objet d'information dérivé est obtenu à partir d'un objet d'information de départ qui est lui-même un autre objet d'information dérivé d'un autre objet d'information de départ, l'étape de construction du graphe dérivé virtuel prend également en compte des liens virtuels partant d'objets d'information citant ledit autre objet d'information de départ et dirigés vers ledit autre objet d'information dérivé.
74. Procédé selon les revendications 69 et 71 prises en combinaison, caractérisé en ce que, dans le cas où l'objet d'information dérivé possède plusieurs vues vers plusieurs objets d'information de départ, l'étape de construction du graphe dérivé virtuel prend en compte les liens virtuels partant d'objets d'information citant les objets d'information de départ respectifs et dirigés vers l'objet d'information dérivé.
75. Procédé mis en œuvre dans un environnement informatique pour accéder de façon personnalisée à des objets d'information, lesdites objets d'information comprenant des objets d'information de départ reliés par des liens orientés pour former ensemble une structure de départ, caractérisé en ce qu'il comprend les étapes consistant à : (a) créer des objets d'information ajoutés aux objets d'information de départ, pour former une structure dérivée, (b) mémoriser la structure dérivée sous forme d'une référence à la structure de départ, des objets d'information ajoutés et des liens entre la structure de départ et les objets d'information ajoutés, (c) mémoriser, en association avec la structure dérivée, des informations spécifiques de recherche d'objets d'information pertinents, (d) rechercher des objets d'information pertinents dans la structure dérivée en utilisant les informations spécifiques de recherche.
76. Procédé selon la revendication 75, caractérisé en ce que les informations spécifiques de recherche comprennent des informations de centres d'intérêt.
77. Procédé selon l'une des revendications 75 et 76, caractérisé en ce que les étapes (a) à (c) sont mises en œuvre de façon répétée pour former une pluralité de structures dérivées par ajout d'objets d'information à la structure de départ ou à des structures dérivées préexistantes.
78. Procédé selon la revendication 76 ou la revendication 77 prise dans la dépendance de la revendication 76, caractérisé en ce que l'étape (c) de mémorisation des informations spécifiques de recherche s'effectue sous forme d'une référence à des informations spécifiques de recherche déjà associées à la structure ou à une structure dérivée préexistante, et d'informations spécifiques de recherche ajoutées.
79. Procédé selon la revendication 78, caractérisé en ce que les structures dérivées sont elles- mêmes organisées en graphe.
80. Procédé selon la revendication 79, caractérisé en ce que le graphe des structures dérivées est un arbre.
81. Procédé mis en œuvre dans un environnement informatique pour accéder sélectivement à l'une parmi une pluralité de objets d'information à partir d'un objet d'information de départ, caractérisé en ce qu'il comprend les étapes suivantes : (a) élaborer des scores de pertinence de l'objet d'information de départ et d'autres objets d'information à l'aide d'un mécanisme de détermination de pertinence donné, lesdits autres objets d'information comprenant des objets d'information indépendants et des objets d'information dérivés de l'objet d'information de départ et/ou de ces objets d'information indépendants, (b) en relation avec l'accès par un utilisateur à l'objet d'information de départ, fournir ou non à l'utilisateur une information sur l'existence d'un autre objet d'information ou un accès audit autre objet d'information, en fonction desdits scores de pertinence.
82. Procédé selon la revendication 81, caractérisé en ce que l'étape (b) est mis en œuvre en relation avec l'existence d'une modification apportée audit autre objet d'information depuis sa fourniture précédente à l'utilisateur.
83. Procédé selon la revendication 81, caractérisé en ce que le mécanisme de détermination de pertinence est basé sur des analyses de liens entre objets d'information, en ce qu'au moins l'un des objets d'information dérivés est obtenu par reproduction d'un objet d'information de départ ou par insertion, dans un objet d'information quelconque, d'une vue ou d'une copie de l'ensemble de ledit objet d'information de départ, et en ce qu'il comprend une étape de création de liens virtuels dirigés vers ledit objet d'information dérivé et partant de chaque objet d'information ayant un lien dirigé vers l'objet d'information de départ considéré.
84. Procédé selon la revendication 81, caractérisé en ce que le mécanisme de détermination de pertinence est basé sur des analyses de liens entre objets d'information, en ce qu'au moins l'un des objets d'information dérivés est obtenu par insertion, dans un objet d'information quelconque, d'une vue ou d'une copie d'une partie seulement d'un objet d'information de départ, cette partie étant ou contenant elle-même une vue ou une copie de l'ensemble d'un objet d'information indirect de départ, et en ce qu'il comprend une étape de création d'un lien virtuel dirigé vers ledit objet d'information dérivé et partant de chaque objet d'information ayant un lien dirigé vers l'objet d'information indirect de départ considéré.
85. Procédé selon la revendication 81, caractérisé en ce qu'il comprend en outre, en liaison avec l'accès à l'objet d'information de départ ou à un autre objet d'information, une étape d'affichage ou non d'au moins une partie (annotation) du contenu d'un troisième objet d'information, en fonction desdits scores de pertinence.
86. Procédé selon la revendication 85, caractérisé en ce que l'étape d'affichage est mise en œuvre également en fonction de l'existence d'une modification apportée au troisième objet d'information depuis son affichage précédent.
87. Procédé mis en œuvre dans un environnement informatique en réseau pour l'affichage d'un objet d'information personnalisé obtenue à partir d'un objet d'information d'origine, caractérisé en ce qu'il comprend les étapes suivantes : charger l'objet d'information d'origine à partir d'un site mettant ledit objet d'information d'origine à disposition de l'utilisateur, enregistrer dans une mémoire un objet d'information de travail obtenu à partir d'une copie de l'objet d'information d'origine, mettre en œuvre des outils de modification de objet d'information pour produire à partir de la dite objet d'information de travail un objet d'information modifié, enregistrer dans une mémoire un ensemble d'informations représentatif des différences entre l'objet d'information d'origine ou l'objet d'information de travail et l'objet d'information modifié, et lors d'un accès ultérieur à l'objet d'information d'origine, engendrer, à partir de l'objet d'mformation d'origine dans sa version courante et dudit ensemble d'informations représentatif desdites différences, un nouvel objet d'information modifié.
88. Procédé selon la revendication 87, caractérisé en ce que l'objet d'information de travail comprend une pluralité de contenus appartenant à l'objet d'information d'origine et des identifiants attribués aux contenus respectifs, et en ce que les différences représentées par ledit ensemble d'informations sont des différences identifiant par identifiant.
89. Procédé de manipulation d'informations à l'aide d'une interface graphique utilisateur, ladite interface comprenant des moyens permettant une sélection d'une partie d'informations données, caractérisé en ce qu'il comprend une étape de conversion d'une sélection effectuée à l'aide de ladite interface en un objet ultérieurement manipulable.
90. Procédé selon la revendication 89, caractérisé en ce que l'étape de conversion est mise en oeuvre seulement en réponse à une instruction d'utilisateur déclenchée à l'aide d'un outil de pointage utilisé pour effectuer la sélection.
91. Procédé selon la revendication 89 ou 90, caractérisé en ce qu'il comprend en outre une étape d'affichage sélectif d'un indicateur visuel montrant l'existence, parmi des informations affichées, d'un objet d'information issu d'une conversion antérieure à partir d'une sélection.
Applications Claiming Priority (3)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
FR0312457 | 2003-10-24 | ||
FR0404936 | 2004-05-07 | ||
PCT/FR2004/002745 WO2005045698A2 (fr) | 2003-10-24 | 2004-10-25 | Procede mis en oeuvre dans un environnement informatique pour engendrer une vue courante a partir d’au moins un objet d’information source susceptible de varier |
Publications (1)
Publication Number | Publication Date |
---|---|
EP1719061A2 true EP1719061A2 (fr) | 2006-11-08 |
Family
ID=34575706
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
EP04805302A Withdrawn EP1719061A2 (fr) | 2003-10-24 | 2004-10-25 | Procédé mis en oeuvre dans un environnement informatique pour engendrer une vue courante à partir d'au moins un objet d'information source susceptible de varier |
Country Status (3)
Country | Link |
---|---|
US (1) | US8495099B2 (fr) |
EP (1) | EP1719061A2 (fr) |
WO (1) | WO2005045698A2 (fr) |
Families Citing this family (77)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US7779001B2 (en) * | 2004-10-29 | 2010-08-17 | Microsoft Corporation | Web page ranking with hierarchical considerations |
US8335824B2 (en) * | 2004-12-29 | 2012-12-18 | At&T Intellectual Property I, L.P. | Methods, systems, and computer program products for providing metadata subscription services |
US7793260B2 (en) * | 2005-04-25 | 2010-09-07 | Microsoft Corporation | System for defining and activating pluggable user interface components for a deployed application |
US7853590B2 (en) * | 2005-12-02 | 2010-12-14 | Microsoft Corporation | Remote read-write access to disparate data stores |
US8171482B1 (en) | 2006-05-09 | 2012-05-01 | Vmware, Inc. | Application environment specifications for provisioning application specific runtime environments using subsets of resources required for execution |
EP2074505A4 (fr) | 2006-10-05 | 2010-01-13 | Splunk Inc | Moteur de recherche sur séries chronologiques |
US20080134293A1 (en) * | 2006-11-30 | 2008-06-05 | James Storm | Method and system for providing distributed applications |
US8219987B1 (en) | 2007-08-24 | 2012-07-10 | Vmware, Inc. | Optimized virtual machine specification for provisioning application specific runtime environment |
US8577937B1 (en) | 2007-05-09 | 2013-11-05 | Vmware, Inc. | Repository including exclusion list |
US7971047B1 (en) | 2007-09-10 | 2011-06-28 | Vmware, Inc. | Operating system environment and installation |
US9015180B1 (en) | 2007-05-09 | 2015-04-21 | Vmware, Inc. | Repository including file identification |
US8347263B1 (en) | 2007-05-09 | 2013-01-01 | Vmware, Inc. | Repository including installation metadata for executable applications |
US11262996B2 (en) | 2007-05-09 | 2022-03-01 | Vmware, Inc. | Repository including exclusion list |
US8001083B1 (en) * | 2007-05-09 | 2011-08-16 | Vmware, Inc. | Repository including version management |
US10452768B2 (en) * | 2007-11-03 | 2019-10-22 | International Business Machines Corporation | Managing source annotation metadata |
US8392511B2 (en) * | 2008-01-17 | 2013-03-05 | International Business Machines Corporation | Embedding a unique serial number into the content of an email for tracking information dispersion |
US10275524B2 (en) * | 2008-01-23 | 2019-04-30 | Sears Holdings Management Corporation | Social network searching with breadcrumbs |
JP4596044B2 (ja) * | 2008-06-03 | 2010-12-08 | ソニー株式会社 | 情報処理システム、情報処理方法 |
JP4600521B2 (ja) * | 2008-06-03 | 2010-12-15 | ソニー株式会社 | 情報処理装置、情報処理方法、プログラム |
JP4596043B2 (ja) * | 2008-06-03 | 2010-12-08 | ソニー株式会社 | 情報処理装置、情報処理方法、プログラム |
US20100049686A1 (en) * | 2008-08-20 | 2010-02-25 | International Business Machines Corporation | Methods and apparatus for visual recommendation based on user behavior |
US8171141B1 (en) | 2009-04-02 | 2012-05-01 | Vmware, Inc. | Provisioning system including stack manager |
US8935260B2 (en) * | 2009-05-12 | 2015-01-13 | Hewlett-Packard Development Company, L.P. | Document key phrase extraction method |
CN101989198A (zh) * | 2009-07-31 | 2011-03-23 | 国际商业机器公司 | 用于业务套件客户化定制的用户反馈方法和*** |
US20110078552A1 (en) * | 2009-09-29 | 2011-03-31 | John William Lumley | Transclusion Process |
US9045098B2 (en) * | 2009-12-01 | 2015-06-02 | Honda Motor Co., Ltd. | Vocabulary dictionary recompile for in-vehicle audio system |
US9098507B2 (en) * | 2009-12-03 | 2015-08-04 | At&T Intellectual Property I, L.P. | Dynamic content presentation |
US8505034B2 (en) | 2009-12-17 | 2013-08-06 | Amazon Technologies, Inc. | Automated service interface optimization |
US20120143900A1 (en) * | 2010-12-06 | 2012-06-07 | Google Inc. | Instant Search For Settings |
US9075858B2 (en) * | 2010-12-16 | 2015-07-07 | Sybase, Inc. | Non-disruptive data movement and node rebalancing in extreme OLTP environments |
US8453048B2 (en) * | 2011-03-07 | 2013-05-28 | Microsoft Corporation | Time-based viewing of electronic documents |
US20120290926A1 (en) * | 2011-05-12 | 2012-11-15 | Infinote Corporation | Efficient document management and search |
US9946988B2 (en) * | 2011-09-28 | 2018-04-17 | International Business Machines Corporation | Management and notification of object model changes |
US8838583B1 (en) | 2011-10-05 | 2014-09-16 | Amazon Technologies, Inc | Diversity within search results |
US8818935B2 (en) * | 2011-11-21 | 2014-08-26 | Fluor Technologies Corporation | Collaborative data management system for engineering design and construction projects |
US9286414B2 (en) * | 2011-12-02 | 2016-03-15 | Microsoft Technology Licensing, Llc | Data discovery and description service |
US9292094B2 (en) | 2011-12-16 | 2016-03-22 | Microsoft Technology Licensing, Llc | Gesture inferred vocabulary bindings |
US20130204833A1 (en) * | 2012-02-02 | 2013-08-08 | Bo PANG | Personalized recommendation of user comments |
US20150161127A1 (en) * | 2012-02-13 | 2015-06-11 | Google Inc. | Ranking entity realizations for information retrieval |
JP5891875B2 (ja) * | 2012-03-19 | 2016-03-23 | 富士ゼロックス株式会社 | 情報処理装置及び情報処理プログラム |
US10838918B2 (en) * | 2012-08-28 | 2020-11-17 | International Business Machines Corporation | Preservation of referential integrity |
CN102937974A (zh) * | 2012-10-17 | 2013-02-20 | 北京奇虎科技有限公司 | 一种搜索服务器及搜索方法 |
EP2939104A4 (fr) * | 2012-12-28 | 2016-09-07 | Xsb Inc | Systèmes et procédés permettant de créer, d'éditer, d'enregistrer et de récupérer des connaissances contenues dans des documents de spécification |
US9208233B1 (en) * | 2012-12-31 | 2015-12-08 | Google Inc. | Using synthetic descriptive text to rank search results |
US10331743B2 (en) * | 2013-02-08 | 2019-06-25 | Snap Inc. | System and method for generating and interacting with a contextual search stream |
US9110680B1 (en) * | 2013-03-14 | 2015-08-18 | Amazon Technologies, Inc. | Avoiding or deferring data copies |
US11409803B2 (en) * | 2013-04-03 | 2022-08-09 | Wesley Seng Chew Chuah | Ranking system |
JP2014215914A (ja) * | 2013-04-26 | 2014-11-17 | 株式会社東芝 | 端末装置、情報処理方法及び情報処理プログラム |
US10019496B2 (en) | 2013-04-30 | 2018-07-10 | Splunk Inc. | Processing of performance data and log data from an information technology environment by using diverse data stores |
US10614132B2 (en) | 2013-04-30 | 2020-04-07 | Splunk Inc. | GUI-triggered processing of performance data and log data from an information technology environment |
US10318541B2 (en) | 2013-04-30 | 2019-06-11 | Splunk Inc. | Correlating log data with performance measurements having a specified relationship to a threshold value |
US10353957B2 (en) | 2013-04-30 | 2019-07-16 | Splunk Inc. | Processing of performance data and raw log data from an information technology environment |
US10997191B2 (en) | 2013-04-30 | 2021-05-04 | Splunk Inc. | Query-triggered processing of performance data and log data from an information technology environment |
US10346357B2 (en) | 2013-04-30 | 2019-07-09 | Splunk Inc. | Processing of performance data and structure data from an information technology environment |
US10225136B2 (en) | 2013-04-30 | 2019-03-05 | Splunk Inc. | Processing of log data and performance data obtained via an application programming interface (API) |
US9146976B2 (en) * | 2013-05-21 | 2015-09-29 | Baker Hughes Incorporated | Synchronization and reconciliation through identification |
US10108525B2 (en) * | 2013-06-14 | 2018-10-23 | International Business Machines Corporation | Optimizing automated interactions with web applications |
JP6465372B2 (ja) * | 2013-10-09 | 2019-02-06 | 株式会社インタラクティブソリューションズ | 携帯端末装置、スライド情報管理システム及び携帯端末の制御方法 |
US11790154B2 (en) | 2013-10-09 | 2023-10-17 | Interactive Solutions Corp. | Mobile terminal device, slide information managing system, and a control method of mobile terminal |
US9509643B1 (en) * | 2013-11-12 | 2016-11-29 | Twitter, Inc. | Network-based content discovery using messages of a messaging platform |
US9672256B2 (en) | 2014-02-04 | 2017-06-06 | Microsoft Technology Licensing, Llc | Creating data views |
GB2527355A (en) * | 2014-06-20 | 2015-12-23 | Ibm | Identifying items on a second website already browsed at a first website |
US10210149B2 (en) * | 2014-07-28 | 2019-02-19 | Ca, Inc. | Personalized wiki-book annotation |
US9990116B2 (en) * | 2014-08-29 | 2018-06-05 | Sap Se | Systems and methods for self-learning dynamic interfaces |
EP3248115A1 (fr) * | 2015-01-25 | 2017-11-29 | Iguazio Systems Ltd. | Stockage d'objet centré sur une application |
JP2016186695A (ja) * | 2015-03-27 | 2016-10-27 | 株式会社日立ソリューションズ | ファイル管理装置 |
JP7000422B2 (ja) | 2016-06-09 | 2022-01-19 | アンフォルマティック・ホリステック・インコーポレーテッド | データストレージシステムおよびデータストレージを実行するための方法 |
US10572576B1 (en) * | 2017-04-06 | 2020-02-25 | Palantir Technologies Inc. | Systems and methods for facilitating data object extraction from unstructured documents |
US10691426B2 (en) * | 2017-10-26 | 2020-06-23 | Saudi Arabian Oil Company | Building flexible relationships between reusable software components and data objects |
CN111954996B (zh) * | 2017-12-19 | 2022-08-23 | 维我***公司 | 用于控制电子通信的***和方法 |
US20200134039A1 (en) * | 2018-10-29 | 2020-04-30 | International Business Machines Corporation | Real-time adaptation of textual content dependent on user understanding |
US20220180263A1 (en) * | 2020-12-04 | 2022-06-09 | Kinaxis Inc. | Rule-based systems and methods for customizing complex business solutions |
US11522825B2 (en) * | 2021-03-12 | 2022-12-06 | Slack Technologies, Llc | Object interface for quick access to objects of a communication platform |
EP4305572A1 (fr) * | 2021-03-12 | 2024-01-17 | Salesforce, Inc. | Interface d'objet pour un accès rapide à des objets d'une plateforme de communication |
CN114118289B (zh) * | 2021-12-02 | 2024-04-23 | 中国石油大学(北京) | 基于数据驱动的成品油管道运行工况识别方法及*** |
US20240086432A1 (en) * | 2022-09-09 | 2024-03-14 | Third Bridge (US) Inc. | Dynamic interactive graphing for attributes |
US11875020B1 (en) * | 2022-09-28 | 2024-01-16 | Atlassian Pty Ltd. | Electronic document management system with a content recommendation interface |
Citations (2)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5946699A (en) * | 1996-08-05 | 1999-08-31 | Kabushiki Kaisha Toshiba | Version management apparatus and method for data having link structure |
WO2001095146A2 (fr) * | 2000-06-06 | 2001-12-13 | Maim Enrico | Systeme et procede permettant l'importation semi-automatique de fragments de ressources d'informations |
Family Cites Families (11)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5793966A (en) * | 1995-12-01 | 1998-08-11 | Vermeer Technologies, Inc. | Computer system and computer-implemented process for creation and maintenance of online services |
JP3724847B2 (ja) * | 1995-06-05 | 2005-12-07 | 株式会社日立製作所 | 構造化文書差分抽出方法および装置 |
US5608892A (en) * | 1995-06-09 | 1997-03-04 | Alantec Corporation | Active cache for a microprocessor |
US5875446A (en) * | 1997-02-24 | 1999-02-23 | International Business Machines Corporation | System and method for hierarchically grouping and ranking a set of objects in a query context based on one or more relationships |
US6425016B1 (en) * | 1997-05-27 | 2002-07-23 | International Business Machines Corporation | System and method for providing collaborative replicated objects for synchronous distributed groupware applications |
US6480206B2 (en) * | 1998-02-24 | 2002-11-12 | Sun Microsystems, Inc. | Method and apparatus for an extensible editor |
JP2002024211A (ja) * | 2000-06-30 | 2002-01-25 | Hitachi Ltd | 文書管理方法およびシステム並びにその処理プログラムを格納した記憶媒体 |
US7249314B2 (en) * | 2000-08-21 | 2007-07-24 | Thoughtslinger Corporation | Simultaneous multi-user document editing system |
US6744447B2 (en) * | 2000-12-29 | 2004-06-01 | International Business Machines Corporation | Method and system for compiling and using placebot agents for automatically accessing, processing, and managing the data in a place |
US7210096B2 (en) * | 2001-01-30 | 2007-04-24 | International Business Machines Corporation | Methods and apparatus for constructing semantic models for document authoring |
US7024429B2 (en) * | 2002-01-31 | 2006-04-04 | Nextpage,Inc. | Data replication based upon a non-destructive data model |
-
2004
- 2004-10-25 WO PCT/FR2004/002745 patent/WO2005045698A2/fr active Application Filing
- 2004-10-25 EP EP04805302A patent/EP1719061A2/fr not_active Withdrawn
- 2004-10-25 US US11/667,936 patent/US8495099B2/en active Active
Patent Citations (2)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5946699A (en) * | 1996-08-05 | 1999-08-31 | Kabushiki Kaisha Toshiba | Version management apparatus and method for data having link structure |
WO2001095146A2 (fr) * | 2000-06-06 | 2001-12-13 | Maim Enrico | Systeme et procede permettant l'importation semi-automatique de fragments de ressources d'informations |
Non-Patent Citations (4)
Title |
---|
DAVID G. DURAND: "Palimpsest: A Data Model for Revision Control", 1 January 1995 (1995-01-01), XP055015915, Retrieved from the Internet <URL:http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.51.4603&rep=rep1&type=pdf> [retrieved on 20120109] * |
HARALD KROTTMAIER ET AL: "Transclusions in the 21st Century", JOURNAL OF UNIVERSAL COMPUTER SCIENCE, vol. 7, no. 12, 28 December 2001 (2001-12-28), pages 1125 - 1136, XP055015826 * |
HARALD KROTTMAIER: "TRANSCLUDED DOCUMENTS: ADVANTAGES OF REUSING DOCUMENT FRAGMENTS", ELPUB2002 PROCEEDINGS, 6 November 2002 (2002-11-06), VWF BERLIN, pages 359 - 367, XP055015825, Retrieved from the Internet <URL:http://elpub.scix.net/data/works/att/02-37.content.pdf> [retrieved on 20120106] * |
See also references of WO2005045698A2 * |
Also Published As
Publication number | Publication date |
---|---|
US8495099B2 (en) | 2013-07-23 |
WO2005045698A2 (fr) | 2005-05-19 |
US20090083314A1 (en) | 2009-03-26 |
WO2005045698A3 (fr) | 2006-03-30 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
EP1719061A2 (fr) | Procédé mis en oeuvre dans un environnement informatique pour engendrer une vue courante à partir d'au moins un objet d'information source susceptible de varier | |
Vossen et al. | Unleashing Web 2.0: From concepts to creativity | |
Martella et al. | Practical graph analytics with apache giraph | |
WO2006108865A9 (fr) | Procedes pour permettre l'acces a des ressources modifiables par des utilisateurs dans un environnement informatique, et ressources structurees a cet effet | |
WO2003057648A9 (fr) | Procedes et systemes de recherche et d'association de ressources d'information telles que des pages web | |
FR3043816B1 (fr) | Procede de suggestion de contenus extraits d’un ensemble de sources d’information | |
WO2013140076A2 (fr) | Procede et systeme de developpement d'applications de consultation de contenus et services sur un reseau de telecommunciation | |
Melucci et al. | Advanced topics in information retrieval | |
WO2001035269A2 (fr) | Systeme de partage d'informations entre au moins deux utilisateurs sur un reseau informatique | |
Holzmann et al. | ABCDEF: The 6 key features behind scalable, multi-tenant web archive processing with ARCH: Archive, Big Data, Concurrent, Distributed, Efficient, Flexible | |
US10296913B1 (en) | Integration of heterogenous data using omni-channel ontologies | |
Rafes et al. | A platform for scientific data sharing | |
US11212363B2 (en) | Dossier interface and distribution | |
Medynskiy et al. | Exploring websites through contextual facets | |
Lai et al. | Semantic-web supported knowledge management system: An approach to enhance collaborative building design | |
WO2001095146A2 (fr) | Systeme et procede permettant l'importation semi-automatique de fragments de ressources d'informations | |
Tedeschi et al. | A cloud-based tool for brand monitoring in social networks | |
Becker et al. | Peer-to-peer based ontology editing | |
FR2806184A1 (fr) | Systeme de navigation mis en oeuvre dans un systeme informatique pour acceder a des pages fournies par des serveurs via un reseau informatique | |
FR2807182A1 (fr) | Systeme de traitement de donnees oriente objet a chargement progressif | |
Wang | Independent Construction System of the Knowledge Graph of Network Literature Resources | |
FR2807180A1 (fr) | Procede et systeme de gestion, dans un poste informatique, de l'affichage d'elements d'affichage, notamment d'elements charges depuis un poste distant | |
FR2807181A1 (fr) | Procede et systeme de gestion, dans un poste informatique, de l'affichage de fenetres lors d'une operation de glisser-deposer | |
FR2805376A1 (fr) | Procede d'enrichissement selectif de graphes contenant a leurs noeuds des ensembles informations | |
FR2805374A1 (fr) | Systeme de navigation mis en oeuvre dans un systeme informatique pour acceder a des pages fournies par des serveurs via un reseau informatique |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
PUAI | Public reference made under article 153(3) epc to a published international application that has entered the european phase |
Free format text: ORIGINAL CODE: 0009012 |
|
17P | Request for examination filed |
Effective date: 20060908 |
|
AK | Designated contracting states |
Kind code of ref document: A2 Designated state(s): AT BE BG CH CY CZ DE DK EE ES FI FR GB GR HU IE IT LI LU MC NL PL PT RO SE SI SK TR |
|
DAX | Request for extension of the european patent (deleted) | ||
17Q | First examination report despatched |
Effective date: 20120120 |
|
STAA | Information on the status of an ep patent application or granted ep patent |
Free format text: STATUS: THE APPLICATION IS DEEMED TO BE WITHDRAWN |
|
18D | Application deemed to be withdrawn |
Effective date: 20141015 |