Computer architecture designed for transferring data between multiple functional units

Abstract

The invention relates to a computer architecture (110) enabling data transfer between several functional units. A functional unit supply structure (111) provides several functional units. A selection structure (112) provides a selection of functional units and linking information, the selected functional units being linked to perform predefined data processing. An interface structure (113) provides an interface for data transfer between linked selected functional units, this interface being designed to transform at least a portion of the output data content of the selected functional unit into input data of the other functional unit, according to the selected functional units and the linking information. [Abstract figure] Fig. 1

Description

Title of the invention: Computer architecture for transferring data between a plurality of functional units

[0001] The invention relates to a computer architecture, a computer-implemented method, and a computer program product, intended for the transfer of data between a plurality of functional units. It also relates to an interface structure capable of ensuring this data transfer.

[0002] Today, artificial intelligence algorithms, such as ChatGPT, are adapted to a wide variety of tasks and applied to increasingly complex problems. However, their implementation in such diverse contexts requires not only increased learning effort, but also growing algorithmic complexity, leading to an ever-increasing demand for computing resources.

[0003] In principle, many of these complex problems can be broken down into much simpler subproblems, each of which can then be handled by a less complex program. However, the exchange of data between these different programs often remains problematic, particularly when dealing with artificial intelligence algorithms. For example, it is common to have to train these algorithms so that they build upon each other, thus allowing one algorithm to use the output data of another as input data. This creates new challenges in terms of complexity and further increases the resource requirements during the training phase.

[0004] In order to increase the flexibility of application of artificial intelligence algorithms in various fields, it would therefore be desirable to allow an efficient and inexpensive transfer of data in terms of computing resources between different AI programs.

[0005] One of the objectives of the present invention is therefore to propose computer architectures, methods and computer program products allowing a fluid and structured exchange of data between different artificial intelligence algorithms, which can be interconnected in a flexible manner.

[0006] This objective is achieved through a computer architecture designed for data transfer between a plurality of functional units, said architecture comprising: a) a functional unit provisioning structure, configured to make available a plurality of distinct units, each designed to transform input data into output data; b) a selection structure, configured to provide a selection of at least two functional units, as well as information a) a linking structure defining the connections between these selected units, so as to allow the cooperative execution of a predefined data processing. This linking implies that the output data of at least one functional unit contains elements constituting at least part of the input data of at least one other unit; c) an interface structure, ensuring the transmission of data between the functional units thus linked. This interface is adapted, based on the selected functional units and the linking information, to transform at least part of the content of the output data of one functional unit into input data for another functional unit.

[0007] The computer architecture, designed to provide a plurality of distinct functional units and allow their selection, as described above, also incorporates an interface dedicated to data transfer between the selected functional units. This interface is configured to transform at least a portion of the output data of one functional unit into input data for another. Thanks to this capability, data can be transferred efficiently between different functional units—particularly between artificial intelligence algorithms—while optimizing the use of computing resources.

[0008] This mechanism allows several functional units to be linked in any desired combination to perform predefined data processing. Thus, efficient and resource-saving functional units, including artificial intelligence algorithms, can be used to solve complex tasks. Furthermore, this architecture offers great flexibility for adapting to a variety of applications. The proposed interface structure therefore addresses the identified problem and, moreover, allows simple functional units to be combined to handle complex problems in a modular and efficient manner.

[0009] The computer architecture in question can take any form that enables it to perform the functions described. For example, it can be implemented as a suitable hardware architecture or as software. It can also be considered as a framework providing the aforementioned functions, which other programs or hardware components can access and utilize. For example, a user interface could interact with this computer architecture to benefit from its functionalities.

[0010] The functional units can themselves be implemented as software components that perform their respective functions. They can also take the form of standalone programs, each dedicated to a specific processing of input and output data. In particular, these units can access data storage devices to read input data or record output data, depending on their role in the overall processing.

[0011] The term “#autonomous#” here means that the functional units, to the extent that their programming allows, operate as independent entities, each responsible for processing well-defined input data to produce specific output data. These functional units operate independently of each other, without direct dependence on preceding or subsequent units in the processing chain.

[0012] Thus, when selected functional units collaborate to execute a predefined data processing, this cooperation takes place within the framework of an interconnection between autonomous units — such as distinct programs, generative artificial intelligences or even expert systems — and not in the classic model of a main program calling internal modules or subroutines to perform individual tasks.

[0013] Each functional unit can perform any type of data processing on its inputs to produce a corresponding output. However, it is preferable that these autonomous units be designed to perform a clearly defined task. For example, a task might consist of filtering certain words in a set of text documents and highlighting them, or sorting the input data according to one or more criteria. Reading and transforming data from sensors also constitute relevant use cases. These tasks may include the processing, extraction, recognition, or interpretation of text, data, code, music, speech, images, or videos. It is desirable that at least some of these functional units be based on artificial intelligence algorithms pre-trained to perform the corresponding task efficiently.

