EP4490607A1 - Verfahren und computerprogramm zur automatisierten erzeugung von kommunikationsschnittstellen in algorithmen aus dem bereich der künstlichen intelligenz - Google Patents
Verfahren und computerprogramm zur automatisierten erzeugung von kommunikationsschnittstellen in algorithmen aus dem bereich der künstlichen intelligenzInfo
- Publication number
- EP4490607A1 EP4490607A1 EP23719674.6A EP23719674A EP4490607A1 EP 4490607 A1 EP4490607 A1 EP 4490607A1 EP 23719674 A EP23719674 A EP 23719674A EP 4490607 A1 EP4490607 A1 EP 4490607A1
- Authority
- EP
- European Patent Office
- Prior art keywords
- source text
- communication interface
- computer program
- semantic
- library
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
Classifications
-
- G—PHYSICS
- G06—COMPUTING OR CALCULATING; COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
-
- G—PHYSICS
- G06—COMPUTING OR CALCULATING; COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Prevention of errors by analysis, debugging or testing of software
- G06F11/3668—Testing of software
-
- G—PHYSICS
- G06—COMPUTING OR CALCULATING; COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/36—Software reuse
-
- G—PHYSICS
- G06—COMPUTING OR CALCULATING; COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/54—Interprogram communication
- G06F9/547—Remote procedure calls [RPC]; Web services
-
- G—PHYSICS
- G06—COMPUTING OR CALCULATING; COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/35—Creation or generation of source code model driven
Definitions
- the invention relates to a method and a computer program for producing a further computer program product based on a source text of artificial intelligence algorithms.
- Specialized software tools have become known for developing algorithms and procedures in the field of artificial intelligence. These software tools, such as “Jupyter Notebooks” (see also https://jupyter.org/), are suitable for supporting iterative and exploratory work by so-called data scientists during the development of artificial intelligence algorithms.
- Providing a communication interface generator for generating at least one communication interface d. Analyzing the source text using the source text analysis component for the presence of the semantic annotations in the source text and passing the logic sequences from the library, which are clearly linked to the existing semantic annotations in the source text, to the communication interface generator; e. Reading out the transferred logic sequences that are clearly linked to the existing semantic annotations in the source text by the communication interface generator and f. Generating communication interfaces using the communication interface generator based on the read out logic sequences; G. Embedding the generated communication interfaces into the computer program product to be manufactured.
- the method according to the invention is a computer-implemented method.
- a source text provided with semantic annotations i.e. a source text with at least one source text construct, which is marked with at least one semantic annotation from the library of semantic annotations, is used as input and from this, in particular dynamically at runtime, a computer program product, especially an API product.
- a computer program product generated in this way includes communication interfaces for embedding the artificial intelligence algorithms of the source text, including the artificial intelligence algorithms, into applications or processes.
- the process is used in the development of the 202208051 Post-registration version Applications or processes used for the automated generation of the communication interfaces and for embedding the artificial intelligence algorithms called by the communication interfaces into the generated computer program product.
- a computer program product according to the invention for producing a further computer program product comprises instructions which, when the program is executed by a suitable computer, cause it to carry out the method according to the invention.
- the computer for executing the computer program product according to the invention can be a terminal or a server.
- Computer program products can also be referred to simply as computer programs.
- “manufacture” can also be referred to synonymously as “create” or “generate”.
- the method thus causes the creation of a computer program product based on a source code of artificial intelligence algorithms.
- the corresponding computer program product according to the invention serves analogously to create a further computer program product.
- the “further” computer program product refers to the computer program product produced or created when carrying out the method according to the invention.
- the term computer program is referred to below when the computer program product is meant for the production or creation of the (further) computer program product to be created or manufactured.
- the computer program product produced or created using this computer program when carrying out the method according to the invention is, however, referred to as a computer program product.
- Post-registration version refers to computer program products that, for example, access the communication interfaces of the generated computer program product.
- the source text is read in by the computer program according to the invention to produce a computer program product and is also executed according to an embodiment of the invention.
- the source text remains untouched. No lines of code relating in particular to the communication interfaces are added and written into the source code. Rather, the semantic annotations serve as a kind of jump label, which can be referenced with the communication interfaces created and the marked source text constructs can be addressed.
- no communication interfaces may be defined in the source code.
- the computer program comprises in particular - a library of semantic annotations comprising - semantic annotations for marking source text constructs of the source text of artificial intelligence algorithms; - Logic sequences clearly linked to the semantic annotations for generating communication interfaces and for embedding the marked source text constructs in the computer program product to be produced; - a source code analysis component, suitably designed 202208051 Post-registration version - for analyzing the source text for the presence of semantic annotations in the source text; - for the transfer of the at least one logic sequence from the library, which is clearly linked to the at least one existing semantic annotation in the source text, to the communication interface generator - a communication interface generator, suitably designed - for reading out the at least one transferred one the logic sequence linked to at least one existing semantic annotation in the source text; - to generate at least one communication interface based on the read logic sequence.
- the at least one communication interface is preferably generated as a standardized programming interface, English Application Programming Interface (API for short), for example as a “REST” interface, using the communication interface generator and according to method step g. embedded in the computer program product, which if necessary according to method step h. provided.
- the communication interface generator is designed accordingly.
- the provided library of semantic annotations includes at least one semantic annotation and at least 202208051 Post-registration version a logic flow that is clearly linked to the at least one semantic annotation.
- the library of semantic annotations provided includes any number of semantic annotations and logic sequences clearly linked to them.
- Each semantic annotation therefore has a logical sequence that is clearly linked to it.
- the plural is mainly used below in connection with the at least one semantic annotation and the at least one logic sequence that is clearly linked to it.
- Semantic annotations are predefined markings with which certain parts of the source text, the so-called source text constructs, in particular certain functions and function parameters or input or output variables or results of the artificial intelligence algorithms, are marked or, in particular, can be marked subsequently. Accordingly, they can also be referred to as semantic source code annotations.
- Each of these markings has a predetermined logic sequence that determines when and how the marked source code constructs are called.
- Each logic sequence therefore includes a predetermined rule for generating a communication interface and thus for further processing, in particular for execution, and embedding the source text constructs of the artificial intelligence algorithms marked with the semantic annotations in the generated computer program product.
- the semantic annotations and the logic sequences associated with them serve two different purposes: On the one hand, they indicate for which parts of the source text communication interfaces, in particular APIs, should be created. On the other hand, they indicate which information should be exchanged as a request and response via these communication interfaces.
- 202208051 Post-registration version Semantic annotations hide all the technical details of the communication interfaces to be generated: The respective source text markings only capture the semantic meaning of the annotated source text constructs and do not allow any conclusions to be drawn about the communication interfaces to be generated.
- a source text analysis component for analyzing the source text for the presence of the semantic annotations from the library in the source text and a communication interface generator for generating at least one communication interface.
- the source code analysis component is responsible for accessing the library. This component examines the source code passed to it for the presence of markings with the semantic annotations that are stored in the library. To do this, the source text can first be searched for markings with semantic annotations and these can be compared with the semantic annotations stored in the library.
- the logic sequences assigned to the recognized semantic annotations and clearly linked to them are then transferred from the library to the communication interface generator.
- selected source text constructs relating to certain artificial intelligence algorithms are annotated, i.e. marked with the semantic annotations according to the library, which means that the input or output of values to or from the Algorithms are determined by the predefined logic sequences that are clearly linked to the semantic annotations.
- the algorithm developer especially the data scientist, knows best about the algorithms and how they should be called. However, he does not have to worry about the specific design of the communication interfaces for accessing the algorithms. This is done automatically by the computer program according to the invention.
- a further advantage of the invention is that no additional, specialized software developer is required to create and configure the communication interfaces. Process step a.
- the computer program for producing a computer program product can accordingly have an input interface which is suitable for: - reading the source text of artificial intelligence algorithms comprising the semantic annotations for marking source text constructs of the source text of artificial intelligence algorithms in the source text; - Passing the read source code to the source code analysis component.
- method step d. includes: d. Analyzing the source text using the source text analysis component for the presence of semantic annotations in the source text and passing on the logic processes from the 202208051 Post-registration version of the library, which is clearly linked to the existing semantic annotations in the source code, and transfer of the configuration templates from the library, which are clearly linked to the passed logic sequences, to the communication interface generator; and wherein method step e. includes: e.
- the generation and provision of at least one configuration interface for configuring the configuration parameters of the at least one transferred logic sequence by means of the communication interface generator based on the at least one read-out logic sequence and based on the at least one read-out configuration template serves in particular to modify the configuration parameters of the with the one read out 202208051 Post-login configuration template clearly linked, read logic flow dynamically at runtime.
- a modification can include a change or adjustment and, if necessary, an expansion, deletion or addition to the configuration parameters of the logic processes. The modification can be carried out manually by a user or can be carried out automatically via the configuration interface using other computer program products.
- the configuration parameters of the read logic sequence that is clearly linked to the read configuration template can be read out via the configuration interface provided and made available to the user for manual modification, for example via a web application, in particular output on a screen, for example in a representation of a form .
- the modifications are determined, for example, by changing predefined values.
- the modifications made, for example by the user or another computer program product, are recorded and transmitted to the communication interface generator using the configuration interface.
- the modifications transferred via the configuration interface are read out by the communication interface generator and the logic sequence read out from the library is modified by the communication interface generator based on the modifications read out.
- There is now a logic sequence in the communication interface generator which can have modified configuration parameters compared to the original logic sequence from the library.
- method step ee comprises. henceforth: ee. Receiving modifications of at least one configuration parameter of the at least one read-out logic sequence by the communication interface generator via the configuration interface and modifying the at least one configuration parameter of the at least one read-out logic sequence by the communication interface generator.
- method step f. further comprises: f. Generating at least one communication interface by means of the communication interface generator based on the at least one read and modified logic sequence.
- the communication interfaces subsequently created and provided are also modified through modifications to the logic processes.
- a communication interface that has been created can no longer be modified from the outside. Only internal processes, such as a running counter, can adjust parameters.
- the computer program product generated according to the invention includes all communication interfaces, but according to one embodiment is provided without configuration interfaces. API products can thus be made available to a user “as a service” without them themselves 202208051 having to configure post-registration registration. It is not necessary to embed the generated configuration interface into the computer program product.
- the logic sequences from the library can be preset with standard values (default) so that communication interfaces can be created and provided without modifications.
- the parameters are advantageously configured during the runtime of the method according to the invention or during the runtime of the computer program product according to the invention.
- the generation of the communication interface and, if applicable, the configuration interface in accordance with the corresponding method steps also preferably takes place during the runtime of the method according to the invention or at the runtime of the computer program according to the invention. All other method steps, such as analyzing the source text or embedding the generated communication interfaces in the computer program product, also take place at runtime of the computer program according to the invention.
- the library of, if necessary, any and/or any number of semantic annotations can be expanded. This can also be done during the duration of the process, but in any case before process step d. take place. Accordingly, process step d.
- Extension, deletion or change, in particular addition or adaptation, of the contents of the library of semantic annotations provided thus includes the extension, deletion or change, in particular addition or adaptation, of the semantic annotations, i.e. the expressions for marking the source text constructs as such with the logic flows clearly linked to the semantic annotations and, if applicable, the configuration templates that are clearly linked to the logic flows.
- the contents of the library of semantic annotations can be read out via the input interface provided and made available to the user for manual expansion, deletion or modification, for example via a web application, in particular on a screen.
- the additions, deletions or changes made, for example by the user or another computer program product, are recorded and written back into the library using the input interface.
- the input interface can also be used to expand, delete or change the source text, in particular read in using the input interface, and in particular to add, delete or adapt semantic annotations of source text constructs.
- the input interface is designed accordingly.
- a further developed computer program for producing a computer program product accordingly includes an input interface for expansion, deletion or change, 202208051 Post-registration version, in particular supplementing or adapting the contents of the library provided and/or for marking at least one source text construct of the source text with at least one semantic annotation from the library.
- the communication interfaces created make it possible to transfer inputs, for example values, to the artificial intelligence algorithms, for example also via a network, or to output corresponding values from the artificial intelligence algorithms, for example also via a network.
- the source text constructs of the artificial intelligence algorithms of the source text marked with the semantic annotations from the library each describe at least one algorithm for the regulation, control or diagnosis of technical devices or systems.
- the at least one generated and provided communication interface serves to embed, for example for execution and access via a network, the at least one source text construct marked with the at least one semantic annotation of the artificial intelligence algorithms of the source text comprising the artificial intelligence algorithms of the control , control, diagnosis or monitoring and/or simulation of technical devices such as machines or systems.
- the provided source text of artificial intelligence algorithms comprising at least one semantic annotation of at least one source text construct, is first passed on to the source text analysis component using an input interface.
- a correspondingly developed computer program includes an input interface for reading in the source text and for passing the source text to the source text analysis component.
- the input interface is designed to be suitable for reading in a source text of artificial intelligence algorithms comprising semantic annotations as expressions for marking source text constructs of the source text of artificial intelligence algorithms in the source text.
- the input interface is designed to be suitable for transferring the source text to the source text analysis component.
- the communication interfaces can be easily controlled by omitting or adding semantic annotations.
- the resulting API product can therefore be ideally tailored to the user’s requirements.
- Reusability of the generated API products in different contexts The semantic annotations can be configured with parameters as required. This configuration only takes place during runtime of the API product via a configuration interface provided for this purpose. This makes it possible for the same source code to be used in different contexts, e.g. for different users and/or projects, since it can be dynamically adapted to the applicable requirements during execution.
- Expandability The library of semantic annotations used by the invention can also be supplemented with any additional annotations.
- This extension mechanism also allows the present invention to be used in foreign application areas outside of the production of artificial intelligence algorithms and methods, if suitable semantic annotations are created for this purpose. Since the source text markings of the semantic annotations do not contain any information about the communication interfaces to be created, it is with them 202208051 Post-registration version Help also possible to map already annotated source text to other communication interfaces at a later point in time. This increases the future-proofing and flexibility of the API products created with the present invention, as any technology migrations can be carried out later without the involvement of the original authors.
- the computer program product generated represents the immediate process product according to the method according to the invention, as well as the product which is produced using the computer program according to the invention to produce a further computer program product. It may be stored on a disk.
- the invention allows numerous embodiments. It is explained in more detail using the following figure, in which an example embodiment is shown.
- the figure shows a schematic overview of the invention.
- a library 1 with any number of semantic annotations SA 1 ... SA n (with n a natural number greater than 1) is provided.
- Each of the semantic annotations SA 1 ... SA n represents an expression for marking a source text construct of a source text using artificial intelligence algorithms.
- SA n - shown here under the same entry in the library - are a configuration template KV 1 ... KV n and a logic sequence LA 1 ... LA n , in which the annotated source text construct is embedded at runtime.
- a source code analysis component 2 a communication interface generator 3 and a 202208051 Post-registration version communication interface provision component 4 provided.
- the arrows between the modules indicate their connections to each other. According to the arrow from Library 1 to Code Analysis Component 2, Code Analysis Component 2 uses the library.
- the source code analysis component 2 uses the communication interface provision component 4 and the communication interface generator 3, which is illustrated with the corresponding arrows between the modules mentioned.
- the communication interface generator 3 is used by the communication interface provisioning component 4.
- source code constructs of the source code are marked by artificial intelligence algorithms.
- This source text is read in and analyzed for the presence of corresponding semantic annotations in the library using the source text analysis component 2. If source text constructs marked with semantic annotations from the library are identified in the source text, communication interfaces are generated by means of the communication interface generator 3 based on the logic sequences clearly linked to the identified semantic annotations and provided by means of the communication interface provision component 4. This will be outlined in more detail below using a greatly simplified example implementation. 202208051 Post-registration version First, a source code is generated using artificial intelligence algorithms, for example by a data scientist, whose algorithms are converted into an API product.
- the following information is recorded in the example: i. Marker to be used in the source code; ⁇ Example: @InteractivePrediction to denote a prediction function; ii. Logic flow in which the annotated source code construct is embedded at runtime; ⁇ Example: Logic flow in which a prediction function annotated with @InteractivePrediction is embedded: ⁇ Validation of the user request, 202208051 Post-registration version ⁇ Execution of the annotated prediction function, ⁇ Persistent storage of the prediction result to enable later traceability, ⁇ Sending the prediction result as a response to the user; iii.
- Configuration template that contains the definitions of all configuration parameters with which the logic flow can be dynamically modified at runtime depending on requirements;
- This example implementation of the invention is written in the Python programming language. It is suitable for creating API products from Python source code that has been created with any Python libraries available on the market in the area of data analysis and artificial intelligence. This covers the relevant use cases in the areas of data analysis and artificial intelligence. The semantic annotations are implemented using so-called Python decorators.
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Software Systems (AREA)
- General Engineering & Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Computer Hardware Design (AREA)
- Quality & Reliability (AREA)
- Stored Programmes (AREA)
Abstract
Description
Claims
Applications Claiming Priority (2)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| DE102022204238 | 2022-04-29 | ||
| PCT/EP2023/059485 WO2023208578A1 (de) | 2022-04-29 | 2023-04-12 | Verfahren und computerprogramm zur automatisierten erzeugung von kommunikationsschnittstellen in algorithmen aus dem bereich der künstlichen intelligenz |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| EP4490607A1 true EP4490607A1 (de) | 2025-01-15 |
Family
ID=86226392
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| EP23719674.6A Pending EP4490607A1 (de) | 2022-04-29 | 2023-04-12 | Verfahren und computerprogramm zur automatisierten erzeugung von kommunikationsschnittstellen in algorithmen aus dem bereich der künstlichen intelligenz |
Country Status (4)
| Country | Link |
|---|---|
| US (1) | US20250291704A1 (de) |
| EP (1) | EP4490607A1 (de) |
| CN (1) | CN119234208A (de) |
| WO (1) | WO2023208578A1 (de) |
Family Cites Families (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US9274755B2 (en) * | 2012-09-05 | 2016-03-01 | Red Hat Israel, Ltd. | Infrastructure for generating code using annotation and template generators |
-
2023
- 2023-04-12 CN CN202380036903.2A patent/CN119234208A/zh active Pending
- 2023-04-12 US US18/861,294 patent/US20250291704A1/en active Pending
- 2023-04-12 EP EP23719674.6A patent/EP4490607A1/de active Pending
- 2023-04-12 WO PCT/EP2023/059485 patent/WO2023208578A1/de not_active Ceased
Also Published As
| Publication number | Publication date |
|---|---|
| US20250291704A1 (en) | 2025-09-18 |
| WO2023208578A1 (de) | 2023-11-02 |
| CN119234208A (zh) | 2024-12-31 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| DE69327318T2 (de) | Unterstützung für systementwicklung. | |
| DE102020112347A1 (de) | Verfahren und einrichtungen zum automatischen erzeugen von code für grafische benutzeroberflächen | |
| DE19960050A1 (de) | Grafische Benutzerschnittstelle zur Entwicklung von Anwendungsbeispielen unter Verwendung einer Testobjektbibliothek | |
| EP2330469B1 (de) | Verfahren und Entwicklungsumgebung zur Erzeugung eines ausführbaren Gesamtsteuerungsprogramms | |
| EP3543844B1 (de) | Verfahren zum durchführen von änderungen an einer software-anwendung | |
| EP3365891B1 (de) | Sprachgesteuertes system | |
| EP3032408B1 (de) | Verfahren zur erzeugung von lauffähigen applikationen mit dynamischen skalierbaren vektorgrafiken | |
| WO2021104608A1 (de) | Verfahren zum erzeugen eines engineering-vorschlags für eine vorrichtung oder anlage | |
| DE69907714T2 (de) | Komponentbasiertes quellcodegeneratorverfahren | |
| DE69328452T2 (de) | System zur Entwicklung von Software aus einer Spezifikation in natürlicher Sprache mittels Objektnetzwerken | |
| Prakash et al. | Chances and Challenges in Fusing Data Science with Materials Science: The working group “3D Data Science” is headed by Prof. Dr. Stefan Sandfeld. | |
| DE102021116315A1 (de) | Verfahren zum Zusammenführen von Architekturinformationen | |
| EP4490607A1 (de) | Verfahren und computerprogramm zur automatisierten erzeugung von kommunikationsschnittstellen in algorithmen aus dem bereich der künstlichen intelligenz | |
| EP3709188A1 (de) | Rechnerarchitektur für eine schnittstelle zur aggregation von datenobjekten in einem verteilten system | |
| EP4270176B1 (de) | Verfahren zur erzeugung von quellcode | |
| DE202024102344U1 (de) | Auf künstlicher Intelligenz basierendes intelligentes Benutzeroberflächen-Bewertungssystem | |
| EP1387260A1 (de) | Verfahren und Vorrichtung zur Erzeugung von Software | |
| DE102016214666A1 (de) | Verfahren und Vorrichtung zur Gestaltung einer technischen Anlage | |
| DE10233971A1 (de) | Verfahren und Vorrichtung zur Erzeugung von Software | |
| EP2329374A1 (de) | Testmodul und verfahren zum testen einer o/r-abbildungs-middleware | |
| EP3355186A1 (de) | Erzeugung und ausführung von software-modulen | |
| EP3961517A1 (de) | Verfahren und ein system zum erstellen einer industriellen lösung mit einer künstlichen intelligenz | |
| EP3771979A1 (de) | Verfahren und vorrichtung zur optimalen konfiguration eines geräts einer geräteklasse | |
| EP1959430A2 (de) | Verfahren zur automatischen Generierung von VoiceXML-sprachapplicationen aus Sprachdialogmodellen | |
| DE102024208098A1 (de) | Verfahren und Vorrichtung zur automatisierten Konfiguration von Manufacturing Execution Systeme |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| STAA | Information on the status of an ep patent application or granted ep patent |
Free format text: STATUS: UNKNOWN |
|
| STAA | Information on the status of an ep patent application or granted ep patent |
Free format text: STATUS: THE INTERNATIONAL PUBLICATION HAS BEEN MADE |
|
| PUAI | Public reference made under article 153(3) epc to a published international application that has entered the european phase |
Free format text: ORIGINAL CODE: 0009012 |
|
| STAA | Information on the status of an ep patent application or granted ep patent |
Free format text: STATUS: REQUEST FOR EXAMINATION WAS MADE |
|
| 17P | Request for examination filed |
Effective date: 20241011 |
|
| AK | Designated contracting states |
Kind code of ref document: A1 Designated state(s): AL AT BE BG CH CY CZ DE DK EE ES FI FR GB GR HR HU IE IS IT LI LT LU LV MC ME MK MT NL NO PL PT RO RS SE SI SK SM TR |
|
| DAV | Request for validation of the european patent (deleted) | ||
| DAX | Request for extension of the european patent (deleted) | ||
| RAP3 | Party data changed (applicant data changed or rights of an application transferred) |
Owner name: SIEMENS MOBILITY GMBH |
|
| STAA | Information on the status of an ep patent application or granted ep patent |
Free format text: STATUS: EXAMINATION IS IN PROGRESS |
|
| 17Q | First examination report despatched |
Effective date: 20260220 |