WO2019155168A1 - Procédé de transformation d'une séquence pour la rendre exécutable par une machine - Google Patents

Procédé de transformation d'une séquence pour la rendre exécutable par une machine Download PDF

Info

Publication number
WO2019155168A1
WO2019155168A1 PCT/FR2019/050272 FR2019050272W WO2019155168A1 WO 2019155168 A1 WO2019155168 A1 WO 2019155168A1 FR 2019050272 W FR2019050272 W FR 2019050272W WO 2019155168 A1 WO2019155168 A1 WO 2019155168A1
Authority
WO
WIPO (PCT)
Prior art keywords
class
function
upstream
sequence
classes
Prior art date
Application number
PCT/FR2019/050272
Other languages
English (en)
Inventor
Christophe Leveque
Original Assignee
Christophe Leveque
Priority date (The priority date 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 date listed.)
Filing date
Publication date
Application filed by Christophe Leveque filed Critical Christophe Leveque
Priority to EP19710040.7A priority Critical patent/EP3750051A1/fr
Publication of WO2019155168A1 publication Critical patent/WO2019155168A1/fr

Links

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00—Arrangements for software engineering
    • G06F8/40—Transformation of program code
    • G06F8/41—Compilation
    • G—PHYSICS
    • G05—CONTROLLING; REGULATING
    • G05B—CONTROL OR REGULATING SYSTEMS IN GENERAL; FUNCTIONAL ELEMENTS OF SUCH SYSTEMS; MONITORING OR TESTING ARRANGEMENTS FOR SUCH SYSTEMS OR ELEMENTS
    • G05B19/00—Programme-control systems
    • G05B19/02—Programme-control systems electric
    • G05B19/04—Programme control other than numerical control, i.e. in sequence controllers or logic controllers
    • G05B19/042—Programme control other than numerical control, i.e. in sequence controllers or logic controllers using digital processors
    • G05B19/0426—Programming the control sequence
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
    • G06F16/20—Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
    • G06F16/24—Querying
    • G06F16/245—Query processing
    • G06F16/2452—Query translation
    • G06F16/24522—Translation of natural language queries to structured queries
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
    • G06F16/20—Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
    • G06F16/28—Databases characterised by their database models, e.g. relational or object models
    • G06F16/282—Hierarchical databases, e.g. IMS, LDAP data stores or Lotus Notes
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F40/00—Handling natural language data
    • G06F40/20—Natural language analysis
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F40/00—Handling natural language data
    • G06F40/20—Natural language analysis
    • G06F40/279—Recognition of textual entities
    • G06F40/284—Lexical analysis, e.g. tokenisation or collocates
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F40/00—Handling natural language data
    • G06F40/40—Processing or translation of natural language
    • G—PHYSICS
    • G05—CONTROLLING; REGULATING
    • G05B—CONTROL OR REGULATING SYSTEMS IN GENERAL; FUNCTIONAL ELEMENTS OF SUCH SYSTEMS; MONITORING OR TESTING ARRANGEMENTS FOR SUCH SYSTEMS OR ELEMENTS
    • G05B2219/00—Program-control systems
    • G05B2219/20—Pc systems
    • G05B2219/23—Pc programming
    • G05B2219/23272—Natural language, use simple words like move, rotate