[0014] The structure for making available (or provisioning) the functional units can, for example, take the form of a database grouping several different units, each dedicated to a specific application domain or function. Alternatively, this structure can be implemented as a function allowing dynamic access to such a database, so as to make the units available for subsequent use, in particular via the selection structure.

[0015] The selection structure can then, for example, be implemented as a user interface or be communicatively coupled to a user interface, thus enabling the selection of at least two functional units. However, the selection structure can also be adapted to provide an automatic selection algorithm among the plurality of functional units according to a predetermined target data processing. The selection of the functional units can, for example, be carried out in such a way that the functions Predefined data provided by the selected functional units can be linked to perform a predetermined target data processing. The selected functional units can be linked such that the output data of at least one selected functional unit contains at least some of the input data of at least one other selected unit. The link can, for example, be a parallel link in which the output data of one functional unit provides content used by two other functional units as input data. The link can also be a concatenation, in which the content of the output data of one functional unit is used as input data only by another functional unit. This quasi-flexible form of linking allows complex target processing to be performed with just a few simple functional units.For example, a functional unit can read data from a sensor and store it in a database in a predefined format. Another functional unit can then search for predefined values ​​in the stored data and mark the corresponding entries. Yet another functional unit can then use the marked entries and the provided sensor data to link the sensor values ​​to other data, for example, at a specific time point. A third functional unit, using, for example, an artificial intelligence algorithm, can then be used to determine a pattern in the temporal occurrence of the predefined values. This pattern, whether determined or not, could then constitute a predefined target data processing task, enabling, for example, an operator to determine a sensor malfunction and / or its causes.In these examples, each of the functional units itself is not specifically adapted to process only sensor data, but only performs general data processing steps; the linking of these data processing steps leads only to the specific application using the corresponding data as input to the corresponding target processing of the sensor data, which can lead to the detection of malfunctions.

[0016] The selection structure also provides additional linking information. This specifies the relationships between the selected functional units, defining the data flows between them. This information can also include additional details, such as the exact content of the data transferred from one unit to another. By default, all the output data of a functional unit can be transmitted to the next unit designated by the link.

[0017] The link between the selected functional units is ensured by the interface structure, which plays a central role in the transfer of data between these units. More specifically, this interface is designed to transform at least a portion of the output data from a selected functional unit into input data for a another unit, taking into account both the selected units and the linking information provided.

[0018] For example, this linking information allows the interface to access metadata or descriptors associated with the functional units involved, thus facilitating data transformation. This information may include the expected input and output data formats of each unit, stored either in a database associated with each functional unit or directly integrated into the interface structure. Using this information, the interface can adapt or convert the exchanged data to ensure compatibility between the different functional units.

[0019] The interface is preferably designed as a centralized communication point. It can also be, at least in part, integrated directly into the functional units themselves. For example, a component of the interface can be embedded in a functional unit and manage the reading of data from specific memory locations. In one embodiment, the interface does not rely on traditional function calls passed to the functional units, thereby enhancing the independence of the latter.

[0020] The interface structure may also include a control unit capable of orchestrating the execution order of the functional units according to the linking information. This control unit can also manage processing branches, that is, cases where the data flow diverges or converges between several functional units. It thus allows the overall logic of the target data processing to be predefined and controlled. Importantly, this control unit does not necessarily operate according to a classic hierarchical model, based on the calling of subroutines or subprograms by a main program. On the contrary, it can manage the sequencing of the functional units externally, without requiring direct feedback between the units. The functional units thus retain their autonomy while being sequenced or orchestrated according to a defined logic.The control unit can specify the execution order, manage parallel or sequential flows, merge outputs, or distribute data to multiple branches. It can be configured to call functional units according to a predefined or dynamically generated sequence, based on link information, functional logic, or even using generative artificial intelligence or a control system reactive to external events.

[0021] In all cases, the control unit initiates and drives the sequence of autonomous functional units, without requiring bidirectional interactions with the latter, thus ensuring a high degree of modularity and flexibility in the execution of the target data processing.

[0022] Preferably, the interface transforms the output data into input data by linking its storage location to a predefined location for the corresponding functional unit. The functional unit accesses this location during execution to resolve the link with the input data storage location and access the input data. The data storage location can be stored as a list or matrix, with each entry assigned to one or more functional units and thus used by them for initial access. The data storage location can also be the same for all functional units. In this case, the interface can transform the output data into input data by replacing an existing link to a previous input data storage location with a new link to the current input data.The storage locations for output data, for example in matrix form, can be part of the link information. Furthermore, a concatenation of input and output data and their corresponding storage locations can be stored as part of the link information.

[0023] In one embodiment, at least one of the selected functional units uses an artificial intelligence algorithm to process data. Artificial intelligence algorithms, in particular, rely on predefined input data, including input data structures, which correspond to the input data and data structures with which the corresponding artificial intelligence algorithm was trained. This means that each artificial intelligence algorithm is linked to input information that determines the structure of its input data. More specifically, in this context, the interface allows different artificial intelligence algorithms to cooperate without needing to be trained together or to rely specifically on one another.Therefore, the interface structure allows for the flexible connection of different artificial intelligence algorithms to solve a predetermined task. This makes it possible to solve many different predetermined tasks by simply selecting the appropriate functional units from among the multitude of functional units, without precise knowledge of the input and output data of the algorithms or the corresponding functional units.

[0024] In one embodiment, the transformation consists of providing a data structure for data transfer. This structure organizes at least part of the output data content according to the linking information, so that it can be processed as input data by at least one other functional unit. Preferably, the data structure includes instruction elements, which contain information about the content provided in the data structure and the processing to be applied. These instruction elements These elements allow the interface or functional units to recognize the content of the corresponding data structure and apply the corresponding defined processing. For example, instruction elements can contain information about the storage location of the corresponding content in a database, its retrieval method, or its encoding. During transfer to a corresponding functional unit, the functional unit or interface can then access the corresponding content during the transfer and, for example, perform an encoding transformation if necessary. Furthermore, it is preferable for the data structure to contain reference data, which includes information about the origin of the transformed content and / or the functional unit that uses the transformed data as input.Reference data, embedded within the data structure, also enables the recognition of links between functional units. For example, during subsequent access to the data structure, the interface can use the reference data to identify functional units linked by their corresponding content. The interface can then transfer the corresponding data and, if necessary, transform it. Therefore, it is also preferable for the interface to be adapted, during transformation, to extract and transfer input data from at least one other functional unit, based on the provided data structure. For example, the interface can be adapted to read the information provided by the data structure, such as instruction elements and / or reference data, and perform a transformation to the corresponding input data based on the information provided by the data structure.

[0025] In one embodiment, the interface is designed to use at least one artificial intelligence algorithm to perform the transformation. This algorithm has been trained using historical datasets to transform at least a portion of the output data content of one functional unit into input data of another functional unit, depending on the selected functional units and linking information. In particular, it is preferable that the artificial intelligence algorithm use a data structure such as the one described above to transform the output data into input data. It can, in particular, be trained to perform such a transformation on all combinations of the plurality of functional units.

[0026] In one embodiment, the functional units comprise start units and processing units. The start units process data from external input sources, while the processing units use input data containing the output data content of at least one other functional unit. A selection of functional units always includes at least one starting unit and one processing unit. Defining starting and processing units further simplifies the selection of functional units for processing a given task. Furthermore, during the functional unit selection process, it is possible to verify that at least one starting unit and one processing unit have been selected. If not, an error message can, for example, alert the user and indicate that a corresponding unit is missing or that no link was found.

[0027] In one embodiment, the selection structure is designed to provide a selection algorithm comprising at least one artificial intelligence algorithm designed, based on historical data, to select functional units from among a plurality of functional units according to a predetermined data processing target and to determine the linking information between the selected functional units, so that the predetermined target data processing is performed by the selected functional units. Such a selection algorithm makes it possible to perform automatic selection for a given target data processing without the user needing to know the selected functional units, for example, how generative AI or mathematically controlled AI works.

[0028] The objective is further achieved by an interface structure which provides an interface between selected functional units to transmit data between at least two linked selected functional units, the interface being adapted to transform at least part of the content of the output data of at least one selected functional unit into input data of at least one other functional unit on the basis of the selected functional units and the linking information, a functional unit being adapted to process input data into output data, and the selected functional units being linked in such a way that a predefined data processing is carried out by an interaction of the selected functional units,and the linking comprising that the output data of at least one selected functional unit has data contents that are at least part of the input data of at least one other selected unit, and the linking information comprising information indicating which of the selected functional units are linked to which other functional unit.

[0029] The objective is further achieved by a computer-implemented method for transmitting data between a plurality of functional units, the method comprising a) providing a plurality of different functional units, in which one functional unit is adapted to process input data into output data, b) providing a selection of at least two of the functional units and linking information, in which the functional units selected are linked such that predefined data processing is performed by an interaction of the selected functional units, and wherein the linking includes that the output data of at least one selected functional unit has data contents that are at least part of the input data of at least one other selected unit, and wherein the linking information includes details of which selected functional units are linked to which other functional unit, c) the provision of an interface between the selected functional units to transmit data between linked selected functional units, and d) via the interface,the transformation of at least part of the output data content of the selected functional unit(s) into input data of the other functional unit(s) based on the selected functional units and linking information.

[0030] The object is further reached by a computer program product enabling the transmission of data between a plurality of functional units, the computer program product being adapted to implement the process as described above when executed on a computer architecture as described above.