Definitions

  • the present invention relates to a method of transforming a sequence comprising several words from a natural language to make said sequence executable in real time to control a machine.
  • Some known methods use classes but are very limited in interpreting a natural language given the complexity of the language and the differences from one language to another.
  • Some documents of the prior art also provide methods for interpreting a natural language, for example document US6243670.
  • This document describes a process that recognizes a list of type objects characteristic of languages, verbs, adverbs, nouns, pronouns ... This process is also limited because the number of languages and differences in structure from one language to another thus render the process described non-universal.
  • the described method also requires a pre-knowledge of a dictionary of the words of the language in question and their semantic status.
  • WO 00/23889 which describes a method for compiling a source code comprising declarations in natural language
  • US2017239576 which describes a method for automatically generating a program from a natural language for specific computer applications to generate an application, such as a video game.
  • the machine is a device or set of devices capable of performing some work or performing a certain function, either under the guidance of an operator, or in an autonomous manner.
  • Machines are more and more complex. It becomes ineffective to use an array of buttons or levers. That is why it is necessary to find a new technical solution to improve the control of the machines by providing a recognition of the commands formulated in natural language and making it possible to control the machine.
  • the present invention aims to remedy these disadvantages.
  • the present invention is directed to a method implemented by computer for transforming a sequence comprising several words from a natural language to make said sequence executable in real time in order to control a machine, remarkable in that said method comprises the following steps:
  • said class if said class also includes a class expression and a sense, then said class is called Generalized class, if the meaning is upstream said class is called upstream Generalized class, if the meaning is downstream, said class is called Generalized class down, if it is an upstream Generalized class then the class in the first position of its class expression is an upstream function class and the second class of its class expression is a class.parameter,
  • a function class is at least one of the following: an upstream function class, and a downstream function class,
  • a function class Dep is either a function class Dep up, or a function class Dep down
  • said classes function Dep present in the table have the characteristic that any class generalized of one of said function classes Dep is known from the method as a function class of direction inverted to said function class Dep, called function class ParDeo, and
  • an upstream ParDeo function class is an upstream function class and is a generalized class of a function class Dep avale, and
  • a function class ParDeo downstream is a downstream function class and is a generalized class of an upstream function class Dep,
  • a hierarchical relationship table is also defined for pairs consisting of an upstream function class or a function class Dep and a downstream function class or a function class Dep, said hierarchical report indicates for each of the pairs present in the table which of the two classes functions of the pair is hierarchically dominant over the other,
  • a downstream function class is subsequent to an upstream function class or a hierarchically dominant Dep function class, and said function classes are separated by a non-empty parameter, then said function class swallows non-hierarchically dominant precedence in taking said parameter on the upstream function class or the function class Dep hierarchically dominant,
  • said database also includes reserved classes, each reserved class includes a number and a simple expression, each simple expression of which is preceded by a marking,
  • said database comprises the following predefined elements: first class reserved, second class reserved, third class reserved, fourth class reserved, fifth class reserved,
  • the first reserved class, the second reserved class, the third reserved class and the fourth reserved class are hereinafter referred to as GI classes.
  • the first three GI classes correspond to the first GI class, the second GI class and the third GI class.
  • the last three GI classes correspond to the second class IG, third class IG and fourth class IG.
  • the first reserved class and the fourth reserved class have the function of indicating in a sequence the beginning and the end of a generalized class.
  • the second reserved class always positioned within a portion of the sequence delimited by the first reserved class and the fourth reserved class, separates said sequence part into two sub-parts, the first of which represents an upstream function class and the second represents a parameter class, and indicates that said sequence portion represents an upstream Generalized class.
  • the third reserved class always positioned within a portion of the sequence delimited by the first reserved class and the fourth reserved class, separates said sequence part into two sub-parts, the first of which represents a parameter class and the second represents a downstream function class, and indicates that said sequence part represents a generalized class downstream,
  • IG expression a sequence or part of a sequence comprising IG classes.
  • the fifth reserved class is a function class and designates any class as executable by a machine.
  • the preprocessing step includes a comparison of the sequence with the data of the database:
  • dichotomy in which the simple expressions and IG expressions known in the process are searched for in the sequence as an upstream function class or a downstream function class, the sequence is dichotomized until all the function classes contained in the sequence likely to give rise to dichotomies has been
  • the dichotomy step consists of:
  • said upstream function class if it is an upstream function class, and said upstream function class if No Dep is at the beginning of the sequence or immediately preceded by one of the first three IG classes and said upstream function is not at the end of sequence and not immediately followed by one of the last three classes IG, then it is identified a part of the sequence playing the role of a parameter class for said upstream function class, said parameter class, contiguous to said upstream function class, starts at the position following said upstream function class and whose end position is identified by continuing on the positions of the sequence from the start position of the parameter class and is:
  • step b) of dichotomy allows nested Generalized classes.
  • sequence part is stored in the database with at least the following two information: a new number and its simple expression
  • the resulting sequence is called the LIG expression of the sequence.
  • the proposed method allows a system to learn as and when, and build its knowledge from the previous knowledge.
  • the method allows:
  • the method makes it possible to understand an unknown sequence in order to apply it to control a machine.
  • Said method is light in resource, can be local (without internet connection) and carried by a computer.
  • a computer is a programmable information processing system or device that operates by sequentially reading a set of instructions organized in programs.
  • computers a digital tablet, a mobile phone, especially of the "smartphone" type, a connected watch, connected glasses, a remote control, a headset, a virtual reality headset, a connected television, a game console, or an internet box.
  • characters are transmitted or collected by means of treatment without waiting for the end of the process treatment.
  • characters are transmitted in writing or by the dictation of a voice transmitted in real time.
  • the method is capable of driving a physical machine at a speed adapted to the evolution of the machine.
  • Database is defined as physical memory The database is used to store and retrieve all raw data or information related to the character or characters of a sequence.
  • IG classes are visible and easily readable by the user when inserted into a text (a sequence / a class). And this means for the user an extremely reduced learning.
  • a method made extremely light by this method allowing it to operate with very limited resources, allowing it to be shipped directly into the machine without external means of communication necessary.
  • this method will require only about thirty instances in the database.
  • the update of the table of the functions Dep in step b) is determined according to the following conditions: if an upstream function class applies to a first upstream number corresponding to the recurrence number of said upstream function class of the upstream Generalized classes of the database, and if said upstream function class applies to a second upstream number corresponding to the number of recurrence of said generalized classes which are aval function classes, and of which said second upstream number is at least greater than half of the first number, then the upstream function class is an upstream function class Dep,
  • downstream function class if a downstream function class applies to a first downstream number corresponding to the number of recurrences of said downstream function class of the generalized classes downstream of the database, and that said downstream function class applies to a second downstream number corresponding to the number of recurrence of said generalized classes which are upstream function classes, and of which said second downstream number is at least greater than half of the first number, then the downstream function class is a function class Dep downstream.
  • the method comprises the following elements: if an upstream function class is earlier in a sequence than a downstream function class, the hierarchical relationship between the upstream and the upstream function class is evaluated the function class swallows as:
  • said upstream function class applies to an upstream number corresponds to the number of recurrences of said upstream function class of the upstream generalized classes of the database in which the parameter classes are generalized downstream classes whose function is said downstream function class, and that said downstream function class applies to a downstream number corresponds to the recurrence number of said downstream function class of the downstream Generalized classes of the database in which the parameter classes are upstream generalized classes whose function is said upstream function class , and that: if the upstream number is greater than the downstream number then said upstream function class is a hierarchically dominant on said downstream function class, if the downstream number is greater than the upstream number then said downstream function class is a hierarchically dominant on said upstream function class,
  • Said evaluation allows the method: either updating the table of hierarchical relations between the functions, or in step b) of dichotomy and if realized in real time, to replace the table of hierarchical relations, and thus of operate without prior knowledge of said hierarchical relationship table.
  • step b) of dichotomy the method comprises the following elements:
  • an upstream list number then being obtained by accumulating the upstream numbers for each of the pairs consisting of an upstream function class belonging to the list an upstream function class and a downstream function class belonging to the list of the downstream function class
  • the downstream list number then being obtained by cumulating the downstream numbers for each of the pairs consisting of an upstream function class belonging to the list upstream function class and a downstream function class belonging to the downstream function class list
  • said upstream function class list is a hierarchically dominant on said downstream function class list
  • downstream function class list is hierarchically dominant on said upstream function class list, otherwise there is no hierarchical relationship between said upstream function class list and said function class list swallows, if an upstream function class is earlier in a sequence than a downstream function class and there is no hierarchical relationship directly between said upstream function class and said downstream function class and that one or both are class ParDep functions, then it is evaluated the hierarchical relationship of the list of function classes ParDep upstream of the same class function Dep down from said upstream function class if it is a function class ParDep and of the list of function classes ParDep downstream of the same function class Dep upstream of said downstream function class if it is a function class ParDep,
  • an upstream function class if an upstream function class is earlier in a sequence than a function class Dep also upstream, it evaluates the hierarchical relationship of the upstream function class and the list of all the function classes ParDep downstream of the function class Dep upstream,
  • step b) it is added if it is an upstream function the following option in determining the end position of the parameter of said upstream function:
  • step b) it is added if it is a function downstream the following option in determining the starting position of the parameter of said downstream function:
  • the application of this provision anticipates the appearance of a function ParDep posterior downstream in the sequence to an upstream function and authorizes the application of the hierarchy of said upstream function with the downstream Pardep functions of the upstream function Dep, and accordingly increases the ability of the process to predict how to be dichotomized thus including a new sequence.
  • step c) if the generalized class is known, its class expression and its meaning are updated.
  • the update will allow on the one hand to correct the understanding of a sequence by using the IG classes directly in the sequence, but also to apply the most recent hierarchies and thus to correct errors. understanding of previously learned sequences. The system will be able to evolve constantly.
  • the second upstream number is at least greater than two-thirds of the first number and the second downstream number is at least greater than two-thirds of the first number.
  • said step b) when searching for function classes in the sequence, further comprises that if a function class is found in the sequence and the IG expression of said function class contains other classes function then said function class is treated in priority on said other function classes.
  • the database also comprises a sixth reserved class
  • said sixth reserved class is a downstream function class and designates any function class Dep as an equivalence function since said function class Dep expects to be parameter in a generalized class whose function is the sixth reserved class, thus any parameter class of a generalized class whose function is the function class ParDep of a function class Dep and equivalence has for equivalent class the parameter class of the function class Dep in the class generalized function ParDep, in the execution step d), if a class is encountered in the sequence and a generalized class is known whose parameter is said class and the function is a function class ParDep of a function class Dep and d equivalence, then the LIG expression of said class is substituted in the sequence by the LIG expression of its equivalent class, the iteration taking over at the beginning of said class,
  • the LIG expression of said equivalent class starts with the number of said class and is obtained by iteration by following all the numbers of the generalized classes of the LIG expression of said class by the number of the first class IG, then the number of the class the first class of the class expression of the generalized class, then the number of the second class IG if the class is a generalized class upstream or the number of the third class IG if the class is a generalized class swallows, then the number of the class the second class of the class expression of the generalized class, then the number of the fourth class IG.
  • the set of these provisions makes it possible to transform any class into another class and in particular a sequence representing an order written in natural language into a class executable by a machine.
  • step b) of dichotomy if there is no hierarchical relationship between two function classes, it is searched for each of the two class functions the list of classes related functions in the database then the recursion of each function class is compared to evaluate the hierarchy between these two lists, the list of classes related to a class being defined as the list of classes which are a parameter class in generalized classes and whose function classes are also apply to said class in a generalized class.
  • This arrangement makes it possible to name and categorize classes sharing various characteristics and thus by naming a new class of the same category, to make it benefit from the hierarchies already learned for the other classes in the category.
  • pretreatment step a) if the reserved class marker is followed by a number, then that expression is substituted in the sequence by the number of the class of the same number.
  • FIG. 1 in the form of a logic diagram, the steps implemented in a particular embodiment of the method that is the subject of the present invention,
  • FIGS. 2 to 5 in the form of a logic diagram, represent the details of the steps implemented in a particular embodiment of the method that is the subject of the present invention.
  • FIG. 6 represents a diagram of reconstitution of a LIG sequence of a class.
  • a sequence is defined as a series of elements put and processed one after the other.
  • a sequence will be understood here as a sequence of numbers.
  • An order such as ⁇ turn right ⁇ which is a sequence of characters is actually a sequence of numbers - encoded via the Ascii table (acronym for American Standard Code for Information Interchange in English terminology for US Standard Code for Information Exchange ) or Uni code (computer standard that allows exchanges of texts in different languages) and so ⁇ turn right ⁇ is a sequence.
  • the essential function of the method is to recognize and process sequences.
  • a database will keep the sequences processed by the method.
  • the process will assign a number (No) to each of these sequences, this No is called No Class or more, simply "class"
  • a class can also be written as other classes.
  • a sequence can be written from already known sequences.
  • ⁇ C1 C2 ⁇ being the sequence consisting of class C1 and class C2.
  • classes can play a function or parameter role.
  • CRO the first reserved class ⁇ [ ⁇ , CR1: the second class reserved ⁇ » ⁇ , CR2: the third reserved class ⁇ " ⁇ , CR3: the fourth class reserved ⁇ j ⁇ .
  • the method recognizes in the sequence the sequences of the Reserved Words used and substitutes them by the numbers (Nos) of corresponding classes.
  • the sequence will then be ⁇ CROturn CR1 leftCR3 ⁇ (step 0)
  • the process identifies on the base (or will create if unknown) the classes ⁇ turn ⁇ and ⁇ right ⁇ is C1 and C2, ⁇ turn ⁇ being the sequence between CRO and CR1 and ⁇ right ⁇ being the sequence between CR1 and CR3 . Then the process identifies on the base (or will create if unknown) the class ⁇ turn right ⁇ either C3, ⁇ turn right ⁇ being the sequence of C1 + the sequence of C2.
  • step 2 This step is ensured by the step identification-creation, (step 2) whose mission is to identify on the database, or to create if unknown, all the component classes delimited by the classes CRO to CR3 in the sequence.
  • step 2 This step is ensured by the step of Dichotomy (step 1) whose mission is to insert in the sequence that it has to treat classes CRO to CR3 by relying on the known functions of the method. Then the process will follow on learning this sequence exactly as above (see step 2).
  • Step 1 pretreatment
  • step 1 dichotomy
  • step 2 identification-creation.
  • Classes C3 and C5 are designated as "Generalized Classes" or Classes G.
  • the notion of generalization consists in replicating in the generality a behavior found in a case taken as an example, in this case the role of function that a class can have. .
  • the G classes have in the database in addition to their simple expression, an expression in terms of class, always consisting of two classes, and a meaning. Since classes G always consist of a function and a parameter, the meaning will indicate where the function is in the expression in terms of class. If the sense is Am the function will be at the beginning and the parameter at the end and vice versa.
  • a class G can therefore be written as ⁇ [Function class ⁇ »Parameter class ⁇ for a class G Amont Or as ⁇ [Parameter class ⁇ " Function class ⁇ ] ⁇ for a class G Swallow.
  • IG Classes G indication classes
  • function and parameter classes can themselves be classes G, it follows that the IG classes make it possible to establish the functional dichotomy of a sequence. This functional dichotomy reflects how the process understood the sequence.
  • the method knows how to recognize certain functions that make it possible to connect two classes.
  • Cx and Cy are any two classes acting as parameters. These two classes are connected in the sequence by the function F0.
  • F0 is an Upstream function in the class G ⁇ [F0 ⁇ »Cy ⁇ j ⁇ that the class G ⁇ [F0 ⁇ » Cy ⁇ j ⁇ is itself a function, Swallow this time in our sequence (1)
  • a class being a function in one direction and whose classes G using this class as a function are also functions but in the opposite direction is the characteristic of the so-called dependent functions or "Dep functions".
  • the dichotomy step does not modify the sequence (no function is known).
  • ⁇ turn left means ⁇ SETWHEEL-1 ⁇
  • step of dichotomy recognizes in the sequence the function ⁇ means ⁇ (step 1/1) learned previously and will insert in this sequence the Reserved Classes CRO to CR3 corresponding to a situation of Function Amount Dep. Which will give: (steps 1/2 and 1/3)
  • These executable classes G have a parameter (or parameter class).
  • any class GDep ⁇ [Cx ⁇ " ⁇ [Fx ⁇ » Cy ⁇ ] ⁇ ] ⁇ or reciprocal such that ⁇ [Fx ⁇ " ⁇ EXE ⁇ ] ⁇ has been learned.
  • These executable GDep classes have two parameters.
  • the method has an "Execution” step (step 3/3) that will recognize these classes and ensure their execution.
  • ⁇ SETWHEEL is assumed to have been initialized in the Reserved Words and linked in the Execution algorithm to the vehicle wheel control program.
  • Cx is a class G whose function ⁇ SETWHEEL is
  • ⁇ SETWHEEL0 ⁇ sets the wheels straight and ⁇ SETWHEEL-1 ⁇ sets the wheels to the left.
  • step 0 preprocessing
  • step 1 dichotomy
  • step 2 identification-creation
  • step 3 application 3
  • the G Dep and Equivalence classes will be of the form: ⁇ [C ⁇ " ⁇ [Feqv ⁇ " Ceqv ⁇ ] ⁇ with ⁇ [Feqv ⁇ " ⁇ EQV ⁇ ] ⁇ known / learned and in which
  • Feqv is the function here Am and Dep and equivalence
  • Ceqv is the class equivalent to C
  • the method has an equivalence step which will search on the basis for the classes C which are submitted to it, their equivalent class Ceqv. (step 3/2)
  • step 0 pretreatment
  • step 1 dichotomy
  • step 2 identification-creation
  • step 3 application 3, equivalent 3/2, execution 3/3
  • step 1 The dichotomy step has no effect here (there is no function in the sequence) (step 1)
  • the identification-creation step finds the class because created in (1) above either Cy (step 2)
  • the Application step starts the iteration for Cx (step 3/1)
  • ⁇ turn left means ⁇ SETWHEEL-1 ⁇ and ⁇ go straight means ⁇ SETWHEEL0 ⁇ so that the ⁇ turn left ⁇ and ⁇ go straight ⁇ commands are now correctly executed.
  • the received sequence is of type "String" (string of characters) each character is coded is:
  • the first classes are reserved for characters.
  • the non-character classes coming next. And this in order to make coexist in the same sequence characters and classes (Rmots for example) whose No will be beyond 255 (ascii case), the sequence is classically binarized on 32 bits for current computers (step 0 / 1).
  • the maximum number of classes then being (2 ⁇ 31 -1) (Class nos are always positive).
  • sequences processed by the method are at the end of the Sequence Reception (step 0) and for the continuation of the "Large Integer” chains in English terminology for "large integers” in French, During preprocessing, the sequences corresponding to reserved words are replaced by their class number
  • the mission of the Dichotomizer is to insert in the sequence to be treated, the classes IG (CRO to CR3) relying on the functions
  • the Dichotomizer does not have to process this function and therefore does not modify the sequence.
  • the first function found will be ⁇ turn ⁇ , it does not participate as a function to a class G and can therefore be processed (step 1/1).
  • the scope of its parameter stops at CR2 ⁇ " ⁇ , indeed the entity to be treated is the parameter:
  • the dichotomizer transforms ⁇ turn right ⁇ into ⁇ [turn ⁇ "right ⁇ ] ⁇ in the sequence (step 1/3).
  • the Dichotomizer will then resume the function search (step
  • ⁇ SETWHEEL1 ⁇ is transformed in the sequence into ⁇ [ ⁇ SETWHEEL ⁇ »1 ⁇ ] ⁇ (step 1/3).
  • the Dichotomizer resumes the function search and will no longer find any unexpressed.
  • the Dichotomizer has received a sequence already containing IG classes.
  • IG sequence A sequence including the IG classes for all known functions of the process and present in the sequence will be referred to as "IG sequence”.
  • This sequence format is the output format of the sequences for the Dichotomizer. This will also be the input format of the sequences for the Identification-Creation algorithm.
  • the mission of the identification-creation stage is either to identify (if known) the component classes of the sequence (delimited by the IG classes), or to create them on the database.
  • ⁇ 1 ⁇ being a character, it is by construction already known ( ⁇ 1 ⁇ will be the class 49 in the cases Ascii extended, Utf8).
  • This IG sequence will be gradually converted, as identifications or creations of classes, in LIG sequence in which:
  • LIG's "L” comes from Lead class in English terminology for “leading class number” in French. In other words "sequence with Lead and Indication G classes". In this format a sequence carries in itself all the information necessary for its Application / execution (step 3).
  • a class G can be created only if one already knows on the base its Function AND its Parameter. In other words, if a class number has already been assigned to them. The sequences of the Dichotomizer stage take this into account.
  • step 2/7 class G unknown on the sequence whose function and parameter are also unknown on the sequence -> return iteration.
  • step 2/1) Following iteration for class ⁇ t ⁇ in the 3 rd position in (1) (step 2/1)
  • step 2/3 we are in the case of step 2/3.
  • second iteration - that is the position of the beginning of the class G corresponding to the CR3 in sixth position and in the case of absence of lead.
  • the LIG sequences have the extreme advantage of linearizing the class structure (see Figure 6). Consequently, an iteration on the classes of a LIG sequence makes it possible to "scan" all the classes involved in the structure starting from the largest ones and respecting the chronological order.
  • the LIG sequences account for how the process has learned and understood a sequence.
  • F1 be an upstream function
  • F2 a swallow function
  • Pi a parameter
  • the process takes the hierarchy most often known. That is, if Ni> Nj.
  • the process takes F1 >>> F2 and vice versa.
  • ⁇ Turn ⁇ is an upstream
  • ⁇ turn left means ⁇ SETWHEEL-1 ⁇
  • the dichotomy step finds the function ⁇ turn ⁇ with as parameter all or part of ⁇ left means ⁇ SETWHEEL-1 ⁇
  • the method accordingly limits the scope of the parameter to ⁇ left ⁇ .
  • the dichotomy step is not found in this Downstream parameter, so it will not reduce the scope of the parameter and will insert the IG classes such as:
  • the class to create is No G and known G -> no update to make, the class remains G on the database
  • the class to be created is G and known G in a different form (the meaning and / or the function and the parameter are different) -> we update the expression in terms of class and meaning (the new version takes precedence over the 'Ancient),
  • the dichotomy step may establish an erroneous dichotomy for a sequence. It is then enough to re-enter said sequence by mentioning the classes IG according to what must be understood. The sequence will then be corrected.
  • ⁇ turn left means ⁇ SETWHEEL-1 ⁇
  • ⁇ SETENGINE is linked in the execution stage to the engine control.
  • the corresponding orders are:
  • ⁇ go ahead means ⁇ SETENGINE1 ⁇
  • the identification-creation step is performed as the dichotomy step.
  • a function class is also called just function.
  • a parameter class is also called just parameter.
  • the principle of the dichotomy is that it is the hierarchical relationships between two functions that make it possible to dichotomise a sequence.
  • Example 1 Case of a Known Hierarchy in the Hierarchical Reporting Table
  • step b) of dichotomy it is recognized the function upstream ⁇ turn ⁇ which is correctly bordered and can thus be considered.
  • ⁇ turn ⁇ is an upstream function
  • ⁇ turn ⁇ is an upstream function
  • the System does not have a direct / simple reporting relationship
  • ⁇ turn right means ⁇ SETWHEEL1 ⁇
  • ⁇ turn ⁇ is an upstream function
  • ⁇ turn right means ⁇ SETWHEEL1 ⁇
  • the upstream ⁇ turn ⁇ function will be processed because when it is well defined, when searching for the scope of its parameter, it is met with the upstream function ⁇ means ⁇ , it is then evaluated the hierarchical relationship of the function ⁇ turn ⁇ versus the function list ParDep of ⁇ means ⁇ is S6, the generalized class S5 gives us an occurrence such that ⁇ turn ⁇ ⁇ S6.
  • the upstream function ⁇ turn ⁇ will be processed because, when searching for the range of its parameter, the upstream Dep function ⁇ is met, it is then evaluated the hierarchical relationship of the function ⁇ turn ⁇ versus the list of ParDep functions of ⁇ signifies ⁇ , which list is empty, so there is no hierarchy via this mode, it is then searched for the related functions of ⁇ signifies ⁇ , the system will then find via S7 and S8 the function ⁇ means ⁇ , it will look for the hierarchy of ⁇ turn ⁇ versus ⁇ means ⁇ , which the system knows as being

Abstract

L'invention concerne un procédé mis en œuvre par ordinateur de transformation d'une séquence comportant plusieurs mots issus d'une langue naturelle pour rendre ladite séquence exécutable en temps réel pour piloter une machine. Le procédé comprend les étapes suivantes : - prétraitement, dans lequel une séquence constituée de plusieurs caractères formant des mots issus d'une langue naturelle, ladite séquence est comparée avec des données d'une base de données comportant des classes, - dichotomie, dans laquelle il est recherché dans la séquence les expressions simples et expressions IG connues dans le procédé comme étant une classe fonction amont ou une classe fonction avale, la séquence est dichotomisée jusqu'à ce que toutes les classes fonction contenues dans la séquence susceptibles de donner lieu à des dichotomies l'ait été, - identification-création, - exécution, où il est itéré de la première à la dernière des classes de la séquence, chaque classe exécutable est exécutée par une machine.

Description

PROCÉDÉ DE TRANSFORMATION D’UNE SÉQUENCE POUR LA RENDRE
EXÉCUTABLE PAR UNE MACHINE
DOMAINE TECHNIQUE DE L’INVENTION
La présente invention concerne un procédé de transformation d’une séquence comportant plusieurs mots issus d’une langue naturelle pour rendre ladite séquence exécutable en temps réel pour piloter une machine.
ETAT DE LA TECHNIQUE
Certains procédés connus utilisent des classes mais sont très limitées pour interpréter un langage naturel étant donné la complexité du langage et les différences d’une langue à une autre.
Certains documents de l'art antérieur proposent également des procédés pour interpréter un langage naturel par exemple le document US6243670. Ce document décrit un procédé qui reconnaît une liste de type d’objet caractéristique de langues, verbes, adverbes, noms, pronoms... Ce procédé est également limité car le nombre de langues et les différences de structure d’une langue à une autre, rendent ainsi le procédé décrit non universel. Le procédé décrit requière également une pré-connaissance d’un dictionnaire des mots de la langue en question et de leur statut sémantique.
Des exemples de document qui représentent l’état de l’art sont les documents suivants :
- WO 00/23889 qui décrit un procédé pour compiler un code source comprenant des déclarations en langue naturel ;
- US2017239576 qui décrit un procédé pour générer automatiquement un programme à partir d’un langage naturel pour des applications informatiques spécifiques pour générer une application, comme un jeu vidéo.
Ces documents de l’état de l’art présentent une base de données comportant un dictionnaire. Le dictionnaire comporte un certain nombre d’élément lourd en ressource. Le résultat du programme donne un code qui est figé et ne peut évoluer sans modification fondamental du programme. Ces programmes nécessitent pour être exécuter le fait de compiler à chaque modification du programme.
La machine est un appareil ou ensemble d'appareils capable d'effectuer un certain travail ou de remplir une certaine fonction, soit sous la conduite d'un opérateur, soit d'une manière autonome.
Les machines sont de plus en plus complexes. Il devient inefficace de se servir de tableau de boutons ou de leviers. C’est pourquoi il est nécessaire de trouver une nouvelle solution technique pour améliorer la commande des machines en fournissant une reconnaissance des commandes formulées en langue naturelle et permettant de contrôler la machine.
OBJET DE L’INVENTION
La présente invention vise à remédier à ces inconvénients.
A cet effet, selon un premier aspect, la présente invention vise un procédé mis en oeuvre par ordinateur de transformation d’une séquence comportant plusieurs mots issus d’une langue naturelle pour rendre ladite séquence exécutable en temps réel afin de piloter une machine, remarquable en ce que ledit procédé comprend les étapes suivantes :
a) prétraitement, dans lequel une séquence constituée de plusieurs caractères formant des mots issus d’une langue naturelle, ladite séquence est comparée avec des données d’une base de données comportant des classes, chaque classe comprenant au minimum les deux premiers des éléments suivants :
■ un numéro,
■ une expression simple constituée par la suite de caractères représentant la classe,
■ une expression classe composée de deux numéros correspondant à deux autres classes, soit positionné en une première position, soit positionné en une deuxième position, et
■ un sens, ledit sens étant soit amont, soit aval,
si ladite classe comprend également une expression classe et un sens, alors ladite classe est appelée classe Généralisée, si le sens est amont ladite classe est appelée classe Généralisée amont, si le sens est aval, ladite classe est appelée classe Généralisée avale, s’il s’agit d’une classe Généralisée amont alors la classe en première position de son expression classe est une classe fonction amont et la classe en deuxième position de son expression classe est une classe.paramètre,
s’il s’agit d’une classe Généralisée avale alors la classe en première position de son expression classe est une classe.. paramètre et la classe en deuxième position de son expression classe est une classe fonction avale, une classe fonction est au moins l’un des éléments suivants : une classe fonction amont, et une classe fonction avale,
il est défini une table de classes fonctions amonts ou avales particulières appelées classe fonction Dep, une classe fonction Dep est soit une classe fonction Dep amont, soit une classe fonction Dep avale, lesdites classes fonction Dep présentes dans la table ont pour caractéristique que toute classe généralisée de l'une desdites classes fonction Dep est connue du procédé comme une classe fonction de sens inversé à ladite classe fonction Dep, appelée classe fonction ParDeo, ainsi
une classe fonction ParDeo amont est une classe fonction amont et est une classe Généralisée d'une classe fonction Dep avale, et
une classe fonction ParDeo avale est une classe fonction avale et est une classe Généralisée d'une classe fonction Dep amont,
il est également défini une table de rapports hiérarchiques pour des couples constitués d'une classe fonction amont ou d’une classe fonction Dep et d'une classe fonction avale ou d’une classe fonction Dep, ledit rapport hiérarchique indique pour chacun des couples présents dans la table laquelle des deux classes fonctions du couple est Hiérarchiquement dominante sur l'autre,
si dans une séquence une classe fonction amont précède une classe fonction avale ou une classe fonction Dep hiérarchiquement dominante, et que lesdites classes fonctions soient séparées par un paramètre non vide, alors ladite classe fonction amont non hiérarchiquement dominante à la préséance dans la prise dudit paramètre sur la classe fonction avale ou la classe fonction Dep hiérarchiquement dominante,
si dans une séquence une classe fonction avale est postérieure à une classe fonction amont ou une classe fonction Dep hiérarchiquement dominante, et que lesdites classes fonctions soient séparées par un paramètre non vide, alors ladite classe fonction avale non hiérarchiquement dominante à la préséance dans la prise dudit paramètre sur la classe fonction amont ou la classe fonction Dep hiérarchiquement dominante,
ladite base de données comporte également des classes réservées, chaque classe réservée comporte un numéro et une expression simple, dont chaque expression simple est précédé d’un marquage,
ladite base de données comporte les éléments suivants prédéfinis : première classe réservée, deuxième classe réservée, troisième classe réservée, quatrième classe réservée, cinquième classe réservée,
la première classe réservée, la deuxième classe réservée, la troisième classe réservée et la quatrième classe réservée sont ci-après désignées classes IG.
Les trois premières classe IG correspondent à la première classe IG, la deuxième classe IG et la troisième classe IG. Les trois dernières classe IG correspond à la deuxième classe IG, troisième classe IG et quatrième classe IG.
La première classe réservée et la quatrième classe réservée ont pour fonction d’indiquer dans une séquence le début et la fin d'une classe Généralisée.
La seconde classe réservée, toujours positionnée à l'intérieur d'une partie de la séquence délimitée par la première classe réservée et la quatrième classe réservée, sépare ladite partie de séquence en deux sous parties dont la première représente une classe fonction amont et la seconde représente une classe paramètre, et indique que ladite partie de séquence représente une classe Généralisée amont.
La troisième classe réservée, toujours positionnée à l'intérieur d'une partie de la séquence délimitée par la première classe réservée et la quatrième classe réservée, sépare ladite partie de séquence en deux sous parties dont la première représente une classe paramètre et la seconde représente une classe fonction avale, et indique que ladite partie de séquence représente une classe Généralisée avale,
une séquence ou partie de séquence comportant des classes IG est dénommé expression IG.
La cinquième classe réservée est une classe fonction et désigne toute classe comme exécutable par une machine. L’étape de prétraitement comporte une comparaison de la séquence avec les données de la base de données :
si une classe réservée est reconnue dans une partie de la séquence, alors ladite partie de la séquence est substituée par le numéro de la classe réservée correspondant,
b) dichotomie, dans laquelle il est recherché dans la séquence les expressions simples et expressions IG connues dans le procédé comme étant une classe fonction amont ou une classe fonction avale, la séquence est dichotomisée jusqu’à ce que toutes les classes fonction contenues dans la séquence susceptibles de donner lieu à des dichotomies l'ait été,
pour chacune des classes fonctions amonts ou classes fonctions avales trouvées dans la séquence, l’étape de dichotomie consiste à :
- s’il s’agit d'une classe fonction amont, et ladite classe fonction amont si Non Dep se trouve au début de la séquence ou immédiatement précédée de l'une des trois premières classe IG et ladite fonction amont se trouve non en fin de séquence et non immédiatement suivie de l’une des trois dernières classes IG, alors il est identifié une partie de la séquence jouant le rôle d’une classe paramètre pour ladite classe fonction amont, ladite classe paramètre, contigu à ladite classe fonction amont, débute à la position suivant ladite classe fonction amont et dont la position de fin est identifiée en poursuivant sur les positions de la séquence à partir de la position de début de la classe paramètre et est :
soit à la position précédant l'expression simple ou l'expression IG d'une classe fonction avale ou d’une classe fonction Dep, et de hiérarchie dominante sur ladite classe fonction amont, soit à la position précédent de l”une des trois dernières classes IG sachant que s’il est rencontré la première classe réservée à une position, l'analyse reprend à la position suivant la quatrième classe réservée correspondante à la première classe réservée rencontrée, soit en fin de séquence,
lorsque la position de fin de la classe paramètre est ainsi déterminée, et si les positions de début et de fin de la classe paramètre sont différentes, il est inséré dans la séquence : la première classe réservée à la position précédent la classe fonction amont,
la deuxième classe réservée entre la fin de la classe fonction amont et le début de la classe paramètre, la quatrième classe réservée à la fin de la classe paramètre,
l'insertion de ces trois classes IG définissent dans la séquence une classe Généralisée amont,
- si il s’agit d'une classe fonction avale, et ladite classe fonction avale si Non Dep se trouve en fin de la séquence ou immédiatement suivie de l’une des trois dernières classes IG et ladite fonction avale se trouve non au début de la séquence et non immédiatement précédée de l’une des trois premières classes IG, alors il est identifié une partie de la séquence jouant le rôle d’une classe paramètre pour ladite classe fonction avale, ladite classe paramètre, contigu a ladite classe fonction avale, se termine à la position précédant ladite classe fonction avale et dont la position de début est identifiée en régressant sur les positions de la séquence à partir de la position de fin de la classe paramètre et est :
soit à la position suivant l'expression simple ou expression IG d'une classe fonction amont ou d’une classe fonction Dep, et de hiérarchie dominante sur ladite classe fonction avale,
soit à la position suivant l'une des trois premières classes IG sachant que s’il est rencontré la quatrième classe réservée à une position, l'analyse reprend à la position précédent la première classe réservée correspondante à la quatrième classe réservée rencontrée,
soit en début de séquence,
lorsque la position du début de la classe paramètre est ainsi déterminée, et si les positions de début et de fin de la classe paramètre sont différentes, il est inséré dans la séquence :
la première classe réservée immédiatement avant la classe paramètre, la troisième classe réservée entre la fin de la classe paramètre et le début de la classe fonction avale,
la quatrième classe réservée à la fin de la classe fonction avale, l'insertion de ces trois classes IG définissent dans la séquence une classe Généralisée avale,
l’étape b) de dichotomie autorise des classes Généralisées imbriquées.
Le fait que l’étape de dichotomie autorise des classes Généralisées imbriquées ne permet pas à des classes Généralisées d’être intriquées.
c) identification-création, dans laquelle
■ toutes les classes fonctions et tous les classes paramètre non classes généralisées sont substituées dans la séquence par leur numéro de classe, et
■ il est inséré immédiatement avant la première classe réservée de chacune des classes généralisées le numéro de classe de ladite classe généralisé,
pour chaque classe généralisée contenue dans la séquence :
■ si la classe fonction définie par son expression simple est inconnue alors ladite classe fonction est stockée dans la base de données avec au moins les deux informations suivantes : un nouveau numéro et son expression simple,
■ si la classe paramètre définie par son expression simple est inconnue alors ladite classe paramètre est stockée dans la base de données avec au moins les deux informations suivantes : un nouveau numéro et son expression simple,
■ si la classe Généralisée définie par son expression simple est inconnue alors ladite classe Généralisée est stockée dans la base de données avec les informations suivantes : un nouveau numéro, son expression simple, son expression classe et son sens,
pour une partie de la séquence qui n’est pas une classe généralisée et est inconnue alors ladite partie séquence est stockée dans la base de données avec au moins les deux informations suivantes : un nouveau numéro et son expression simple,
la séquence obtenue est appelée expression LIG de la séquence.
d) exécution, où il est itéré de la première à la dernière des classes de la séquence et dans laquelle
■ les classes IG sont ignorées, ■ chaque classe exécutable est exécutée par une machine, la poursuite de l'itération reprenant en fin de ladite classe exécutable, une classe exécutable étant définie comme :
■ une classe paramètre liée à la cinquième classe réservée dans une classe généralisée,
■ une classe Généralisée dont la classe fonction est une classe exécutable,
■ une classe Généralisée dont la classe fonction est une classe fonction ParDep d'une classe fonction Dep qui est une classe exécutable.
Le procédé proposé permet à un système d'apprendre au fur et à mesure, et de construire son savoir à partir du savoir précédent.
Le procédé permet :
- d'assimiler à partir d'un nombre limité d'exemples les langues naturelles humaines en intégrant la compréhension de celles-ci
de prédire la façon dont doivent être comprises des phrases nouvelles ,ou en d'autres termes de traiter des séquences inconnues. Et en conséquence d'appeler correctement des sous programmes de commande de machine.
de s'adapter à des modifications linguistiques ou de compréhension.
d'apprendre simultanément plusieurs langues
L'ensemble créant une interface universelle et performante entre l'homme et la machine.
Le procédé permet de comprendre une séquence inconnue afin de l’appliquer pour piloter une machine.
Ledit procédé est léger en ressource, peut être en local (sans connexion à internet) et portée par un ordinateur.
On entend par ordinateur est un système ou un dispositif de traitement de l'information programmable et qui fonctionne par la lecture séquentielle d'un ensemble d'instructions, organisées en programmes.
Les exemples suivants sont considérés comme des ordinateurs : une tablette numérique, un téléphone mobile, notamment de type « smartphone », une montre connectée, des lunettes connectées, une télécommande, un casque, un casque de réalité virtuelle, une télévision connectée, une console de jeux, ou une box internet.
On entend par temps réel, le fait que les caractères sont transmis ou collectés au moyen de traitement sans attendre la fin du traitement du procédé. Par exemple, les caractères sont transmis par écrit ou par la dictée d’une voix émis en temps réel. Le procédé est capable de piloter une machine physique à une vitesse adaptée à l'évolution de la machine.
On entend par base de données comme étant une mémoire physique La base de données permet de stocker et de retrouver l'intégralité d’une données brutes ou d'informations en rapport avec le ou les caractères d’une séquence.
Les avantages résultants du procédé sont multiples :
Capacité d'apprentissage du système conférée à l'utilisateur. En insérant dans un texte a apprendre les classes IG, l’utilisateur pilote ainsi la compréhension du procédé. Une fois un texte appris par le procédé, il saura reproduire, pour des exemples différents la dichotomie et ce conformément à son apprentissage, en d'autres termes il saura ré-insérer de lui-même ces classes IG dans le texte qui lui est soumis sans IG. Cette dichotomie utilisant les IG traduit la compréhension du système et permet l'exécution correcte du texte/de la séquence/de la classe traitée. En d'autres termes, les classes IG définissent une méthode d'écriture de la compréhension !
Il est à noter que classes IG sont visibles et aisément lisibles par l'utilisateur lorsque insérées dans un texte (une séquence/une classe). Et ce moyennant pour l'utilisateur un apprentissage extrêmement réduit.
L'utilisateur ici n'a pas besoin d'être informaticien pour faire évoluer le procédé, i.e. pour l’éduquer.
Possibilité pour l'utilisateur de voir et vérifier tout ce que le procédé a appris et comment il l'a compris. Ceci autorisant à l'utilisateur d'avoir un contrôle total sur le savoir de son système - point particulièrement important en cette époque.
Possibilité de corriger aisément ladite compréhension du procédé. Il suffit de rappeler la séquence mal comprise sous sa forme IG (le texte avec ses IG) et de modifier la position ou le sens des IG erronées. Le système ré apprendra alors la séquence avec la nouvelle compréhension Universel dans son principe (indépendant de la langue traitée) et en conséquence pas de dictionnaire ni de règles liées à la langue traitée et d'autres caractéristiques spécifiques mais aussi plusieurs langues peuvent cohabiter simultanément dans le procédé.
Ceci est une différence fondamentale - Dans les exemples de l’état de l’art, les systèmes ou procédé décrits requièrent la pré-connaissance des langues ou un accès à un dictionnaire à distance (vocabulaire et éléments de structure sémantique soit des centaines de milliers d'instances par langue) pour fonctionner.
Alors que le présent procédé ne pré-connaît que quatre classes IG pour structurer sémantiquement les textes qui lui sont soumis et ce quelque soit la langue utilisée ! Sa connaissance se construisant à partir de sa connaissance précédente, ie "Au fil de l'eau" et en fonction des besoins. L'interprétation se faisant temps réel.
Pas de compilation nécessaire pour fonctionner ni aucune opération de type programmation, figeant le système.
Un procédé rendu extrêmement léger par cette méthode, lui permettant de fonctionner avec des ressources très limitées, lui permettant alors d'être embarque directement dans la machine sans moyens de communication extérieurs nécessaires.
Par exemple et pour le cas simple d'une petite voiture décrit ci-après, la présente méthode ne nécessitera qu'une trentaine d'instances dans la base de données.
Le procédé en introduisant dans la séquence des classes particulières (réservées), au nombre de quatre, appelées classes IG, permet de matérialiser la façon dont est comprise une séquence par le système, et permet à l'utilisateur de « voir » cette compréhension, ces classes IG permettent également à l'utilisateur d'éventuellement corriger aisément ladite compréhension.
L’invention est avantageusement mise en oeuvre selon les modes de réalisation et les variantes exposées ci-après, lesquelles sont à considérer individuellement ou selon toute combinaison techniquement opérante.
Dans un mode de réalisation, la mise à jour de la table des fonctions Dep à l’étape b) est déterminée selon les conditions suivantes : si une classe fonction amont s’applique à un premier nombre amont correspondant au nombre de récurrence de ladite classe fonction amont des classes Généralisées amont de la base de données, et que ladite classe fonction amont s’applique à un deuxième nombre amont correspondant au nombre de récurrence desdites classes Généralisées qui sont des classes fonctions avales, et dont ledit deuxième nombre amont est au moins supérieur à la moitié du premier nombre, alors la classe fonction amont est une classe fonction Dep amont,
si une classe fonction avale s’applique à un premier nombre aval correspondant au nombre de récurrence de ladite classe fonction avale des classes Généralisées avale de la base de données, et que ladite classe fonction avale s’applique à un deuxième nombre aval correspondant au nombre de récurrence desdites classes Généralisées qui sont des classes fonctions amont, et dont ledit deuxième nombre aval est au moins supérieur à la moitié du premier nombre, alors la classe fonction avale est une classe fonction Dep avale.
Cette disposition permet au procédé la mise à jour de la table des fonctions Dep, et ainsi de fonctionner sans avoir de préconnaissance de celle-ci. Dans un mode de réalisation, à l’étape b) de dichotomie, le procédé comporte les éléments suivants : si une classe fonction amont est antérieure dans une séquence à une classe fonction avale, il est évalué le rapport hiérarchique entre la classe fonction amont et la classe fonction avale comme étant :
si ladite classe fonction amont s'applique à un nombre amont correspond au nombre de récurrence de ladite classe fonction amont des classes Généralisées amont de la base de données dans lesquelles les classes paramètre sont des classes Généralisées avale dont la fonction est ladite classe fonction avale, et que ladite classe fonction avale s'applique à un nombre aval correspond au nombre de récurrence de ladite classe fonction avale des classes Généralisées avale de la base de données dans lesquelles les classes paramètre sont des classe Généralisées amont dont la fonction est ladite classe fonction amont, et que : si le nombre amont est supérieur au nombre aval alors ladite classe fonction amont est une hiérarchiquement dominante sur ladite classe fonction avale, si le nombre aval est supérieur au nombre amont alors ladite classe fonction avale est une hiérarchiquement dominante sur ladite classe fonction amont,
sinon il n’y a pas de rapport hiérarchique entre ladite classe fonction amont et ladite classe fonction avale,
Ladite évaluation permet au procédé : soit la mise à jour de la table des rapports hiérarchiques entre les fonctions, soit à l'étape b) de dichotomie et si réalisée en temps réel, de se substituer à la table des rapports hiérarchiques, et ainsi de fonctionner sans avoir de préconnaissance de ladite table de rapports hiérarchiques.
Dans un mode de réalisation, à l’étape b) de dichotomie, le procédé comporte les éléments suivants :
il est défini également un rapport hiérarchique pour une liste de classe fonction amont et une liste de classe fonction avale, un nombre amont de liste étant alors obtenu en cumulant les nombres amonts pour chacun des couples constitués d’une classe fonction amont appartenant à la liste de classe fonction amont et d’une classe fonction avale appartenant à la liste de la classe fonction avale, et le nombre aval de liste étant alors obtenu en cumulant les nombres avals pour chacun des couples constitués d’une classe fonction amont appartenant à la liste de classe fonction amont et d’une classe fonction avale appartenant à la liste de la classe fonction avale,
si ledit nombre amont de liste est supérieur au nombre aval de liste, alors : ladite liste de classe fonction amont est une hiérarchiquement dominante sur ladite liste de classe fonction avale,
si le nombre aval de liste est supérieur au nombre amont de liste alors ladite liste de classe fonction avale est une hiérarchiquement dominante sur ladite liste de classe fonction amont, sinon il n’y a pas de rapport hiérarchique entre ladite liste de classe fonction amont et ladite liste de classe fonction avale, si une classe fonction amont est antérieure dans une séquence à une classe fonction avale et qu'il n’y a pas de rapport hiérarchique directement entre ladite classe fonction amont et ladite classe fonction avale et que l'une ou les deux sont des classe fonctions ParDep, alors il est évalué le rapport hiérarchique de la liste des classes fonctions ParDep amont de la même classe fonction Dep avale de ladite classe fonction amont si celle-ci est une classe fonction ParDep et de la liste des classes fonctions ParDep avales de la même classe fonction Dep amont de ladite classe fonction avale si celle-ci est une classe fonction ParDep,
L'application de cette disposition, qui sous-entend la stationarité/constance des hiérarchies pour toutes les fonctions Pardep de la même fonction Dep vis-à-vis d'autres fonctions, permet au procédé d'augmenter les dichotomies conformes à la compréhension adéquate d'une séquence.
Dans un mode de réalisation, à l'étape b)
si une classe fonction amont est antérieure dans une séquence à une classe fonction Dep également amont, il est évalué le rapport hiérarchique de la classe fonction amont et de la liste de toutes les classes fonctions ParDep avales de la classe fonction Dep amont,
et dans lequel à l'étape b) il est rajouté s’il s’agit d'une fonction amont l'option suivante dans la détermination de la position de fin du paramètre de ladite fonction amont :
soit à la position précédent l'expression simple d'une classe fonction Dep amont et de hiérarchie dominante sur ladite classe fonction amont, si une classe fonction avale est postérieure dans une séquence à une classe fonction Dep également avale, il est évalué le rapport hiérarchique de la classe fonction avale et de la liste de toutes les classes fonctions Pardep avales de la classe fonction Dep avale,
et dans lequel à l'étape b) il est rajouté si il s’agit d'une fonction avale l'option suivante dans la détermination de la position de début du paramètre de ladite fonction avale :
soit à la position suivant l'expression simple d'une classe fonction Dep avale et de hiérarchie dominante sur ladite classe fonction avale.
L'application de cette disposition anticipe l'apparition d'une fonction ParDep avale postérieure dans la séquence à une fonction amont et autorise l'application de la hiérarchie de ladite fonction amont avec les fonctions Pardep avales de la fonction Dep amont, et en conséquence augmente la capacité du procédé à prédire la façon dont doit être dichotomisée donc comprise une nouvelle séquence.
Dans un mode de réalisation, à l’étape c), si la classe généralisée est connue, il est mis à jour son expression classe et son sens. Ainsi, pour chaque classe Généralisée la mise à jour va permettre d'une part de corriger la compréhension d'une séquence en utilisant les classes IG directement dans la séquence, mais aussi d'appliquer les hiérarchies les plus récentes et ainsi de corriger des erreurs de compréhension de séquences précédemment apprises. Le système pourra donc évoluer constamment.
Dans un mode de réalisation, le deuxième nombre amont est au moins supérieur aux deux tiers du premier nombre et le deuxième nombre aval est au moins supérieur aux deux tiers du premier nombre.
Cette disposition en augmentant le seuil de décision de la loi majoritaire dans la définition des classes fonction Dep, réduit les fausses interprétations de fonction Dep et en conséquence les erreurs de dichothomies et donc de compréhension, et ce au prix d'un nombre de séquences d’apprentissage supplémentaires.
Dans un mode de réalisation, à l'étape b) de dichotomie lors de la recherche de classes fonctions dans la séquence, ladite étape b) comporte en outre que si une classe fonction est trouvée dans la séquence et que l'expression IG de ladite classe fonction contient d'autres classes fonction alors ladite classe fonction est traitée en priorité sur lesdites autres classes fonction.
Cette disposition en privilégiant les fonctions dont les expressions simples sont les plus grandes permet au procédé de bien considérer dans une séquence des classes fonctions étant elles-mêmes des classes généralisées et en conséquence améliore la capacité de compréhension du procédé. De tels cas sont fréquents dans certaines langues.
Dans un mode de réalisation :
- à l’étape a) de prétraitement, la base de données comporte également une sixième classe réservée,
ladite sixième classe réservée est une classe fonction avale et désigne toute classe fonction Dep comme fonction d'équivalence dès lors que ladite classe fonction Dep se trouve être paramètre dans une classe généralisée dont la fonction est la sixième classe réservée, ainsi toute classe paramètre d'une classe généralisée dont la fonction est la classe fonction ParDep d'une classe fonction Dep et d'équivalence a pour classe équivalente la classe paramètre de la classe fonction Dep dans la classe généralisée fonction ParDep, dans l’étape d) d’exécution, s’il est rencontré dans la séquence une classe et que une classe généralisée est connue dont le paramètre est ladite classe et la fonction est une classe fonction ParDep d'une classe fonction Dep et d'équivalence, alors l'expression LIG de ladite classe est substituée dans la séquence par l'expression LIG de sa classe équivalente, l'itération reprenant au début de ladite classe,
l'expression LIG de ladite classe équivalente débute par le numéro de ladite classe et est obtenue par itération en faisant suivre tous les numéros des classe généralisées de l'expression LIG de ladite classe par le numéro de la première classe IG, puis du numéro de la première classe de l'expression classe de la classe généralisée, puis du numéro de la deuxième classe IG si la classe est une classe généralisée amont ou du numéro de la troisième classe IG si la classe est une classe généralisée avale, puis du numéro de la deuxième classe de l'expression classe de la classe généralisée, puis du numéro de la quatrième classe IG.
L'ensemble de ces dispositions permet de transformer toute classe en une autre classe et en particulier une séquence représentant un ordre rédigé en langue naturelle en une classe exécutable par une machine.
Dans un mode de réalisation, à l’étape b) de dichotomie s’il n’y a pas de rapport hiérarchique entre deux classes fonctions, il est recherché pour chacune des deux classe fonctions la liste des classes fonctions apparentées dans la base de données puis il est comparé la récurrence de chaque classe fonction pour évaluer la hiérarchie entre ces deux listes, la liste des classes apparentées a une classe étant définie comme la liste des classes qui sont une classe paramètre dans des classes généralisées et dont les classes fonctions s’appliquent également à ladite classe dans une classe généralisée.
Cette disposition permet de nommer et de catégoriser des classes partageant divers caractéristiques et ainsi en nommant une nouvelle classe de la même catégorie, de lui faire bénéficier des hiérarchies déjà apprises pour les autres classes dans la catégorie.
Dans un mode de réalisation, à l'étape a) de prétraitement si il est rencontré le marqueur des classes réservées suivi d'un numéro, alors cette expression est substituée dans la séquence par le numéro de la classe de même numéro. Cette disposition permet de faire référence à toute classe connue de la base de données dans une séquence.
BREVE DESCRIPTION DES FIGURES
D’autres avantages, buts et caractéristiques de la présente invention ressortent de la description qui suit faite, dans un but explicatif et nullement limitatif, en regard des dessins annexés, dans lesquels :
- la figure 1 , sous forme de logigramme, les étapes mises en oeuvre dans un mode de réalisation particulier du procédé objet de la présente invention,
- les figures 2 à 5, sous forme de logigramme, représente les détails des étapes mises en oeuvre dans un mode de réalisation particulier du procédé objet de la présente invention.
- la figure 6 représente un schéma de reconstitution d’une séquence LIG d’une classe.
DESCRIPTION D’EXEMPLES DE REALISATION DE L’INVENTION
Dans un exemple ci-dessous les termes suivants sont utilisés :
Plusieurs termes vont être employés pour la suite, nous donnons ici leurs définitions :
« go straight » en terminologie anglophone pour « vas tout droit » en français.
« is a verb of équivalence » en terminologie anglophone pour « est un verbe d’équivalence » en français.
« make a Uturn and stop » en terminologie anglophone pour « fait demi tour et arrête toi » en français.
« means » en terminologie anglophone pour « signifie » en français.
« move back » en terminologie anglophone pour « marche arrière » en français.
« north » en terminologie anglophone pour « nord » en français.
« quickly » en terminologie anglophone pour « rapidement » en français. « turn left » en terminologie anglophone pour « tourne à gauche » en français.
« turn right » en terminologie anglophone pour « tourne à droite » en français. « setengine » en terminologie anglophone pour « sens moteur » en français.
« setwheel » en terminologie anglophone pour « position roue(s) » en français.
« south » en terminologie anglophone pour « sud » en français.
Pour la suite, ce qu’il y a entre accolade : {...} est ce qui est saisi sur un ordinateur et aussi les expressions des classes.
Notion de Séquence
Il est défini une séquence comme étant une série d'éléments mis et traités les uns à la suite des autres. Une séquence sera ici comprise comme une suite de nombres. Un ordre tel que {turn right} qui est une suite de caractères est en fait une suite de nombre - codé via la table Ascii (acronyme de American Standard Code for Information Interchange en terminologie anglophone pour Code américain normalisé pour l'échange d'information) ou Uni code (standard informatique qui permet des échanges de textes dans différentes langues) et donc {turn right} est bien une séquence.
Le procédé a pour fonction essentielle de reconnaître et de traiter des séquences.
Notion de Classe
Une base de données conservera les séquences traitées par la méthode. Le procédé affectera un numéro (No) à chacune de ce ces séquences, ce No est appelé No de classe ou plus, simplement « classe »
Une classe peut également s'écrire sous forme d'autres classes. En d'autres termes une séquence peut s'écrire à partir de séquences déjà connues.
Ex : Si on a dans la base deux classes C1 ={turn } et C2={right} alors la classe C3={turn right} peut également s'écrire C3=={C1 C2}
{C1 C2} étant la séquence constituée de la classe C1 et de la classe C2.
Notion de Fonction et Paramètre
Dans les séquences, les classes pourront jouer un rôle de Fonction ou de Paramètre.
Ex Si nous rajoutons dans la base la classe C4={left} alors la classe CS={turn left}
pourra également s'écrire CS=={C1 C4} Nous pourrons apprendre alors au procédé que C1 = {turn } est une fonction qui a deux paramètres :
C2={right} dans la classe C3 et C4={left} dans la classe CS
Notion de Mots Réservés
Certaines séquences ont une signification particulière connue de la méthode.
Nous désignerons ces séquences comme « Mots Réservés » (Rmots)
Pour les reconnaître, et par convention, ils commencent toujours par le caractère « ^ ».
Comme pour les autres séquences il est affecté à ces Mots Réservés un No de classe.
Ces Classes Réservées pourront être utilisées dans les séquences et sont immédiatement reconnues par le procédé lors de la phase de prétraitement.
Ex : préalablement, nous avons appris au procédé qu’il existe quatre classes réservées :
CR0={^[} CR1 ={^»} CR2={^«} et CR3={^]}
Ces quatre classes connues du procédé nous permettre d'établir les rôles (Fonction ou Paramètre) joués par les classes dans une séquence.
Il est également utilisé pour CRO : la première classe réservée {^[}, CR1 : la deuxième classe réservée {^»}, CR2 : la troisième classe réservée {^«}, CR3 : la quatrième classe réservée {^j}.
Les figures sous forme de logigramme servent de support à la description suivante.
Notion de Classe Généralisée
Pour apprendre au procédé l'ordre {turn right} dans lequel {turn } joue le rôle de fonction et {right} joue le rôle de paramètre, nous saisissons directement la séquence : {^[turn ^»right^]}
Le procédé reconnaît dans la séquence les séquences des Mots Réservés utilisés et leur substitue par les numéros (Nos) de classes correspondantes. La séquence sera alors {CROturn CR1 leftCR3} (étape 0)
Puis le procédé identifie sur la base (ou créera si inconnues) les classes {turn } et {right} soit C1 et C2, {turn } étant la séquence comprise entre CRO et CR1 et {right} étant la séquence comprise entre CR1 et CR3. Puis le procédé identifie sur la base (ou créera si inconnues) la classe {turn right} soit C3, {turn right} étant la séquence de C1 + la séquence de C2. Puis le procédé conservera de plus sur la base pour la classe C3, son expression en terme de classe soit {C1 C2}, et son sens qui indique où se trouve la fonction dans l'expression {C1 C2}, ici « Am » (pour amont) puisque nous avons utilisé {^»}, en effet dans {C1 C2} la classe amont C1 est la fonction et en conséquence la classe avale C2 est le paramètre.
L'exemple décrit dans ce texte suppose pour la langue utilisée une lecture de la séquence de la gauche vers la droite
Cette étape est assurée par l'étape identification-création, (étape 2) dont la mission est d'identifier sur la base de données, ou de créer si inconnues, toutes les classes composantes délimitées par les classes CRO à CR3 dans la séquence.
La classe C1 ={turn } est alors maintenant connue par le procédé comme classe fonction Amont dans C3.
Si maintenant nous saisissons directement la séquence : {turn left} (sans faire mention des classes réservées CRO à CR3)
Le procédé va rechercher dans cette séquence s'il peut trouver des fonctions connues (étape 1/1 ). Il trouve dans cette séquence la classe C1 ={turn } précédemment apprise et déjà connue comme classe fonction Amont dans la classe C3. Par construction, le procédé va généraliser le rôle de C1 dans C3 en considérant que C1 peut également être une classe fonction Amont dans {turn left}. En conséquence, le procédé ajoute de lui-même les classes réservées CRO à CR3 dans la séquence comme pour C3. Notre séquence devient alors : (étapes 1/2 et 1/3) {^[turn ^»left^]}
Cette étape est assurée par l’étape de Dichotomie (étape 1 ) dont la mission est d'insérer dans la séquence qu'il a à traiter les classes CRO à CR3 en s'appuyant sur les fonctions connues de la méthode. Puis le procédé va enchaîner sur l'apprentissage de cette séquence exactement comme ci-dessus (voir étape 2).
La base de données est complétée par la séquence C1 ={turn } C4={left}
C5={turn left} et C5=={C1 C4} avec le Sens=Am
On a donc dans le procédé l'enchaînement des étapes suivantes : Etape 0, prétraitement, étape 1 : dichotomie, étape 2 : identification- création. Les classes C3 et C5 sont désignées comme des « Classes Généralisées » ou classes G. La notion de généralisation consistant à répliquer dans la généralité un comportement constaté dans un cas pris comme exemple, en l'occurrence le rôle de fonction que peut avoir une classe.
Les classes G disposent dans la base de données en plus de leur expression simple, d'une expression en terme de classe, toujours constituée de deux classes, et d'un sens. Les classes G étant toujours constituées d'une fonction et d'un paramètre, le sens indiquera où se trouve la fonction dans l’expression en terme de classe. Si le sens est Am la fonction sera au début et le paramètre en fin et réciproquement.
Une classe G peut donc s'écrire comme {^[Classe fonction^»Classe paramètre^} pour une classe G Amont Ou comme {^[Classe paramètre^«Classe fonction^]} pour une classe G Avale.
Les classes CR0={^[} CRI={^»} CR2={^«} CR3={^]} seront appelées Classes IG (classes d'indication G), elle définissent les classes G dans une séquence. Les classes fonction et paramètres pouvant elles-mêmes être des classes G, il en résulte que les classes IG permettent d'établir la dichotomie fonctionnelle d'une séquence. Cette dichotomie fonctionnelle traduit la façon dont le procédé a compris la séquence.
Parmi les deux éléments d'une classe G, la fonction sera celui qui s'applique à l'autre.
Ex: le sens commun veux que dans {turn right} c'est bien {turn } qui s'applique à {right} et non l'inverse.
Notion de Fonctions Dépendantes
Le procédé sait reconnaître certaines fonctions qui permettent de relier deux classes.
Soit la séquence : {^[Cx^«^[F0^»Cy^]^j} (1 )
Dans cette séquence Cx et Cy sont deux classes quelconques jouant le rôle de paramètre. Ces deux classes sont reliées dans la séquence par la fonction F0.
On constate que dans cette séquence :
F0 est une fonction Amont dans la classe G {^[F0^»Cy^j} que la classe G {^[F0^»Cy^j} est elle même une fonction, Avale cette fois dans notre séquence (1 ) Une Classe étant fonction dans un sens et dont les classes G utilisant cette classe comme fonction étant également fonctions mais dans le sens inverse est la caractéristique des fonctions dites Dépendantes ou « Fonctions Dep ».
Si le procédé détecte une majorité de séquences comme (1 ) ci-dessus pour une fonction FO alors elle va généraliser ce comportement (le rôle de fonction de FO et le rôle de fonction de sens inverse à FO des classes G utilisant FO) et considérera que FO est une Fonction Dep.
C'est-à-dire que :
- si FO est une classe fonction Amont Dep alors toute classe G utilisant FO est automatiquement une classe fonction Avale, et réciproquement :
si FO est une classe fonction Avale Dep alors toute classe G utilisant FO est automatiquement une classe fonction Amont : la séquence réciproque de (1 ) ci-dessus étant alors :
{^[^[Cx^« F0^]^» Cy^]} (2)
Autre exemple :
Nous supposerons ici :
Avoir initialisé le Rmot {^SETWHEEL}
Qu'aucune fonction n'est connue de la méthode
Si nous saisissons la séquence :
{^[turn right^«^[ means ^»^SETWHEEL1 ^]^]}
L’étape de dichotomie ne modifie pas la séquence (aucune fonction n'est connue).
Une fois cette séquence apprise par l'identificateur-Créateur (étape 2), le procédé va savoir que { means } est une fonction Amont Dep et en conséquence si nous saisissons ensuite :
{turn left means ^SETWHEEL-1 }
L’étape de dichotomie reconnaît dans la séquence la fonction { means } (étape 1 /1 ) apprise précédemment et va insérer dans cette séquence les Classes Réservées CRO à CR3 correspondant à une situation de Fonction Amont Dep. Ce qui donnera : (étapes 1/2 et 1/3)
{^[turn left^«^[ means ^»^SETWHEEL-1 ^]^]}
Séquence qui est ensuite apprise normalement par l'Identificateur- Créateur (étape 2) Pour la suite, on appellera « classe GDep » pour désigner dans la suite ce type de séquences, c'est-à-dire qui correspondent à la forme (1 ) ou (2)
Pour la suite et par convention les espaces séparant les mots d'une langue naturelle dans une séquence sont dans une classe généralisée toujours portés exclusivement par la fonction (compris/inclus dans l'expression de la fonction) et non par le paramètre.
Les Classes Exécutables et le Mot Réservé ^ECE
Pour piloter une machine le procédé doit reconnaître les classes/séquences qui doivent appeler les programmes de contrôle de la machine.
Nous avons défini dans le procédé le Mot Réservé {^ECE} qui est une classe fonction Avale pour permettre cette reconnaissance
Par construction, le procédé considère comme classe Exécutable : toute classe C « marquée » par le Rmot ^ECE c'est-à-dire {^[C^«^EXE^]} a été appris
Ou
Toute classe G dont la fonction est marquée par le Rmot ^ECE c'est a dire toute classe G =^[Fx^»Cx^] ou ^[Cx^«Fx^] telle que {^[Fx^«^EXE^]} a été appris. Ces classes G exécutables possèdent un paramètre (ou classe paramètre).
Ou
Toute classe GDep dont la Fonction Dep est marquée par le Rmot ^EXE
c'est-à-dire toute classe GDep={^[Cx^«^[Fx^»Cy^]^]} ou réciproque telle que {^[Fx^«^EXE^]} a été appris. Ces classes GDep exécutables possèdent deux paramètres.
Le procédé dispose d'une étape « d’Exécution » (étape 3/3) qui reconnaîtra ces classes et assurera leur exécution.
Autre exemple :
Supposons que nous ayons connecté au procédé un petit véhicule pour lequel nous pouvons orienter les roues avec un programme de commande de roue et avec le paramètre :
{1 } pour mettre les roues vers la droite
{-1 } pour mettre les roues vers la gauche {0} pour mettre les roues droites
^SETWHEEL est supposé avoir été initialisé dans les Mots Réservés et lié dans l'algorithme d'Exécution au programme de commande des roues du véhicule.
Nous établirons comme Fonction Amont le Rmot ^SETWHEEL en saisissant : {^[^SETWHEEL^»1 ^]}
Nous marquerons ^SETWHEEL par ^EXE pour rendre exécutable les classes G utilisant la fonction ^SETWHEEL. Nous saisirons donc :
{^[^SETWHEEL^«^EXE^]}
En conséquence la saisie de
{^SETWHEEL1 }
- est compris par le procédé comme {^[^SETWHEEL^»1 ^]} (étape 1 )
-est identifiée car déjà créée ci-dessus soit Cx (étape 2)
-est exécutée car étant reconnue comme classe exécutable (étape 3/3) En effet Cx est une classe G dont la fonction ^SETWHEEL est
« marquée » par ^EXE l’étape d'exécution appelle la commande des roues avec le paramètre {1 } ce qui met les roues vers la droite.
De la même manière, {^SETWHEEL0} met les roues droites et {^SETWHEEL-1 } met les roues vers la gauche.
L’étape d'exécution étant appelé par le procédé lui-même appelé après la Dichotome et l'Identification-Création. L'enchaînement des étapes est donc : étape 0 : prétraitement, étape 1 : dichotomie, étape 2 : identification-création, étape 3 : application 3, exécution 3/3
Les Fonctions d'Équivalence et le Mot Réservé ^EQV
Le procédé ayant pour mission de convertir un ordre en une séquence exécutable, il doit identifier les séquences à convertir et leur séquence équivalente.
Pour réaliser ceci, il a été défini dans le procédé le Mot Réservé {^EQV} Fonction Avale qui permet, comme précédemment de « marquer » des fonctions. Une fois marquée par ^EQV une fonction reconnue par le procédé comme fonction d'équivalence.
Dans ce cas les fonctions marquées sont Dep et permettent ainsi de relier une séquence à sa séquence équivalente. Les classes G Dep et d'Equivalence seront de la forme : {^[C^«^[Feqv^»Ceqv^]^}} avec {^[Feqv^«^EQV^]} connu/appris et dans lesquelles
Feqv est la Fonction ici Am et Dep et d'équivalence
C est la classe pouvant être convertie
Ceqv est la classe équivalente a C
Le procédé dispose d'une étape d'équivalence qui recherchera sur la base pour les classes C qui lui sont soumises, leur classe équivalente Ceqv. (étape 3/2)
Cet algorithme est appelé dans l'algorithme d'Application avant l'Exécution
L'enchaînement des Algorithmes étant donc le suivant :
étape 0 : prétraitement, étape 1 : dichotomie, étape 2 : identification- création, étape 3 : application 3, équivalent 3/2, exécution 3/3
Exemple : Nous devons en première instance apprendre au procédé une équivalence pour une classe Nous reprenons l'exemple précédent en saisissant :
{^[turn right^«^[ means ^»^SETWHEEL1 ^]^]} (1 )
Ceci établit { means } comme Fonction Amont Dep
Nous établissons { means } comme Fonction d'équivalence en la « marquant » avec ^EQV
Nous saisirons alors :
{^[ means ^«^EQV^]}
La séquence (1 ) ci-dessus est maintenant bien considérée par l’étape d’équivalence et donc par le procédé comme une classe G Dep et d'Équivalence.
Si maintenant nous saisissons :
{turn right}
L’étape de dichotomie n'a pas d'effet ici (il n'y a pas de fonction dans la séquence) (étape 1 )
L’étape d’identification-création trouve la classe car créée lors de (1 ) ci- dessus soit Cy (étape 2)
La séquence est donc maintenant {Cy} (étape 3/1 )
L'étape d’Application/d’exécution débute l'itération pour Cy (étape 3/1 ) Appelle de l’étape d'Équivalence pour Cy (étape 3/2) ce dernier trouve comme classe équivalente Cx={^[^SETWHEEL^»1 ^]} la séquence {Cy} est donc remplacée par la séquence {Cx^[^SETWHEEL^»1 ^]} (voir séquences LIG ci- après).
L'étape d'application/exécution reprend alors pour cette nouvelle séquence
L'étape d'Application débute l'itération pour Cx (étape 3/1 )
Appelle l'étape d'Équivalence pour Cx l'étape d'Équivalence ne connaît pas d'équivalence pour Cx (étape 3/2)
Appelle l'étape d'Éxécution pour Cx (3/3)
Ce qui mettra les roues vers la droite !
II suffit alors de saisir les équivalences :
{turn left means ^SETWHEEL-1 } et {go straight means ^SETWHEEL0} pour que les ordres {turn left} et {go straight} soient maintenant correctement exécutés.
Précisions sur les Séquences -les formats IG et LIG
Au cours des différentes étapes 0/1/2 les séquences vont évoluer.
Voyons comment :
en étape 0 Prétraitement Séquence
La séquence reçue est de type « String » (chaîne de caractères) chaque caractère est codé soit :
- sur 8 bits si le procédé travaille en Ascii étendu ou Utf8
sur 12 ou 16 bits si le procédé travaille en Utf12 ou Utf16 et plus généralement sur autant de bits qu'il sera nécessaire pour couvrir tous les besoins en caractères des langues envisagées.
Par construction dans cet exemple d'application les premières classes sont réservées aux caractères. Les classes non caractères venant ensuite. Et ce afin de faire cohabiter dans une même séquence des caractères et des classes (Rmots par exemple) dont le No se trouvera au-delàs de 255 (cas ascii), la séquence est binarisée classiquement sur 32 bits pour les ordinateurs actuels (étape 0/1 ). Le nombre maximum de classes étant alors (2^31 -1 ) (les Nos de classes sont toujours positifs).
Les séquences traitées par le procédé sont en fin de la Réception Séquence (étape 0) et pour la suite des chaînes de « Larges Integers» en terminologie anglophone pour « grands entiers » en français, Lors du prétraitement, les séquences correspondant à des mots réservés sont remplacées par leur numéro de classe No.
en étape 1 Dichtotomie
La mission du Dichotomiseur est d'insérer dans la séquence à traiter, les classes IG (CRO à CR3) en s'appuyant sur les fonctions
déjà connues du procédé connu dans la base de données trouvées dans la séquence
et ne participant pas déjà à une classe G dans la séquence.
Exemple 1 : Si la séquence à traiter est {^[turn ^»right^]}, en supposant {turn } déjà connue en tant que classe fonction Amont. La seule ou classe fonction trouvée sera {turn } mais elle participe déjà a une classe G, en effet elle est précédée par CR0={^[} et suivie par CR1 ={^»}
Le Dichotomiseur n'a donc pas à traiter cette fonction et donc ne modifie pas la séquence.
Exemple 2 : Si la séquence à traiter est :
{^[turn right^«^[ means ^»^SETWHEEL1 ^]^]} en supposant {turn } et {^SETWHEEL} déjà connues comme classe fonctions Amont.
La première fonction trouvée sera {turn }, elle ne participe pas comme fonction a une classe G et peut donc être traitée (étape 1/1 ). La portée de son paramètre s'arrête a CR2={^«}, en effet l'entité à traiter est le paramètre :
{turn right}, l'intrication des classes G étant interdite (étape 1/2)
Le dichotomiseur transforme {turn right} en {^[turn ^»right^]} dans la séquence (étape 1/3).
Ceci nous donne la séquence :
{^[^[turn ^»right^]^«^[ means ^»^SETWHEEL1 ^]^]}
Le Dichotomiseur reprendra ensuite la recherche de fonction (étape
1/1 ).
Il trouvera {turn } qui est déjà exprimée et participe comme fonction a une classe G et donc enchaîne : il ne considérera pas { means ^SETWHEEL1 } ni { means } car non connues a ce point comme fonction (la séquence n'a pas encore été créée, ceci étant fait à l'étape suivante (étape 2).
Il trouve {^SETWHEEL} qui n'est pas exprimée et peut donc être traitée exactement comme précédemment pour {turn } . L'entité à traiter étant cette fois le paramètre {^SETWHEEL1 } (étape
1/2).
{^SETWHEEL1 } est donc transformée dans la séquence en {^[^SETWHEEL^»1 ^]} (étape 1/3).
Le Dichotomiseur reprend la recherche de fonction et n'en trouvera plus de non exprimée.
Nous aurons donc en sortie du Dichotomiseur la séquence :
{^[^[turn ^»right^]^«^[ means ^»^[^SETWHEEL^»1 ^]^]^]} cette séquence fait état de la structure de la classe correspondante
Dans cet exemple le Dichotomiseur a reçu une séquence comportant déjà des classes IG.
Il a néanmoins complété la dichotomie de la séquence qui lui est soumise en prenant en compte toutes les fonctions connues du procédé présentes dans cette séquence.
Une séquence comportant les classes IG pour toutes les fonctions connues du procédé et présentes dans la séquence sera désignée comme « séquence IG ». Ce format de séquence est le format de sortie des séquences pour le Dichotomiseur. Ce sera également le format d'entrée des séquences pour l'algorithme d'Identification-Création.
en étape 2 Identification-Création
La mission de l’étape d’identification-Création est soit d'identifier (si connues) les classes composantes de la séquence (délimitées par les classes IG), soit de les créer sur la base de données.
Reprenons comme séquence à traiter la séquence IG précédente issue du Dichotomiseur:
{^[^[turn ^»right^]^«^[ means ^»^[^SETWHEEL^»1 ^]^]^]} (1 )
dans laquelle seule {turn } , {^SETWHEEL} et {1 } sont connues de la base. En effet, {1 } étant un caractère, il est par construction déjà connu ( {1 } sera la classe 49 dans les cas Ascii étendu, Utf8 ).
Cette séquence IG va être convertie graduellement, au fur et à mesure des identifications ou créations de classes, en séquence LIG dans laquelle :
Les classes G se verront rajouter leur No et ce AVANT leur classe CRO dans la séquence IG Exemple : soit Cz={^[Cx^»Cy^]} donnera la séquence LIG {Cz^[Cx^»Cy^]}
Les séquences des classes Non G se verront simplement substituées par leur No
Exemple : si Cx={turn } et Cy={right} sur la base pour
{^[turn ^»right^]} donnera {^[Cx^»Cy^]}
Le « L » de LIG vient de Lead class en terminologie anglophone pour « numéro de classe en tête » en français. En d’autres termes « séquence avec Lead and Indication G classes ». Sous ce format une séquence porte en elle même toutes les informations nécessaires à son Application/exécution (étape 3).
Une classe G ne pourra être créée que si l'on connaît déjà sur la base sa Fonction ET son Paramètre. En d'autres termes si un numéro No de classe leur a déjà été affecté. Les enchaînements de l’étape Dichotomiseur tiennent compte de ceci.
Appliqué a notre séquence (1 ) cela donnera
Début d'itération pour la classe CR0={^[} en 1 ère position dans (1 ) (étape 2/1 ). Il s’agit d'une classe G inconnue sur la séquence - en effet si elle était connue nous aurions une Lead Classe: {C^[ ... Et dont la Fonction et le Paramètre sont inconnus sur la séquence (même chose pas de lead classe pour ces derniers ). Nous sommes donc dans le cas de l'étape 2/7 -> Retour itération.
Suite d'itération pour la classe CR0={^[} en 2ème position dans (1 ) (étape 2/1 )
Nous sommes de même dans le cas de l'étape 2/7 : classe G inconnue sur la séquence dont la Fonction et le Paramètre sont également inconnus sur la séquence -> Retour itération.
Suite d'itération pour la classe {t} en 3ème position dans (1 ) (étape 2/1 )
Il s’agit d'une classe Non G (car non CRO et non suivie de CRO}
Non connue sur la séquence (car non suivie de CR1 ou CR2 ou CR3) Nous sommes dans le cas de l'étape 2/5. En conséquence
- Extraction de la séquence de classe : de la position courante (3) jusqu'au premier CR1 ou CR2 ou CR3 rencontré soit la séquence extraite {turn}
Recherche sur base de cette séquence- déjà connue soit Cx Substitue {turn } par Cx dans la séquence soit :
{^[^[Cx^»right^]^«^[ means ^»^[^SETWHEEL^»1 ^]^]^]} (2) et Retour itération
Suite d'itération pour la classe CR1 =(^») en 4ème position dans (2) (étape 2/1 )
Nous sommes dans le cas de l'étape 2/2 -> Retour itération
Suite d'itération pour la classe (r} en 5ème position dans (2) (étape 2/1 )
Il s’agit d'une classe Non G (car non CRO et non suivie de CRO}
Non connue sur la séquence (car non suivie de CR1 ou CR2 ou CR3) Nous sommes dans le cas de l'étape 2/5. En conséquence
Extraction de la séquence de classe : de la position courante (5) jusqu'au premier CR1 ou CR2 ou CR3 rencontré soit la séquence extraite { right}
Recherche sur base de cette séquence - Inconnue donc créée sur la base soit Cy
Substitue { right} par Cy dans la séquence soit :
{ ^[^[Cx^»Cy^]^«^[ means ^»^(^SETWHEEL^»1 ^]^]^]} (3)
et Retour itération
Suite d'itération pour la classe CR3=(^]} en 6ème position dans (3) (étape
2/1 )
Nous sommes dans le cas de l'étape 2/3. En conséquence nous reprenons l'itération en deuxième position - qui est la position du début de la classe G correspondant à la CR3 en sixième position et dans le cas d'absence de lead.
Suite d'itération pour la classe CR0=(^[} en 2ème position dans (3) (étape
2/1 )
Nous sommes dans le cas d'une classe G inconnue sur la séquence (pas de lead) dont la Fonction et le Paramètre sont connus (Cx et Cy) - c'est le cas de l'étape 2/6. En conséquence
Extrait la séquence de classe = séquence de la Fonction† séquence du paramètre soit
la séquence de classe={turn }+{right}={turn right} - identifie ou (dans notre cas ) Crée la séquence sur base soit Cz insère ce No (Cz) en amont de son CRO dans la séquence soit la séquence
{^[Cz^[Cx^»Cy^]^«^[ means ^»^[^SETWHEEL^»1 ^]^]^]} (4) et Retour itération pour la classe suivant la fin de la classe Cz soit la huitième position
Suite d’itération pour la classe CR2={^«} en 8ème position dans (4) (étape
2/1 )
De la même manière le procédé continue et créé tous les classes nécessaires et consituté la séquence LIG de la forme.
{Gs^[Cz^[Cx^»Cy^]^«Gî^[Cw^»Cu^[GR6^»Cv^]^]^]}
Avec : Cx={turn } Cy={right}, Cz={turn right}=={CxCy}Am,
CR6={^SETWHEEL}, Cv={1 }, Cu={^SETWHEEL1 }=={CR6Cv}Am,
Cw={ means } Cu={^SETWHEEL1 }, Ct={ means ^SETWHEEL1 }=={CwCu}Am, Cz={turn right}, Ct={ means ^SETWHEEL1 },
Cs={turn right means ^SETWHEEL1 }=={CzCt}Av
Les séquences LIG ont l'extrême avantage de linéariser la structure des classes (voir figure 6). En conséquence une itération sur les classes d'une séquence LIG permet de « balayer » toutes les classes impliquées dans la structure en partant des plus grandes et en respectant l'ordre chronologique.
Il est à noter que la 1 ère classe d'une séquence LIG sera toujours le No de classe de la séquence ! (Cs dans l'exemple ci-dessus).
Les Séquences LIG rendent compte de la façon dont le procédé a appris et compris une séquence.
Ces séquences sont très aisées à reconstituer à partir de la base de données.
Reconstitution de séquence LIG de classe
Soit une classe Cs dont nous voulons la séquence LIG (Nous reprendrons les données de l'exemple)
Nous démarrerons avec la séquence {Cs}
Itération sur les classes de la séquence (On ignore les classes IG: CRO à CR3)
- Traite la classe en X ème position ( Cs en 1 ère position) - Accède la base pour la classe (Cs)
Si la classe est Non G ->Suite itération
Si la classe est G (Cs est G car possède une expression classe et un sens)
Nous prenons son expression classe et son sens (soit {CzCt} et Av) Nous insérons dans cette expression les classes IG correspondant au sens pour former la séquence de classe (soit { ^[ Cz^«Ct^]})
Nous insérons dans la séquence après le No de classe cette séquence de classe (soit {Cs^[Cz^«Ct^]})
et Retour itération
- Traite la classe en Xème position ( Cz en 3eme position)
Accède la base pour la classe (Cz)
Si la classe est Non G ->Suite itération
Si la classe est G (Cz est G )
Nous prenons son expression classe et son sens (soit {CxCy} et
Am )
Nous insérons dans cette expression les classes IG correspondant au sens pour former la séquence de classe (soit {^[Cx^»Cy^]})
Nous insérons dans la séquence après le No de classe cette séquence de classe
(soit {Cs^[Cz^[Cx^»Cy^]^«Ct^]})
et Retour itération
Ainsi de suite jusqu’à la séquence LIG :
{Cs^[Cz^[Cx^»Cy^]^«Ct^ [Cw^»Cu^[CR6^»Cv^]^]^]}
Règles de bordure
L’étape de dichotomie pour pouvoir considérer une fonction identifiée dans une séquence doit respecter les régies de bordures suivantes :
Une fonction Amont Non Dep devra être au début de la séquence Ou immédiatement précédée de CR0={^[} ou de CR1 ={^»} ou de CR2={^«} (Une des trois premières classes IG).
Une fonction Avale Non Dep devra être en fin de la séquence Ou immédiatement suivie de CR1 ={^»} Ou de CR2={^«} Ou de CR3={^]} (Une des trois dernières classes IG).
Ces règles assurent la bonne chronologie dans la dichotomie et évitent des erreurs d'interprétation.
Exemple : nous supposons ici connaître {turn } comme fonction Amont. Dans la séquence {make a Uturn and stop} la fonction {turn } ne sera pas considérée dans cette séquence pour non-respect de la règle de bordure énoncée ci-dessus. Une fonction Amont (Dep ou non Dep) doit ne pas être en fin de séquence ou immédiatement suivie de CR1 ={^»} ou de CR2={^«} ou de CR3={^]} (Une des trois dernières classes IG).
Une fonction Avale (Dep ou non Dep) devra ne pas être en début de séquence ou immédiatement précédée de CR0={^[} ou de CR1 ={^»} ou de CR2={^«} (Une des trois premières classes IG).
Ces règles garantissent que le paramètre de la fonction est existant (non nul).
Une fonction Amont précédée de CR0={^[} et suivie de CR1 ={^»} participe déjà a une classe G et donc ne sera pas considérée. De la même manière pour une fonction Avale précédée de CR2={^«} et suivie de CR3={^]}.
Notion de Hiérarchie
Nous désignerons par Hiérarchie la relation qu'il peut exister entre deux fonctions de sens opposé.
Soit F1 une fonction Amont, F2 une fonction Avale et Pi un paramètre
S’il existe sur la base de données une (ou plusieurs) classe(s) Ci de la forme
Ci={^[F1 ^»^[Pi^«F2^]^]} alors le procédé en déduit qu'il existe une hiérarchie dominante de F1 sur F2 . Hiérarchie que nous écrirons F1 >>> F2
Si à contrario, il existe sur la base une (ou plusieurs) classe(s) Cj de la forme Cj={^[^[F1 ^»Pj^]^«F2^]} alors le procédé en déduit qu'il existe une hiérarchie dominante de F2 sur F1. Hiérarchie que nous écrirons F1 <<<F2
Si il existe simultanément Ni classes de la forme Ci et Nj classes de la forme Cj, le procédé prend la hiérarchie la plus souvent connue. C'est-à-dire si Ni>Nj. Le procédé prend F1 >>> F2 et réciproquement.
S’il existe une hiérarchie avec une fonction qui est classe G d'une fonction Dep alors le procédé applique la même hiérarchie pour toutes les autres fonctions également classes G de la même fonction Dep (mais avec un paramètre pouvant être différent).
Ces hiérarchies ont une utilité directe et essentielle dans la dichotomie d'une séquence et permettent au module de dichotomie de déterminer la portée du paramètre applicable à une fonction. En effet, le paramètre d'une fonction non dominante ne peut contenir une fonction qui lui est dominante
Exemple : Si nous avons soumis au procédé la séquence suivante :
{^[^[turn ^»right^]^«^[ means ^»^[^SETWHEEL1 ^]^]^]} (5)
Le procédé a alors appris :
Que {turn } est une fonction Amont
- Que { means } est une fonction Amont et Dep
Qu'il existe une hiérarchie {turn }<<<{ means ^SETWHEEL1 } et qu'il existe donc une hiérarchie {turn }<<<{ means xxx} dans lequel xxx est un paramètre quelconque de { means}
Que {^SETWHEEL} est une fonction amont
Si nous saisissions ensuite la séquence :
{turn left means ^SETWHEEL-1 }
L’étape de dichotomie trouve la fonction {turn } avec comme paramètre tout ou partie de {left means ^SETWHEEL-1}
la dichotomie recherche les fonctions dans ce paramètre et trouve { means } qui est une fonction Amont Dep et dont les classes G sont automatiquement des fonctions Avales et dont nous connaissons un exemple de hiérarchie dominante sur {turn } dans la séquence (5).
Le procédé limite en conséquence la portée du paramètre à {left}. Après insertion des classes IG.
la séquence sera :
{^[turn ^»left^] means ^SETWHEEL-1 }
La fonction acceptable suivante sera { means } fonction Amont avec comme paramètre tout ou partie de {^SETWHEEL-1 }
L’étape de dichotomie ne trouve pas dans ce paramètre de Fonction avale, en conséquence il ne va pas réduire la portée du paramètre et va insérer les classes IG telles que :
{^[turn ^»left^]^[ means ^»^SETWHEEL-1 ^]} puis reprendra la recherche de fonctions pour cette séquence. Il trouvera {^[ means ^»^SETWHEEL-1 ^]} fonction Avale car { means } est une fonction Amont Dep. Le paramètre {^[turn ^»left^]} étant une classe G, il n'y a pas à rechercher de fonction dans ce cas. En conséquence, l’étape de dichotomie va insérer les classes IG suivantes.
{^[^[turn ^»left^]^«^[ means ^»^SETWHEEL-1 ^]^]} puis reprendra la recherche de fonction et trouvera {^SETWHEEL} fonction amont. Après insertion des classes IG nous aurons : {^[^[turn ^»left^]^«^[ means ^»^[^SETWHEEL^»-1 ^]^]^]} qui est la dichotomie de notre séquence.
Règles de mise à jour des classes dans l'Identificateur-Créateur
Toute séquence simple (ne comportant que des caractères, ne comportant pas de séquences IG) ne devra être présente qu'une unique fois dans la base de données. En conséquence toute séquence simple n’est représentée que par un unique No de classe dans la base de données. Le maintien de cette notion d'unicité impose que le module d'identification-création respecte les règles suivantes :
- la classe à créer est G et connue Non G ->On met à jour la jour la classe en lui rajoutant son expression en terme de classe et son sens,
la classe à créer est Non G et connue G -> pas de mise a jour à faire, la classe reste G sur la base de données,
la classe à créer est G et connue G sous une forme différente (le sens et/ou la fonction et le paramètre sont différents) -> on met à jour l'expression en terme de classe et le sens (la nouvelle version prime sur l'ancienne),
la classe a créer (G ou Non G) est connue sous la même forme -> Pas de mise à jour à faire,
la classe à créer (G ou Non G) est inconnue sur la base-> Crée la nouvelle classe.
Corrections d'incompréhension
Dans certains cas, (absence de définition de fonction, non définition de hiérarchie, etc), l’étape de dichotomie peut établir une dichotomie erronée pour une séquence. Il suffit alors de re-saisir ladite séquence en mentionnant les classes IG conformément à ce qui doit être compris. La séquence sera alors corrigée.
Exemple d'application
Nous reprendrons pour cet exemple le contrôle d'un petit véhicule déjà abordé puis nous l'étofferons. Nous partirons d'une base vierge et nous ferons apparaître l'état de la base à chaque étape.
a) initialisation de la base
Il s’agit des Mots Réservés :
Figure imgf000036_0001
Figure imgf000037_0001
b) contrôle des roues
Établit ^SETWHEEL comme fonction Amont { ^[^SETWHEEL^»1 ^]}
Figure imgf000037_0002
Établit ^SETWHEEL comme Fonction Exécutable {^SETWHEEL^«^EXE^]}
Figure imgf000037_0003
Établit { means } comme Équivalence {^[ means ^«^EQV^]}
Figure imgf000037_0004
Apprend les équivalences :
(i) Pour mettre les roues à droite
{^[turn right^«^[ means ^»^SETWHEEL1 ^]^]}
Figure imgf000037_0005
(ii) Pour mettre les roues à gauche
{turn left means ^SETWHEEL-1 }
Figure imgf000037_0006
(iii) Pour mettre les roues droites
{go straight means ^SETWHEEL0}
Figure imgf000038_0001
Cl contrôle du moteur
Nous utiliserons cette fois le Rmot ^SETENGINE Fonction Amont dont les paramètres sont de même {1 } pour avancer, {0} pour arrêter, {-1 } pour reculer.
^SETENGINE est lié dans l’étape d'éxécution à la commande du moteur. Les ordres correspondants sont :
{go ahead} pour avancer, {stop} pour arrêter et {move back} pour reculer Établit ^SETENGINE comme Fonction Amont
{^[^SETENGINE^»1 ^]}
Figure imgf000038_0002
Établit ^SETENGINE comme Fonction Exécutable
{^[ ^SETENGINE^«^EXE^]}
Figure imgf000038_0003
Apprend les équivalences :
(i) Pour mettre le moteur en avant
{go ahead means ^SETENGINE1 }
Figure imgf000038_0004
(ii) Pour mettre le moteur en arrière
{move back means ^SETENGINE-1 }
Figure imgf000038_0005
(iii) Pour arrêter le moteur
{stop means ^SETENGINE0}
Figure imgf000039_0001
A ce point nous avons donc appris au procédé à exécuter les ordres nécessaires au contrôle de notre véhicule, a savoir :
turn right, turn left, go straight, go ahead, move back, et stop Ordres Équivalents
Nous souhaitons ici disposer de synonymes pour certains ordres, par exemple nous souhaitons que le procédé comprenne correctement l'ordre {make a right}. Pour ce faire nous pouvons évidemment saisir {make a right means ^SETWHEEL 1 } ce qui fonctionnera.
Nous saisirons plutôt l'équivalence :
{make a right means turn right}
Une fois cette équivalence apprise normalement, nous pourrons saisir {make a right}
le procédé appelle la fonction d’équivalence pour cette séquence, cette dernière trouve comme classe équivalente {turn right}, et continue
la fonction d’équivalence trouve alors {^SETWHEEL1 } et reprend ensuite la méthode
- la fonction d’équivalence ne trouvant plus d'équivalence, le procédé passe à l’étape d’exécution et met les roues à droite.
Cet ordre sera donc bien exécuté par la machine.
Dans une variante, selon un exemple, l’étape d’identification-création est réalisée au fur à mesure de l’étape dichotomie.
Revenant à la figure 6, cette figure représente un exemple d’une classe
C9 et des classes impliquées dans la structure de la classe C9. La figure montre les relations entre les classes une fois les traitements accomplis. Dans les bulles sont mentionnées les expressions simples. Le P signifie un paramètre. Le F représente la fonction.
Figure imgf000040_0001
Précisions et Exemples sur les Hiérarchies
Une classe fonction est appelée aussi juste fonction. Un classe paramètre est appelée aussi juste paramètre.
Le principe de la dichotomie est que ce sont les rapports hiérarchiques entre deux fonctions qui permettent de dichotomiser une séquence.
Cas 1 - Supposons une fonction amont antérieure sur la séquence à une fonction avale
° Si le Système connaît une hiérarchie simple entreces deux fonctions Le Système applique cette hiérarchie (insère les classes IG correspondantes dans la séquence).
Exemple 1 : Cas d'une hiérarchie connue dans la table des rapports hiérarchiques
Soit une base de données dans laquelle il est connu les éléments suivants :
{turn } comme fonction amont
{ quickly} comme fonction avale
le rapport hiérarchique : {turn } <<< { quickly} ( la fonction { quickly} est dominante sur la fonction {turn } )
Il est saisi la séquence : {turn right quickly}
A l'étape b) de dichotomie il est reconnu la fonction amont {turn } qui est correctement bordée et peut donc être considérée.
II est alors recherché la portée de son paramètre qui commence à « r ». Il est ensuite reconnu la fonction avale { quickly} de hiérarchie dominante sur {turn }.
En conséquence le paramètre s'arrête au « t » précédent { quickly} et la fonction {turn } a préséance sur la fonction { quickly} dans la prise du paramètre {right} et les IG correspondantes sont insérés dans la séquence : {^[turn ^»right^] quickly} puis l'algorithme continue. La seule fonction bien bordée encore non traitée dans la séquence est { quickly}, il n'y a pas d'interaction hiérarchique avec une autre fonction, aussi son paramètre débute en début de séquence et finit à la position précédent { quickly}. En conséquence les IG suivantes sont insérées :
{^[^[turn ^»right^]^« quickly^]}
Exemple 2 : Cas d'une hiérarchie inconnue dans la table
Utilisation de l'évaluation d'une hiérarchie
Soit une base de données dans laquelle il est connu trois séquences : S1 ={^[^[turn ^»north^]^« quickly^]}
S2={^[^[turn ^»south^]^« quickly^]}
S3={^[turn ^»^[left^« quickly^]^]}
De ces trois séquences le Système sait que :
{turn } est une Fonction amont
{ quickly} est une Fonction avale
Il est saisi la séquence : {turn right quickly}
Lors de l'étape b) de dichotomie et identiquement à l'Exemple 1 ci- dessus, les deux fonctions {turn } et { quickly} sont reconnues, mais l'absence de rapport hiérarchique de ces deux fonctions dans la table impose au Système (ou procédé) de l'évaluer. Il est alors compté le nombre de récurrences pour les deux fonctions, soit N12=1 (correspondant à S3) et N21 =2 (correspondant à S1 et S2), nous indiquant ainsi, puisque N21 >N12 que {turn } <<< { quickly} et identiquement à l'Exemple 1 ci-dessus, il est inséré dans la séquence les IG telles que {^[^[turn ^»right^]^« quickly^]} ° Si le Système ne connaît pas de hiérarchie simpleentre ces deux fonctions et que l'une au moins (ou les deux) fonction(s) sont des fonctions ParDep, alors le Système recherchera la hiérarchie :
Soit de la fonction amont si celle-ci n'est pas une fonction ParDep Soit des listes des fonction ParDep amont de la fonction amont si celle- ci est une fonction ParDep
et/versus
Soit de la fonction avale si celle-ci n'est pas une fonction Pardep Soit de la liste des fonctions ParDep avales de la fonction avale si celle- ci est une fonction ParDep
Si le Système trouve alors une hiérarchie Le Système applique cette hiérarchie
Exemple 3 : Cas de Hiérarchie inconnue Fonction amont Versus Fonction ParDep avale
Utilisation des listes de fonction ParDep d'une fonction Dep utilisée dans une fonction ParDep
Soit une base de données dans laquelle il est connu les éléments suivants :
{ means } comme Fonction Dep amont
S4={^[ means ^»^SETWHEEL1 ^]}
S5={^[^[turn ^»left^]^«^[ means ^»^SETWHEEL-1 ^]^]} Le Système sait en conséquence que :
{turn } est une fonction amont
S4 est une fonction ParDep avale
Appelions S6={^[ means ^»^SETWHEEL-1 ^]} est une fonction ParDep avale
Le Système ne connaît pas de rapport hiérarchique directe/simple de
{turn } Versus { means ^SETWHEEL1 }
Il est saisit : {turn right means ^SETWHEEL1 }
Lors de l'étape b) de dichotomie la fonction amont {turn } sera traitée car bien bordée (les classes IG), lors de la recherche de la portée de son paramètre il est rencontré la fonction avale S4={ means ^SETWHEEL1 } mais aussi la fonction Dep amont { means } toutes deux bien bordées, la fonction S4 étant une classe généralisée utilisant { means } sera prioritaire dans le traitement sur cette dernière, en l'absence de connaissance de rapport hiérarchique entre ces deux fonctions et puisque S4 est une fonction ParDep, il est évalué le rapport hiérarchique de {turn } versus la liste des fonctions ParDep de la fonction Dep { means } soit S4 et S6, la classe généralisée S5 nous donne une occurrence telle que {turn } <<< S6, cette hiérarchie s'appliquera donc et en conséquence {turn } aura la préséance dans la prise du paramètre {right} et infiné nous obtiendrons :
{^[^[turn ^»right^]^«^[ means ^»^SETWHEEL1 ^]^]}
° Si le Système ne trouve toujours pas de hiérarchie, le Système recherchera alors la hiérarchie :
de la liste des fonctions amont apparentées à la fonction amont et/versus
de la liste des fonctions avales apparentées à la fonction avale
Si le Système trouve alors une hiérarchie Le Système applique cette hiérarchie Cas 2 - Fonction amont antérieure sur la séquence à une fonction Dep amont
Seules des fonctions de sens inversés peuvent interagir hiérarchiquement entre elles, aussi dans l'évaluation hiérarchique, il sera substitué à la fonction Dep amont, la liste des fonctions ParDep avales de cette fonction Dep amont. Ceci correspond à une anticipation dans la séquence d'une future fonction ParDep avale de la fonction Dep amont qui apparaîtra au cours de la dichotomie.
Exemple 4 : Cas de Hiérarchie inconnue Fonction amont Versus Fonction Dep amont
Utilisation des listes de fonctions ParDep
Soit une base de données dans laquelle il est connu les éléments suivants : { means } comme Fonction Dep amont
S5={^[^[turn ^»left^]^«^[ means ^»^SETWHEEL-1 ^]^]}
Le Système sait en conséquence que :
{turn } est une fonction amont
Appelions S6={^[ means ^»^SETWHEEL-1 ^]} est une fonction ParDep amont
Il est saisit : {turn right means ^SETWHEEL1 }
Lors de l'étape b) de dichotomie la fonction amont {turn } sera traitée car bien bordée, lors de la recherche de la portée de son paramètre il est rencontré la fonction Dep amont { means }, il est alors évalué le rapport hiérarchique de la fonction {turn } versus la liste des fonctions ParDep de { means } soit S6, la classe généralisée S5 nous donne une occurrence telle que {turn } <<< S6. En conséquence {turn } aura la préséance dans la prise du paramètre {right} et les IG suivantes seront insérées {^[turn ^»right^] means ^SETWHEEL1} la fonction suivante à traiter est la fonction { means }, c'est une fonction amont et il n'y a pas d'autres fonctions postérieures avec laquelle elle puisse interagir hiérarchiquement, en conséquence son paramètre commencera à ^SETWHEEL et finira en fin de séquence, il est alors inséré les IG suivantes :
{^[turn ^»right^]^[ means ^»^SETWHEEL1 ^]}. La derniere fonction à traiter est la fonction avale Pardep {^[ means ^»^SETWHEEL1 ^]}, après insertion des classes IG et infiné nous obtiendrons :
{^[^[turn ^»right^]^«^[ means ^»^SETWHEEL1 ^]^]} Exemple 5 : Cas de Hiérarchie inconnue Fonction amont Versus
Fonction Dep amont
Utilisation des parentés pour l'évaluation hiérarchique
{ means } comme fonction Dep amont
{ signifies } comme fonction Dep amont
le rapport hiérarchique {turn } <<< { means }
Deux séquences :
S7={^[means^« is a verb of equivalence^]}
S8={^[signifies^« is a verb of equivalence^]} il est saisit : {turn right signifies ^SETWHEEL1 }
Lors de l'étape b) de dichotomie la fonction amont {turn } sera traitée car bien bordée, lors de la recherche de la portée de son paramètre il est rencontré la fonction Dep amont { signifies }, il est alors évalué le rapport hiérarchique de la fonction {turn } versus la liste des fonctions ParDep de { signifies } , liste qui est vide, il n'y a donc pas de hiérarchie via ce mode, il est alors recherché les fonctions apparentés de { signifies },le système trouvera alors via S7 et S8 la fonction { means }, il recherchera alors la hiérarchie de {turn } versus { means }, que le système connaît comme étant
{turn } <<< { means } .En conséquence {turn } aura la préséance dans la prise du paramètre {right} et infiné nous obtiendrons :
{^[^[turn ^»right^]^«^[ means ^»^SETWHEEL1 ^]^] Cette Organisation n'est pas limitative, elle peut encore être étendue, il est possible, et par exemple, s’il n'est pas trouvé de hiérarchies à l'issue des enchaînements précédents, d'étendre la liste des fonctions apparentées obtenues précédemment de toutes les fonctions apparentées de cette liste puis de reprendre l'évaluation hiérarchiques et ainsi de suite.
II y a un compromis entre le temps de traitement attachés aux évaluations hiérarchiques et l'acceptabilité d'une erreur de compréhension du Système.

Claims

REVENDICATIONS
1. Procédé mise en oeuvre par ordinateur de transformation d’une séquence comportant plusieurs mots issus d’une langue naturelle pour rendre ladite séquence exécutable en temps réel pour piloter une machine, caractérisée en ce que ledit procédé comprend les étapes suivantes :
a) prétraitement, dans lequel une séquence constituée de plusieurs caractères formant des mots issus d’une langue naturelle, ladite séquence est comparée avec des données d’une base de données comportant des classes, chaque classe comprenant au minimum les deux premiers des éléments suivants :
■ un numéro,
■ une expression simple constituée par la suite de caractères représentant la classe,
■ une expression classe composée de deux numéros correspondant à deux autres classes, soit positionné en une première position, soit positionné en une deuxième position, et
■ un sens, ledit sens étant soit amont, soit aval,
si ladite classe comprend également une expression classe et un sens, alors ladite classe est appelée classe Généralisée, si le sens est amont ladite classe est appelée classe Généralisée amont, si le sens est aval, ladite classe est appelée classe Généralisée avale,
s’il s’agit d’une classe Généralisée amont alors la classe en première position de son expression classe est une classe fonction amont et la classe en deuxième position de son expression classe est une classe.paramètre,
s’il s’agit d’une classe Généralisée avale alors la classe en première position de son expression classe est une classe.. paramètre et la classe en deuxième position de son expression classe est une classe fonction avale, une classe fonction est au moins l’un des éléments suivants : une classe fonction amont, et une classe fonction avale,
il est défini une table de classes fonctions amonts ou avales particulières appelées classe fonction Dep, une classe fonction Dep est soit une classe fonction Dep amont, soit une classe fonction Dep avale, lesdites classes fonction Dep présentes dans la table ont pour caractéristique que toute classe généralisée de l'une desdites classes fonction Dep est connue du procédé comme une classe fonction de sens inversé à ladite classe fonction Dep, appelée classe fonction ParDeo, ainsi
une classe fonction ParDeo amont est une classe fonction amont et est une classe Généralisée d'une classe fonction Dep avale, et
une classe fonction ParDeo avale est une classe fonction avale et est une classe Généralisée d'une classe fonction Dep amont,
il est également défini une table de rapports hiérarchiques pour des couples constitués d'une classe fonction amont ou d’une classe fonction Dep et d'une classe fonction avale ou d’une classe fonction Dep, ledit rapport hiérarchique indique pour chacun des couples présents dans la table laquelle des deux classes fonctions du couple est Hiérarchiquement dominante sur l'autre,
si dans une séquence une classe fonction amont précède une classe fonction avale ou une classe fonction Dep hiérarchiquement dominante, et que lesdites classes fonctions soient séparées par un paramètre non vide, alors ladite classe fonction amont non hiérarchiquement dominante à la préséance dans la prise dudit paramètre sur la classe fonction avale ou la classe fonction Dep hiérarchiquement dominante,
si dans une séquence une classe fonction avale est postérieure à une classe fonction amont ou une classe fonction Dep hiérarchiquement dominante, et que lesdites classes fonctions soient séparées par un paramètre non vide, alors ladite classe fonction avale non hiérarchiquement dominante à la préséance dans la prise dudit paramètre sur la classe fonction amont ou la classe fonction Dep hiérarchiquement dominante,
ladite base de données comporte également des classes réservées, chaque classe réservée comporte un numéro et une expression simple, dont chaque expression simple est précédé d’un marquage (^),
ladite base de données comporte les éléments suivants prédéfinis : première classe réservée (^[), deuxième classe réservée (^»), troisième classe réservée (^«), quatrième classe réservée (^]), cinquième classe réservée (^ECE), la première classe réservée (^[), la deuxième classe réservée (^»), la troisième classe réservée (^«) et la quatrième classe réservée (^]) sont ci-après désignées classes IG, la première classe réservée (^[) et la quatrième classe réservée (^]) ont pour fonction d’indiquer dans une séquence le début et la fin d'une classe Généralisée,
la seconde classe réservée (^»), toujours positionnée à l'intérieur d'une partie de la séquence délimitée par la première classe réservée (^[) et la quatrième classe réservée (^j), sépare ladite partie de séquence en deux sous parties dont la première représente une classe fonction amont et la seconde représente une classe paramètre, et indique que ladite partie de séquence représente une classe Généralisée amont,
la troisième classe réservée (^«), toujours positionnée à l'intérieur d'une partie de la séquence délimitée par la première classe réservée (^[) et la quatrième classe réservée (^j), sépare ladite partie de séquence en deux sous parties dont la première représente une classe paramètre et la seconde représente une classe fonction avale, et indique que ladite partie de séquence représente une classe Généralisée avale,
une séquence ou partie de séquence comportant des classes IG est dénommé expression IG,
la cinquième classe réservée (^EXE) est une classe fonction et désigne toute classe comme exécutable par une machine,
l’étape de prétraitement comporte une comparaison de la séquence avec les données de la base de données :
si une classe réservée est reconnue dans une partie de la séquence, alors ladite partie de la séquence est substituée par le numéro de la classe réservée correspondant,
b) dichotomie, dans laquelle il est recherché dans la séquence les expressions simples et expressions IG connues dans le procédé comme étant une classe fonction amont ou une classe fonction avale, la séquence est dichotomisée jusqu’à ce que toutes les classes fonction contenues dans la séquence susceptibles de donner lieu à des dichotomies l'ait été,
pour chacune des classes fonctions amonts ou classes fonctions avales trouvées dans la séquence, l’étape de dichotomie consiste à :
- s’il s’agit d'une classe fonction amont, et ladite classe fonction amont si Non Dep se trouve au début de la séquence ou immédiatement précédée de l'une des trois premières classe IG (^[, ^», ^«) et ladite fonction amont se trouve non en fin de séquence et non immédiatement suivie de l’une des trois dernières classes IG (^», ^«, ^]), alors il est identifié une partie de la séquence jouant le rôle d’une classe paramètre pour ladite classe fonction amont, ladite classe paramètre, contigu à ladite classe fonction amont, débute à la position suivant ladite classe fonction amont et dont la position de fin est identifiée en poursuivant sur les positions de la séquence à partir de la position de début de la classe paramètre et est : soit à la position précédant l'expression simple ou l'expression IG d'une classe fonction avale ou d’une classe fonction Dep, et de hiérarchie dominante sur ladite classe fonction amont,
soit à la position précédent de l”une des trois dernières classes IG (^», ^«, ^]) sachant que s’il est rencontré la première classe réservée (^[) à une position, l'analyse reprend à la position suivant la quatrième classe réservée (^j) correspondante à la première classe réservée (^[) rencontrée,
soit en fin de séquence,
lorsque la position de fin de la classe paramètre est ainsi déterminée, et si les positions de début et de fin de la classe paramètre sont différentes, il est inséré dans la séquence :
la première classe réservée (^[) à la position précédent la classe fonction amont,
la deuxième classe réservée (^») entre la fin de la classe fonction amont et le début de la classe paramètre, la quatrième classe réservée (^j) à la fin de la classe paramètre,
l'insertion de ces trois classes IG définissent dans la séquence une classe
Généralisée amont,
- si il s’agit d'une classe fonction avale, et ladite classe fonction avale si Non Dep se trouve en fin de la séquence ou immédiatement suivie de l’une des trois dernières classes IG (^», ^«, ^]) et ladite fonction avale se trouve non au début de la séquence et non immédiatement précédée de l’une des trois premières classes IG (^[, ^», ^«) , alors il est identifié une partie de la séquence jouant le rôle d’une classe paramètre pour ladite classe fonction avale, ladite classe paramètre, contigu a ladite classe fonction avale, se termine à la position précédant ladite classe fonction avale et dont la position de début est identifiée en régressant sur les positions de la séquence à partir de la position de fin de la classe paramètre et est : soit à la position suivant l'expression simple ou expression IG d'une classe fonction amont ou d’une classe fonction Dep, et de hiérarchie dominante sur ladite classe fonction avale, soit à la position suivant l'une des trois premières classes IG (^[, ^», ^«) sachant que s’il est rencontré la quatrième classe réservée (^]) à une position, l'analyse reprend à la position précédent la première classe réservée (^[) correspondante à la quatrième classe réservée (^]) rencontrée,
soit en début de séquence,
lorsque la position du début de la classe paramètre est ainsi déterminée, et si les positions de début et de fin de la classe paramètre sont différentes, il est inséré dans la séquence :
la première classe réservée (^[) immédiatement avant la classe paramètre,
la troisième classe réservée (^«) entre la fin de la classe paramètre et le début de la classe fonction avale,
la quatrième classe réservée (^]) à la fin de la classe fonction avale, l'insertion de ces trois classes IG définissent dans la séquence une classe Généralisée avale,
l’étape b) de dichotomie autorise des classes Généralisées imbriquées,
c) identification-création, dans laquelle
■ toutes les classes fonctions et tous les classes paramètre non classes généralisées sont substituées dans la séquence par leur numéro de classe, et
■ il est inséré immédiatement avant la première classe réservée (^[) de chacune des classes généralisées le numéro de classe de ladite classe généralisé,
pour chaque classe généralisée contenue dans la séquence :
■ si la classe fonction définie par son expression simple est inconnue alors ladite classe fonction est stockée dans la base de données avec au moins les deux informations suivantes : un nouveau numéro et son expression simple, ■ si la classe paramètre définie par son expression simple est inconnue alors ladite classe paramètre est stockée dans la base de données avec au moins les deux informations suivantes : un nouveau numéro et son expression simple,
■ si la classe Généralisée définie par son expression simple est inconnue alors ladite classe Généralisée est stockée dans la base de données avec les informations suivantes : un nouveau numéro, son expression simple, son expression classe et son sens,
pour une partie de la séquence qui n’est pas une classe généralisée et est inconnue alors ladite partie séquence est stockée dans la base de données avec au moins les deux informations suivantes : un nouveau numéro et son expression simple,
la séquence obtenue est appelée expression LIG de la séquence
d) exécution, où il est itéré de la première à la dernière des classes de la séquence et dans laquelle
■ les classes IG sont ignorées,
■ chaque classe exécutable est exécutée par une machine, la poursuite de l'itération reprenant en fin de ladite classe exécutable, une classe exécutable étant définie comme :
■ une classe paramètre liée à la cinquième classe réservée (^ECE) dans une classe généralisée,
■ une classe Généralisée dont la classe fonction est une classe exécutable,
■ une classe Généralisée dont la classe fonction est une classe fonction ParDep d'une classe fonction Dep qui est une classe exécutable.
2. Procédé selon la revendication 1 , dans lequel la mise à jour de la table des fonctions Dep à l’étape b) est déterminée selon les conditions suivantes : si une classe fonction amont s’applique à un premier nombre amont (N1 am) correspondant au nombre de récurrence de ladite classe fonction amont des classes Généralisées amont de la base de données, et que ladite classe fonction amont s’applique à un deuxième nombre amont (N2am) correspondant au nombre de récurrence desdites classes Généralisées qui sont des classes fonctions avales, et dont ledit deuxième nombre amont (N2am) est au moins supérieur à la moitié du premier nombre (N1 am), alors la classe fonction amont est une classe fonction Dep amont,
si une classe fonction avale s’applique à un premier nombre aval (N1 av) correspondant au nombre de récurrence de ladite classe fonction avale des classes Généralisées avale de la base de données, et que ladite classe fonction avale s’applique à un deuxième nombre aval (N2av) correspondant au nombre de récurrence desdites classes Généralisées qui sont des classes fonctions amont, et dont ledit deuxième nombre aval (N2av) est au moins supérieur à la moitié du premier nombre (N1 av), alors la classe fonction avale est une classe fonction Dep avale.
3. Procédé selon la revendication 1 , dans lequel à l’étape b) de dichotomie, le procédé comporte les éléments suivants : si une classe fonction amont est antérieure dans une séquence à une classe fonction avale, il est évalué le rapport hiérarchique entre la classe fonction amont et la classe fonction avale comme étant :
si ladite classe fonction amont s'applique à un nombre amont (N12) correspond au nombre de récurrence de ladite classe fonction amont des classes Généralisées amont de la base de données dans lesquelles les classes paramètre sont des classes Généralisées avale dont la fonction est ladite classe fonction avale, et que ladite classe fonction avale s'applique à un nombre aval (N21 ) correspond au nombre de récurrence de ladite classe fonction avale des classes Généralisées avale de la base de données dans lesquelles les classes paramètre sont des classe Généralisées amont dont la fonction est ladite classe fonction amont, et que :
si le nombre amont (N12) est supérieur au nombre aval
(N21 ) alors ladite classe fonction amont est une hiérarchiquement dominante sur ladite classe fonction avale, si le nombre aval (N21 ) est supérieur au nombre amont (N12) alors ladite classe fonction avale est une hiérarchiquement dominante sur ladite classe fonction amont,
sinon il n’y a pas de rapport hiérarchique entre ladite classe fonction amont et ladite classe fonction avale,
4. Procédé selon la revendication 3, dans lequel à l’étape b) de dichotomie, le procédé comporte les éléments suivants :
il est défini également un rapport hiérarchique pour une liste de classe fonction amont et une liste de classe fonction avale, un nombre amont de liste (NL12) étant alors obtenu en cumulant les nombres amonts (N12) pour chacun des couples constitués d’une classe fonction amont appartenant à la liste de classe fonction amont et d’une classe fonction avale appartenant à la liste de la classe fonction avale,
et le nombre aval de liste (NL21 ) étant alors obtenu en cumulant les nombres avals (N21 ) pour chacun des couples constitués d’une classe fonction amont appartenant à la liste de classe fonction amont et d’une classe fonction avale appartenant à la liste de la classe fonction avale, si ledit nombre amont de liste (NL12) est supérieur au nombre aval de liste (NL21 ), alors :
ladite liste de classe fonction amont est une hiérarchiquement dominante sur ladite liste de classe fonction avale,
si le nombre aval de liste (NL21 ) est supérieur au nombre amont de liste (NL12) alors ladite liste de classe fonction avale est une hiérarchiquement dominante sur ladite liste de classe fonction amont,
sinon il n’y a pas de rapport hiérarchique entre ladite liste de classe fonction amont et ladite liste de classe fonction avale, si une classe fonction amont est antérieure dans une séquence à une classe fonction avale et qu'il n’y a pas de rapport hiérarchique directement entre ladite classe fonction amont et ladite classe fonction avale et que l'une ou les deux sont des classe fonctions ParDep, alors il est évalué le rapport hiérarchique de la liste des classes fonctions ParDep amont de la même classe fonction Dep avale de ladite classe fonction amont si celle-ci est une classe fonction ParDep et de la liste des classes fonctions ParDep avales de la même classe fonction Dep amont de ladite classe fonction avale si celle-ci est une classe fonction ParDep,
5. Procédé selon la revendication 4, dans lequel à l'étape b)
si une classe fonction amont est antérieure dans une séquence à une classe fonction Dep également amont, il est évalué le rapport hiérarchique de la classe fonction amont et de la liste de toutes les classes fonctions ParDep avales de la classe fonction Dep amont,
et dans lequel à l'étape b) il est rajouté s’il s’agit d'une fonction amont l'option suivante dans la détermination de la position de fin du paramètre de ladite fonction amont :
soit à la position précédent l'expression simple d'une classe fonction Dep amont et de hiérarchie dominante sur ladite classe fonction amont, si une classe fonction avale est postérieure dans une séquence à une classe fonction Dep également avale, il est évalué le rapport hiérarchique de la classe fonction avale et de la liste de toutes les classes fonctions Pardep avales de la classe fonction Dep avale,
et dans lequel à l'étape b) il est rajouté si il s’agit d'une fonction avale l'option suivante dans la détermination de la position de début du paramètre de ladite fonction avale :
soit à la position suivant l'expression simple d'une classe fonction Dep avale et de hiérarchie dominante sur ladite classe fonction avale.
6. Procédé selon la revendication 1 , dans lequel à l’étape c), si la classe généralisée est connue, il est mis à jour son expression classe et son sens.
7. Procédé selon la revendication 2, dans lequel le deuxième nombre amont (N2am) est au moins supérieur aux deux tiers du premier nombre (N1 am) et le deuxième nombre aval (N2av) est au moins supérieur aux deux tiers du premier nombre (N1 av).
8. Procédé selon la revendication 1 , dans lequel à l'étape b) de dichotomie lors de la recherche de classes fonctions dans la séquence, ladite étape b) comporte en outre que si une classe fonction est trouvée dans la séquence et que l'expression IG de ladite classe fonction contient d'autres classes fonction alors ladite classe fonction est traitée en priorité sur lesdites autres classes fonction. 9. Procédé selon la revendication 1 , dans lequel :
dans l’étape a) de prétraitement, la base de données comporte également une sixième classe réservée (^EQV),
ladite sixième classe réservée (^EQV) est une classe fonction avale et désigne toute classe fonction Dep comme fonction d'équivalence dès lors que ladite classe fonction Dep se trouve être paramètre dans une classe généralisée dont la fonction est la sixième classe réservée (^EQV), ainsi toute classe paramètre d'une classe généralisée dont la fonction est la classe fonction ParDep d'une classe fonction Dep et d'équivalence a pour classe équivalente la classe paramètre de la classe fonction Dep dans la classe généralisée fonction ParDep,
dans l’étape d) d’exécution, s’il est rencontré dans la séquence une classe et que une classe généralisée est connue dont le paramètre est ladite classe et la fonction est une classe fonction ParDep d'une classe fonction Dep et d'équivalence, alors l'expression LIG de ladite classe est substituée dans la séquence par l'expression LIG de sa classe équivalente, l'itération reprenant au début de ladite classe,
l'expression LIG de ladite classe équivalente débute par le numéro de ladite classe et est obtenue par itération en faisant suivre tous les numéros des classe généralisées de l'expression LIG de ladite classe par le numéro de la première classe IG, puis du numéro de la première classe de l'expression classe de la classe généralisée, puis du numéro de la deuxième classe IG si la classe est une classe généralisée amont ou du numéro de la troisième classe IG si la classe est une classe généralisée avale, puis du numéro de la deuxième classe de l'expression classe de la classe généralisée, puis du numéro de la quatrième classe IG.
10. Procédé selon la revendication 5 dans lequel à l’étape b) de dichotomie s’il n’y a pas de rapport hiérarchique entre deux classes fonctions, il est recherché pour chacune des deux classe fonctions la liste des classes fonctions apparentées dans la base de données puis il est comparé la récurrence de chaque classe fonction pour évaluer la hiérarchie entre ces deux listes, la liste des classes apparentées a une classe étant définie comme la liste des classes qui sont une classe paramètre dans des classes généralisées et dont les classes fonctions s’appliquent également à ladite classe dans une classe généralisée.
1 1. Procédé selon la revendication 1 , dans lequel à l'étape a) de prétraitement s’il est rencontré le marqueur des classes réservées (^) suivi d'un numéro, alors cette expression (^+numéro) est substituée dans la séquence par le numéro de la classe de même numéro.
PCT/FR2019/050272 2018-02-07 2019-02-07 Procédé de transformation d'une séquence pour la rendre exécutable par une machine WO2019155168A1 (fr)