[0031] It must be understood that the methods, systems and computer programs described above have similar and / or identical preferred embodiments, as defined in particular in the dependent claims.

[0032] In what follows, embodiments of the invention are described with reference to the following figures, in which

[0033] [Fig. 1] Fig. 1 schematically illustrates, by way of example, an embodiment of a system with a computer architecture for transferring data between a plurality of functional units, and

[0034] [Fig.2] Fig.2 schematically shows, by way of example, a process and a flow of data within the system to transfer data between a plurality of functional units.

[0035] Figure 1 schematically illustrates, by way of example, a system 100 with a computer architecture 110 enabling data transfer between several functional units 121. In this embodiment, the system comprises a database 120, a user interface 130, and the computer architecture 110. Several functional units 121 can be used, for example, stored in the database 120. Furthermore, the database 120 can be adapted to store input and output data, link information, etc. The user interface 130 can, for example, be a graphical user interface displayed on a screen and allowing the user to interact with the computer architecture 110.

[0036] The computer architecture 110 can be hardware or software within a computer system, or standalone as a separate computer system. It comprises a functional unit provisioning structure 111, a selection structure 112, and an interface structure 113. This structure is designed to provide several different functional units. For example, it can access the database 120 in order to provide several functional units 121 stored therein for further processing. However, it can also be directly implemented by the database 120, which provides the functional units 121. These functional units 121 can consist of several different data processing algorithms. The functional units preferably include startup units and processing units.Starter units are data processing algorithms that process data from an external source, such as an external database not part of System 100. Processing units are data processing algorithms that use as input content derived, at least in part, from the output of another functional unit. Each of these functional units can perform a different, usually simple, data processing operation. They may, for example, use trained artificial intelligence algorithms to perform a predefined task. A functional task for one functional unit might, for example, be to search for and highlight given words in a large number of texts. Another functional unit might, for example, be designed to extract highlighted passages from text documents and sort them according to a predefined pattern.Other functional units may relate to data classification, text field recognition in forms, context establishment, mathematical linking of numerical values, etc. In principle, each functional unit can solve a task, usually a simple one. However, the combination, and especially the linking, of different functional units also makes it possible to solve predefined complex tasks.

[0037] The selection structure 112 allows a selection to be made from among a plurality of functional units and linking information. This makes it possible to link the selected functional units in such a way that a predetermined task, in particular the processing of target data, can be performed by these units. For example, the user interface 130 allows the user to make a selection from among the plurality of functional units 121 and to determine the content of the output data of one functional unit that will be integrated into the input data of another functional unit. This information can be stored in the linking data and allows the selected link between the functional units to be represented as a data stream. The user interface 130 can be adapted to assist the user to select the functional units, for example by providing a list of starting units and possible processing units. Furthermore, automatic or semi-automatic selection could be ensured, for example through artificial intelligence trained to select from the multitude of functional units and linking data needed to solve a predetermined task. In addition, a tool such as thematic sorting of the functional units and a corresponding presentation can help users select the appropriate functional units and linking information. The selection structure 112 can then be communicatively coupled to the user interface 130 to provide the selected input and linking information for further processing. Moreover, the selection structure 112 itself could be integrated into the user interface 130.

[0038] The interface structure 113 is designed to provide an interface between selected functional units in order to transfer data between selected and linked functional units. More specifically, the interface can use information about the selected functional units and linking information to transform the output data of one functional unit into input data for another functional unit. For example, depending on the selected functional units and the linking information, the interface can determine the content of the output data from one or more functional units to be integrated into the content of the input data of one or more other functional units. The interface can thus be adapted to transform this content into input data that is readable and processable by the corresponding functional unit.For example, the interface can provide a data structure for the inputs of a functional processing unit. Based on the binding information, the data structure can be used to structure the content of the output data so that it can be processed as input data by the bound functional unit. The use of this data structure is detailed in the following description, with a more concrete example.

[0039] In principle, the interface structure 113 can be provided as a standalone function or be at least partially part of each functional unit. For example, each functional unit can be adapted to provide output data in a corresponding data structure, and each processing unit can be adapted to provide input data using that data structure.

[0040] The interface structure 113 thus allows the transfer and processing of very different data contents from different functional units. This offers great flexibility, combined with a wide variety of data processing algorithms provided by the functional units, to solve a multitude of predefined tasks. This avoids the need to create a data processing algorithm A separate, complex process is required for each predefined target data processing task, for example, to train a highly complex artificial intelligence to perform a corresponding target processing task from the planned input data. Instead, a selection can be made quickly and flexibly from relatively simple, pre-existing functional units, which are then linked accordingly to provide the corresponding target processing task. This concept also allows for a high degree of customization of data processing and its adaptation to a wide variety of tasks.

[0041] Figure 2 illustrates a schematic and exemplary method for data processing and the corresponding data flow of a system as described in Figure 1. In this method, several functional units are first provided, for example, by the database 120 and / or the user interface 130. The functional units for processing the target data can then be selected and linked from among these functional units. After selecting and linking the corresponding functional units, the processing of the target data can be initiated with the functional unit. To do this, a first functional unit can be populated, for example, by accessing the functional unit as it is stored in the database 120. During the execution of the functional unit, which is a starting unit, external data can, for example, be read from an external database and processed according to a corresponding algorithm.The corresponding output data produced by the functional unit can then be stored in database 120. From the selected functional units and their linking information, a corresponding data structure can be created from the output data, enabling its transfer to the relevant linked functional unit. Depending on the data structure, the output data can then be transformed into input data for a linked functional unit. This input data can then be transferred to the next linked functional unit, based, for example, on the linking information. After the input data has been processed by the next functional unit, which is a processing unit, it is possible to verify whether the processing of the target data is complete.For example, it is possible to check whether other functional units are used or linked, or whether a predefined target data processing specification has been defined. If not, the algorithm can again store the corresponding output data from the functional unit and repeat the corresponding transfer to the next functional unit. Once the target data processing is complete, it can be stopped and, for example, a corresponding result can be provided to the user.

[0042] Some preferred embodiments are described in detail below. In one embodiment, the system includes the database, which comprises several Functional units. These functional units are also called "roperators" below. Preferably, a roperator can combine an operator and an artificial intelligence algorithm. More specifically, roperators process information from input data to output data. For a roperator, there can be n (n = natural number) input data streams and n output data streams. The input data streams can be processed in parallel or sequentially. The output data streams can also be generated in parallel or sequentially. Preferably, the database can provide startup roperators and processing roperators. The startup roperators can be adapted to read input data from databases, files, or external streams and make it available as output data, described in more detail below.This output data can then be used by the next roperator(s). Roperators that process the output data of another roperator as input data are called processing roperators. Starter operators possess the properties of elements from classic programming languages, such as loops over elements or triggers on events, but can also utilize artificial intelligence algorithms. Furthermore, functional collection units, called collection operators, can be provided, tailored to processing the final result of the target data and, for example, its graphical display.

[0043] During the processing of target data, the startup operators can read input data from files, emails, voice files, images, videos, etc., and convert it so that it is available to the processing operators. For example, the interface, or a part of the interface (the startup operator part), can be adapted to store the output data in a predefined storage location. Several processed input data sets can be stored by the interface in different output data sets, as described in more detail below. For example, the interface can store the output data as a data structure comprising a descriptive element, for example, an identifier, and a link to a storage location for the output data in the database.The startup operators, in collaboration with the interface, prepare the input data so that the processing operators can use it.

[0044] The processing operators can then read the input data, and the interface, part of which can also be integrated into the processing operators, can then store the output data as input data in the predetermined memory location, so that the next processing operator can access it again to retrieve the input data. In this embodiment, the Data is transferred via the interface by storing the corresponding data in a predetermined memory location. It's important to note that the memory location does not refer to the actual storage location of the data on the hard drive, but rather to a memory location that operators access and that has a corresponding link to the actual data storage location. For example, this can be implemented using a list or matrix data structure where operators access predetermined list or matrix locations, and the interface is adapted to link the operator's input data to that list or matrix location. For simple processing, a single list location may suffice.

[0045] Furthermore, output operators can be defined as specific processing operators. They can be adapted to synthesize the results of processing the target data into a predefined form, according to the user's requirements. They can, for example, access the output data. It is also possible to process the output data of an entire string. This data can then be synthesized into the desired form to produce the desired result.

[0046] The type of a robot can be determined by its identifier (ID), i.e., its name. For example, robots can be converters or collectors: a converter converts input data to produce output data, and a collector gathers input data from various sources to produce output data. This can be reflected in the nomenclature. For example, the nomenclature of a robot can be defined as follows:

[0047] Function_FormatFromTo_#Input2#Output_ID

[0048] so for example

[0049] OCR_ODF2TXT_121_243546

[0050] Summary Excel_TXT2XLS_n21_321539

[0051] Reader LIS_LAB2TXT_121_426437

[0052] where the ID is arbitrary but unique for each Roperator - this is used to distinguish Roperators of different generations and versions when the functions are the same but the design is different.