Priority Applications (1)

Application Number Priority Date Filing Date Title
EP19710040.7A EP3750051A1 (fr) 2018-02-07 2019-02-07 Procédé de transformation d'une séquence pour la rendre exécutable par une machine

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
FR1850996A FR3077656A1 (fr) 2018-02-07 2018-02-07 Procede de transformation d’une sequence pour la rendre executable par une machine
FR1850996 2018-02-07

Publications (1)

Publication Number Publication Date
WO2019155168A1 true WO2019155168A1 (fr) 2019-08-15

Family

ID=62749079

Family Applications (1)

Application Number Title Priority Date Filing Date
PCT/FR2019/050272 WO2019155168A1 (fr) 2018-02-07 2019-02-07 Procédé de transformation d'une séquence pour la rendre exécutable par une machine

Country Status (4)

Country Link
US (1) US11009845B2 (fr)
EP (1) EP3750051A1 (fr)
FR (1) FR3077656A1 (fr)
WO (1) WO2019155168A1 (fr)

Citations (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
WO2000023889A1 (fr) 1998-10-16 2000-04-27 Klein Peter A Procede et systeme de compilation de code de source contenant des ressources en langage naturel
US6243670B1 (en) 1998-09-02 2001-06-05 Nippon Telegraph And Telephone Corporation Method, apparatus, and computer readable medium for performing semantic analysis and generating a semantic structure having linked frames
US20050283467A1 (en) * 2004-06-17 2005-12-22 Ixi Mobile (R&D) Ltd. Natural language for programming a specialized computing system
US20170239576A1 (en) 2016-02-24 2017-08-24 Virginia Tech Intellectual Properties, Inc. Automated program synthesis from natural language for domain specific computing applications

Family Cites Families (12)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US4499553A (en) * 1981-09-30 1985-02-12 Dickinson Robert V Locating digital coded words which are both acceptable misspellings and acceptable inflections of digital coded query words
US6108666A (en) * 1997-06-12 2000-08-22 International Business Machines Corporation Method and apparatus for pattern discovery in 1-dimensional event streams
US6125342A (en) * 1997-11-18 2000-09-26 L & H Applications Usa, Inc. Pronoun semantic analysis system and method
JP3004254B2 (ja) * 1998-06-12 2000-01-31 株式会社エイ・ティ・アール音声翻訳通信研究所 統計的シーケンスモデル生成装置、統計的言語モデル生成装置及び音声認識装置
US7085708B2 (en) * 2000-09-23 2006-08-01 Ravenflow, Inc. Computer system with natural language to machine language translator
US20080126092A1 (en) * 2005-02-28 2008-05-29 Pioneer Corporation Dictionary Data Generation Apparatus And Electronic Apparatus
US9846739B2 (en) * 2006-10-23 2017-12-19 Fotonation Limited Fast database matching
US7809765B2 (en) * 2007-08-24 2010-10-05 General Electric Company Sequence identification and analysis
US8077984B2 (en) * 2008-01-04 2011-12-13 Xerox Corporation Method for computing similarity between text spans using factored word sequence kernels
JP5391583B2 (ja) * 2008-05-29 2014-01-15 富士通株式会社 検索装置、生成装置、プログラム、検索方法および生成方法
JP4701292B2 (ja) * 2009-01-05 2011-06-15 インターナショナル・ビジネス・マシーンズ・コーポレーション テキスト・データに含まれる固有表現又は専門用語から用語辞書を作成するためのコンピュータ・システム、並びにその方法及びコンピュータ・プログラム
ITRM20130022A1 (it) * 2013-01-11 2014-07-12 Natural Intelligent Technologies S R L Procedimento e apparato di riconoscimento di scrittura a mano

Patent Citations (5)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6243670B1 (en) 1998-09-02 2001-06-05 Nippon Telegraph And Telephone Corporation Method, apparatus, and computer readable medium for performing semantic analysis and generating a semantic structure having linked frames
WO2000023889A1 (fr) 1998-10-16 2000-04-27 Klein Peter A Procede et systeme de compilation de code de source contenant des ressources en langage naturel
US20050283467A1 (en) * 2004-06-17 2005-12-22 Ixi Mobile (R&D) Ltd. Natural language for programming a specialized computing system
EP1769332A2 (fr) * 2004-06-17 2007-04-04 Ixi Mobile (R&D) Ltd. Langage naturel pour programmer un systeme informatique specialise
US20170239576A1 (en) 2016-02-24 2017-08-24 Virginia Tech Intellectual Properties, Inc. Automated program synthesis from natural language for domain specific computing applications

Non-Patent Citations (1)

* Cited by examiner, † Cited by third party
Title
ANONYMOUS: "Translating Natural Language to Code", INTERNET CITATION, 2013, XP002786153, Retrieved from the Internet <URL:https://www.transifex.com/blog/2013/translate-natural-language-to-code/> [retrieved on 20181030] *

Also Published As

Publication number Publication date
EP3750051A1 (fr) 2020-12-16
US20190243324A1 (en) 2019-08-08
US11009845B2 (en) 2021-05-18
FR3077656A1 (fr) 2019-08-09

Similar Documents

Publication Publication Date Title
EP1364316A2 (fr) Dispositif d&#39;extraction d&#39;informations d&#39;un texte a base de connaissances
BE1024194A9 (fr) Procédé d&#39;indentification d&#39;un caractère dans une image numérique
FR2880709A1 (fr) Procede de recherche, reconnaissance et localisation dans l&#39;encre, dispositif, programme et langage correspondants
WO2007082948A1 (fr) Procede et dispositif pour extraire des informations et les transformer en donnees qualitatives d&#39;un document textuel
BE1008621A3 (fr) Procedure et procede de communication entre machines et procede generalise de preparation de programmes afferents.
Chang et al. The prompt artists
US20230118966A1 (en) Generation of story videos corresponding to user input using generative models
US20160110459A1 (en) Realtime Ingestion via Multi-Corpus Knowledge Base with Weighting
WO2011134804A1 (fr) Procede et systeme d&#39;adaptation d&#39;un contenu textuel au comportement langagier d&#39;une communaute en ligne
FR3017474A1 (fr) Saisie assistee de regles dans une base de connaissance
EP3248111A1 (fr) Procédé de lemmatisation, dispositif et programme correspondant
EP3750051A1 (fr) Procédé de transformation d&#39;une séquence pour la rendre exécutable par une machine
WO2014173882A1 (fr) Procédé et dispositif d&#39;extraction automatique de thèmes à partir d&#39;au moins un document contenant du texte
EP0670069A1 (fr) Procede de demonstration automatique
US11017172B2 (en) Proposition identification in natural language and usage thereof for search and retrieval
EP4127965A1 (fr) Méthode mise en oeuvre par ordinateur pour la recherche analogique de documents
Blouin Event extraction from facsimiles of ancient documents for history studies
Alcolei Enriched concurrent games: witnesses for proofs and resource analysis
FR2880708A1 (fr) Procede de recherche dans l&#39;encre par conversion dynamique de requete.
CN117688163B (zh) 基于指令微调和检索增强生成的在线智能问答方法及装置
US10878005B2 (en) Context aware document advising
WO2015132342A1 (fr) Procédé d&#39;analyse d&#39;une pluralité de messages, produit programme d&#39;ordinateur et dispositif associés
EP4155967A1 (fr) Procédé d&#39;échanges d&#39;informations sur un objet d&#39;intérêt entre une première et une deuxième entités, dispositif électronique d&#39;échange d&#39;informations et produit programme d&#39;ordinateur associés
FR2939538A1 (fr) Procede de recherche de correspondances entres differentes sources de donnees.
FR3110740A1 (fr) Procédé de conversion automatique de fichiers numériques

Legal Events

Date Code Title Description
121 Ep: the epo has been informed by wipo that ep was designated in this application

Ref document number: 19710040

Country of ref document: EP

Kind code of ref document: A1

NENP Non-entry into the national phase

Ref country code: DE

ENP Entry into the national phase

Ref document number: 2019710040

Country of ref document: EP

Effective date: 20200907