[0053] The various Roperators provided can be linked to perform the processing of the target data. This link can be ensured by linking information, which determines which data content is generated by which Roperator and subsequently processed by which other Roperator. This makes it possible to determine how data flows from one Roperator to another. Two Roperators are linked if one uses the output data content of another Roperator as input data. To allow the exchange of data between linked Roperators and minimize the consumption of computing resources, the system includes a structure interface. This structure transforms the output data of a Roperator into input data for a linked Roperator. Preferably, the transformation uses a predetermined data structure. This data structure can contain several different data elements. Preferably, it includes an instruction element. These instruction elements can be provided, for example, as metatags and can define the form in which the content of the data structure should be processed. This allows data to be provided in different forms, with the instruction elements then containing information about the provided data and allowing control over its transmission to the linked operators. The instruction elements can thus define a deviation from the input format of a linked operator without leaving the interface.This allows for a self-adaptive interface description, meaning that the interface can be defined in the data structure via the instruction element and correctly interpreted by the receiving operator. Such an interpretation can, for example, be provided by an input artificial intelligence receiving the operator to translate the input data according to the operator's needs; that is, the data can then only be transmitted to the bound operator in an interpretable form.

[0054] Preferably, the data structure includes a reference element that allows the origin of the data content, its content, its encoding, etc., to be determined. The structure then identifies the corresponding content. This could be, for example, text, 2D or 3D images, 2D or 3D videos, databases, expert systems, and / or signals of any kind, including voice input elements. Input data from the linked processors can be extracted from this data structure.

[0055] The output data of a Roperator can be divided into different output elements, the presence of which is not mandatory. For example, output elements may contain data to be transferred to other linked Roperators, which can then be transferred as input data to other Roperators via an interface. In addition, the output data may contain data elements used for final processing, for example, output data generated as intermediate results or final results generated in the meantime and intended for use in the final results.

[0056] A Roperator can then be a task processor, itself composed of one or more of the following elements. For example, a Roperator may have input data analysis functions. These elements may also have their own artificial intelligence to interpret the input data and transmit it to the elements described below. A Roperator may also integrate process control elements, for example, exploration robots via directories or loops. Preferably, a Roperator has generative artificial intelligence. or an extended language model. Furthermore, a Roperator can integrate natural language processing, a classical program, an expert system, and / or a regular expression processor. A Roperator can also have its own intrinsic database with its own input and output elements depending on the input data. Additionally, a Roperator can have a connection element to other external databases with query options to generate output data. Finally, a Roperator can provide an automation tool for the automated control of other programs or operating system elements. These Roperator elements can process input data and provide output data that can be passed to other linked Roperators via the interface.

[0057] A Roperator can also contain a persistent database structure. Depending on its function, it can execute functions on this database and provide the result.

[0058] The system may also include a database structure. This can be adapted to coordinate and organize the processing of robots. It may include a robot and an input and output database. This database, in text or database form, can contain all the elements of each robot, for example, text, code, images, videos, etc. These elements can be stored, and their storage locations can be recorded in the transfer data structure, for example, as metatags. The following example can serve as a functional example for a concrete implementation: the storage locations of the robot's elements, for example, the code or the output data, can be provided by a single descriptive data element.This descriptive data element can be or include a meta tag containing a description, such as an identifier, the stored elements and their respective storage locations, and optionally, if there are multiple stored elements, a reference to the next descriptive data element using a meta tag. Descriptive data elements can thus form a chain of descriptive data elements, with the first referencing the next. The starting point of the first descriptive data element can, for example, always be stored in the same location. Therefore, each Roperator, starting from the first known and always identical storage location, processes all the stored elements it references as input data and stores the output data in the database. Each output element can then again have a descriptive data element with a meta tag.Once the processing is complete, the first data element is placed in the same storage location as the first input element by modifying the output data's meta tag. This allows the next Roperator to begin its work in the same location. The input storage is known only to the previous Roperator, without requiring information about its functionality. Therefore, information about the input and output data used by the Roperator is provided completely independently of the higher-level control program, the higher-level control database, or the higher-level generic control AI. Specifically, the database can also store intermediate or final results of the target data processing. It can also store and make accessible all the elements mentioned above, such as input and output data. Furthermore, it can be part of the interface and configured to control data flows between linked operators, as described in the example above, by modifying metadata.As an integral part of the interface, the database thus makes it possible to link the operators together and to control their inputs and outputs.

[0059] The linking of operators via the interface can be controlled and dynamically adapted in various ways. For example, the linking can be performed via a graphical interface, an API, a command line, etc. An algorithm and / or generative artificial intelligence can be used. The artificial intelligence can be trained to link the operators independently. To this end, it can be adapted to perform a preliminary analysis of the target data processing, so as to construct the resulting combination and sequence of operators.

[0060] The linking of roperators can, for example, be controlled via the interface as a meta-level. The interface or the interface structure can be configured to incorporate a control unit capable of controlling the sequence of the different roperators based on the linking information. For example, the control unit can read the roperator call order from the linking information. This means that it can use the sequence provided by the linking information, for example, after receiving a signal indicating the end of data processing by a roperator, or after the elapsed of a predetermined time, to call the next roperator(s). The control unit does not need to exchange any additional information with the roperators. Each roperator can thus be configured to process the target data independently of all linked upstream and downstream operators.Ideally, no roperator knows its position in the overall workflow. Roperators can therefore be configured to act independently of the overall workflow sequence. This has the advantage of allowing the overall workflow composition of all roperators to be generated automatically, for example, using generative AI.

[0061] The following example describes a preferred embodiment of the interface. In this embodiment, the interface is designed to provide a stack, for example of blocks, in a database, which robots can access. The stack can be considered as a list or matrix provided in the binding data. For example, The interface can provide the stack in such a way that robots can process all blocks of the stack according to their task (121, n21, 12n...) within a fixed and predefined area. Robots can store their output data in a different storage location, possibly in a defined order. In particular, the interface can be adapted to transform a link between an output block of one robot and an input storage location of another robot, so that the next robot finds the robot's output data at its defined input location and, from there, by following the link, can directly access the output data as input data, without predetermination. Furthermore, the interface can also link the output data of a processing operator, as intermediate results, to a memory location, for example, in a block that no longer needs to be processed by subsequent processing operators.For example, such an intermediate result can be stored under this name with the ID InputNDesc of a processing operator, with processing operators configured to ignore this ID.

[0062] Preferably, Roperators are adapted to provide part of the interface as a mini-infrastructure dedicated to managing input and output data. For example, there may be one or more input data items, such as blocks, videos, images, etc. This input data is usually stored in a database as a block. This is why they are used as an example below. In this example, a description, such as an identifier, can be provided for each input and output data item, usually in a different NoSQL database. If there are multiple input data items, an indication, such as a link, can be provided, indicating where the next block is located or whether the input data string terminates in the current block. For example, a notation might take the following form:

[0063] Input1Block, Input2Block, Input3Block and associated

[0064] Input1Desc, Input2Desc, Input3Desc,

[0065] InputlDesc is the main input from which the operators start. In this example, InputlBloc is located here and knows the reference to Input2Desc. Similarly, Input2Desc knows the reference to Input2Bloc and Input3Desc. This allows the contents of these blocks to be processed in a loop. This could be represented, for example, as follows:

[0066] For each entry - except the intermediate result - do:

[0067] In particular, the control can adapt a robot operator to process a new input or, if it is marked as an intermediate result of a previous robot operator, to ignore it but pass it on as a new input to the next operator.

[0068] After processing, all results can be saved; in this example, 2 output files, the number of output files not needing to be related to the The number of input files and the number of output files are determined solely by the Roperator's functions, for example:

[0069] Output1Bloc, Output2Bloc and associated

[0070] SortielDesc, Output2Desc

[0071] All data can be managed in these data structures created by the interface using references, i.e., links. After all files have been processed, the references to the output files can be saved as new input files by the interface, for example:

[0072] ExitDesc —> Entry 1 Desc ,

[0073] Exit2Desc —> Inlet2Desc ,

[0074] so that the next Roperator can access InputlDesc as a starting point. If the provided data structure mentions properties that a Roperator cannot use functionally, these can simply be added to the input string—that is, ignored but passed through. In a specific use case, a Queryaire's query on all elements of a file server in an intermediate state might then look like this:

[0075] InputlDesc with Desc "Questionnaire",

[0076] Input2Desc with Desc "File Server"

[0077] InputNDesc with Desc "Intermediate Result",

[0078] EntryN+lDesc with Desc "Intermediate result".

[0079] In this example, each Roperator is configured to access InputlDesc, regardless of what its predecessors have left behind. This means that no Roperator needs to know the past or future actions of other Roperators. Thus, the interface, which can also be implemented within the Roperators, provides the framework for managing input and output, with the Roperators performing the functions for which they are intended, from input to output.

[0080] In principle, robots can be adapted to be called externally, for example in a Python program. This allows the interface to be adapted to control the actual execution of the robots based on link information. The interface can also be adapted to dynamically generate a framework, for example via AI or other rule sets.

[0081] The interface and / or database structure can also be adapted to query security features and permissions. In principle, the composition of ropers and links can be automatically checked and corrected by a validation instance.

[0082] Thanks to the invention described above, several AIs can be combined with classical elements to create a highly improved summation AI. This significantly improves performance compared to ChatGPT, for example, and allows both the processing of massive amounts of data and the handling of specialized, extremely complex AI tasks that were previously impossible to solve.

[0083] In the claims, the words "comprising" and "including" do not exclude other elements or steps, and the indefinite article "a" does not exclude a plurality.

[0084] A single unit or device can perform the function of several elements listed in the claims. The fact that individual functions and / or elements are listed in different dependent claims does not mean that a combination of these functions or elements could not also be advantageously used.

[0085] The processes described above, executed by a certain number of units, can also be executed by a different number of units. In particular, these processes can be executed using a single, suitable unit. One or more computer systems and their output devices, such as monitors or screens, can be adapted to execute the processes described. These processes, in particular the computer methods described above, can be implemented as computer program code and / or corresponding hardware.

[0086] A computer program can be stored on a suitable medium, such as an optical medium or a semiconductor storage medium. The stored computer program can be distributed with or as a component of other hardware. It can also be distributed in other forms, for example via the Internet or other telecommunications systems.

[0087] The reference signs in the claims should not be understood as limiting the object and scope of the protection of the claims by those reference signs.

[0088] The invention relates to a computer architecture enabling data transfer between several functional units. A functional unit supply structure provides a plurality of functional units. A selection structure provides a selection of functional units and linking information, the selected functional units being linked to perform predefined data processing. An interface structure provides an interface enabling data transfer between selected and linked functional units, this interface being designed to transform at least a portion of the output data content of the selected functional unit into input data of the other functional unit, depending on the selected functional units and the linking information.

Claims

Demands

1. A computer architecture for transferring data between several functional units, comprising: a functional unit (111) supply structure (121) adapted to supply a plurality of different functional units, a functional unit being adapted to process input data into output data, a selection structure (112) adapted to supply a selection of at least two functional units and linking information, the selected functional units being linked such that predefined data processing is performed by an interaction of the selected functional units, the linking being such that the output data of at least one selected functional unit has a data content that is at least a part of the input data of at least one other selected unit,and linking information including information indicating which of the selected functional units are linked to which other functional unit, an interface structure (113) providing an interface between the selected functional units for transferring data between linked selected functional units, the interface being adapted to transform at least a part of the content of the output data of the selected functional unit(s) into input data of the other functional unit(s) on the basis of the selected functional units and the linking information.

2. Computer architecture according to claim 1, wherein at least one of the selected functional units (121) uses an artificial intelligence algorithm to process data.

3. Computer architecture according to any one of claims 1 or 2, wherein the transformation provided by the interface structure (113) includes the provision of a data structure for transferring data, the data structure structuring, on the basis of the linking information, at least a part of the content of the output data so that it can be processed as input data by the other functional unit(s) (121).

4. A computer architecture according to claim 3, wherein the data structure comprises instruction elements, the instruction elements including information on the content provided in the data structure and the processing steps to be applied.

5. Computer architecture according to any one of claims 3 or 4, wherein the data structure includes reference data, the reference data containing information about the origin of the transformed content and / or about the functional unit (121) which uses the transformed data as input data.

6. Computer architecture according to any one of claims 3 to 5, wherein the interface (113) is adapted to extract and transmit input data for at least one other functional unit (121) on the basis of the data structure provided as part of the transformation.

7. A computer architecture according to any one of the preceding claims, wherein the interface (113) is adapted to use at least one artificial intelligence algorithm to perform the transformation, wherein the artificial intelligence algorithm(s) have been trained using historical datasets to transform at least a portion of the output data content of one functional unit into input data of another functional unit based on the selected functional units and linking information.

8. Computer architecture according to any one of the preceding claims, wherein the functional units (121) comprise startup units and processing units, wherein the startup units process data from external data sources as input data and the processing units use input data comprising contents from the output data of at least one other functional unit, wherein a supplied selection of functional units always comprises at least one startup unit and one processing unit.

9. A computer architecture according to any one of the preceding claims, wherein the selection structure (121) is adapted to provide a selection algorithm, the selection algorithm comprising at least one adapted artificial intelligence algorithm, based on historical data, for selecting functional units from among the plurality of functional units on the basis of a predetermined data processing target and to determine link information between the selected functional units such that the predetermined target data processing is carried out by the selected functional units.

10. Interface structure (113) providing an interface between selected functional units (121) for data transmission between at least two linked selected functional units, said interface being adapted to transform at least a part of the content of the output data of at least one selected functional unit into input data of at least one other functional unit, based on the selected functional units and linking information, one functional unit being designed to transform input data into output data, the selected functional units being linked so as to perform predefined data processing by interaction.The link includes output data from at least one selected functional unit containing at least part of the input data from at least one other selected unit, the link information including information indicating which of the selected functional units are linked to which other functional unit.

11. A computer-implemented method for transferring data between a plurality of functional units, the method comprising the steps of: providing a plurality of different functional units, in which one functional unit is adapted to process input data into output data; selecting at least two of the functional units; and linking information, in which the selected functional units are linked such that predefined data processing is carried out by an interaction of the selected functional units, and in which the linking includes that the output data of at least one selected functional unit has data contents that are at least a part of the input data of at least one other selected unit.and in which the linking information includes information indicating which of the selected functional units are linked to which other functional unit, providing an interface between the selected functional units to transfer data between the linked selected functional units, and, transforming, via the interface, at least part of the content of the output data of the selected functional unit(s) into input data of the other functional unit(s) based on the selected functional units and linking information.

12. A computer program product for transferring data between several functional units, said computer program product being designed to implement the method according to claim 11 when executed on a computer architecture according to any one of claims 1 to 9.

Images