Fine-tunable extracted intermediate representations for generating artificial intelligence

Abstract

In an exemplary embodiment, instead of using a large language model (LLM) to directly generate the desired computer code, an intermediate representation is generated from the LLM. LLM is used to generate a programmatically uncomputable portion of computer code (which may be referred to as a "creative" portion for the purpose of the present disclosure). The intermediate representation may then be fed into a separate programming component that compiles the intermediate representation into a compilable computer code. The fine tuning may involve, for example, cleaning the intermediate representation, enhancing the intermediate representation, and formatting the intermediate file, and modifying the intermediate representation based on the feature set.

Description

Technical Field

[0001] This document generally relates to computer systems and more particularly to the use of large language models. Background Art

[0002] Large Language Models (LLMs) refer to artificial intelligence (AI) systems that have been trained on extensive datasets to understand and generate human language. These models are designed to process and understand natural language, allowing them to answer questions, engage in conversations, generate text, and perform a variety of language-related tasks. BRIEF DESCRIPTION OF THE DRAWINGS

[0003] The present disclosure is illustrated by way of example and not limitation in the figures of the accompanying drawings in which like references indicate similar elements.

[0004] Figure 1 is a block diagram illustrating a system for automatically generating CDS model objects from natural language text according to an exemplary embodiment.

[0005] Figure 2 is a flow chart illustrating a method for automatically generating a CDS model object from a natural language text according to an exemplary embodiment.

[0006] Figure 3 is a block diagram showing the architecture of software that can be installed on any one or more of the above-mentioned devices.

[0007] Figure 4 A diagrammatic representation of a machine in the form of a computer system within which a set of instructions may be executed, for causing the machine to perform any one or more of the methodologies discussed herein, is shown in accordance with an exemplary embodiment. DETAILED DESCRIPTION

[0008] The following description discusses illustrative systems, methods, techniques, instruction sequences, and computing machine program products. In the following description, for the purpose of explanation, many specific details are set forth in order to provide an understanding of various exemplary embodiments of the present subject matter. However, it will be apparent to those skilled in the art that various exemplary embodiments of the present subject matter may be practiced without these specific details.

[0009] LLMs are very capable of generating text and even computer code (to be compiled into running software). However, a limitation of LLMs is that their existing knowledge is limited by their training data. As a result, the output is not always correct. There are ways to reduce the impact of this limitation (such as by crafting appropriate system messages, adding external data through generated function calls, or fine-tuning the base model), but these solutions are not perfect and can still result in incorrect output. These limitations are magnified when LLMs output compilable computer code, where not only the correctness of the output content is important, but also the correctness of the syntax and format.

[0010] In fact, certain types of compilable computer code may be more difficult for an LLM to generate correctly due to a variety of factors, such as the type of compilable computer code being proprietary or at least partially proprietary (and therefore in a format that is difficult for the LLM to train) and the type of compilable computer code being difficult to change once generated.

[0011] In an exemplary embodiment, rather than using the LLM to directly generate the desired computer code, an intermediate representation is generated by the LLM. The LLM is used to generate portions of the computer code that cannot be programmatically computed (which may be referred to as "creative" portions for purposes of this disclosure). The intermediate representation may then be fed into a separate programming component that compiles the intermediate representation into compilable computer code. The compilation may involve, for example, cleaning up the intermediate representation, enhancing the intermediate representation, and formatting the intermediate file and modifying the intermediate representation based on a feature set.

[0012] Programming components do not learn from data and are not subject to machine learning techniques. Typically, programming components consist of algorithms that are manually designed and coded by humans, relying on human expertise and knowledge to solve specific problems.

[0013] In contrast, LLMs are designed to learn patterns and relationships from data, allowing them to improve their performance over time. LLMs differ from programmed components in that they can adapt and optimize based on the data they are exposed to.

[0014] The technical advantages of using this approach over alternative methods of automatically creating computer code are that (1) it is faster; (2) it consumes fewer tokens (making it cheaper); and (3) the intermediate representation can be verified and repaired if necessary, making the resulting generated computer code less likely to contain errors.

[0015] Cloud computing can be described as Internet-based computing that provides shared computer processing resources and provides data to computers and other devices as needed. Users can establish corresponding sessions, during which processing resources and bandwidth are consumed. For example, during a session, users are provided with on-demand access to a shared pool of configurable computing resources (e.g., computer networks, servers, storage, applications, and services). Computing resources can be supplied and released (e.g., scaled) to meet user needs. Exemplary cloud platforms include the SAP Cloud Application Platform (CAP) from SAP SE of Waldorf, Germany. The cloud platform can run a data model infrastructure in which a variety of data models can be created and run.

[0016] An example of such a data model infrastructure is Core Data Services (CDS) from SAP SE of Walldorf, Germany. CDS enables service definitions and data models to be captured declaratively in plain object notation. CDS models are typically written in the CDS language and then compiled. In an exemplary embodiment, the above-described techniques are used to generate a CDS model (which is a compilable computer code) by first using LLM to generate an intermediate representation (such as a JavaScript Object Notation (JSON) file or an Extensible Markup Language (XML) file), and then passing the intermediate representation through a programming component to generate the final CDS computer code.

[0017] LLMs for generating information are often referred to as Generative Artificial Intelligence (GAI) models. GAI models can be implemented as Generative Pre-Trained Transformer (GPT) models or bidirectional encoders. GPT models are machine learning models that use a transformer architecture, which is a deep neural network that excels at processing sequential data, such as natural language.

[0018] A bidirectional encoder is a neural network architecture in which the input sequence is processed in two directions: forward and backward. The forward direction starts at the beginning of the sequence and processes one input token at a time, while the backward direction starts at the end of the sequence and processes the input in reverse order.

[0019] By processing the input sequence bidirectionally, the bidirectional encoder can capture more contextual information and dependencies between words, leading to better performance.

[0020] The bidirectional encoder can be implemented as a Bidirectional Long Short-Term Memory (BiLSTM) or BERT (Bidirectional Encoder Representations from Transformers) model.

[0021] Each direction has its own hidden state, and the final output is the combination of the two hidden states.

[0022] Long Short-Term Memory (LSTM) is a type of recurrent neural network (RNN) designed to overcome the vanishing gradient problem in traditional RNNs, which makes it difficult to learn long-term dependencies in sequential data.

[0023] LSTM includes a cell state, which acts as a memory to store information over time. The cell state is controlled by three gates: input gate, forget gate, and output gate. The input gate determines how much new information is added to the cell state, while the forget gate determines how much old information is discarded. The output gate determines how much of the cell state is used to calculate the output. Each gate is controlled by a sigmoid activation function, which outputs a value between 0 and 1 that determines the amount of information that passes through the gate.

[0024] In BiLSTM, there are separate LSTMs for the forward direction and the backward direction. At each time step, the forward and backward LSTM units receive the current input token and the hidden state from the previous time step. The forward LSTM processes the input token from left to right, while the backward LSTM processes the input token from right to left.

[0025] The output of each LSTM cell at each time step is a combination of the input token and the previous hidden state, which allows the model to capture both short-term and long-term dependencies between input tokens.

[0026] BERT applies bidirectional training of models known as transformers to language modeling. This is in contrast to prior art solutions that view text sequences from left to right, or a combination of left to right and right to left. Bidirectionally trained language models have a deeper sense of language context and flow than unidirectional language models.

[0027] More specifically, the Transformer encoder reads an entire sequence of information at once and is therefore considered bidirectional (although one could argue that it is actually non-directional). This property allows the model to learn the context of a piece of information based on all of its surroundings.

[0028] In other exemplary embodiments, a Generative Adversarial Network (GAN) embodiment may be used. A GAN is a supervised machine learning model with two sub-models: a generator model that is trained to generate new examples, and a discriminator model that attempts to classify examples as real examples or generated examples. The two models are trained together in an adversarial manner (using a zero-sum game according to game theory) until the discriminator model is fooled about half of the time, indicating that the generator model is generating credible examples.

[0029] The generator model takes a random vector of fixed length as input and generates samples in the domain of interest. The vector is randomly drawn from a Gaussian distribution and is used to seed the generation process. After training, the points in this multidimensional vector space will correspond to points in the problem domain, forming a compressed representation of the data distribution. This vector space is called a latent space, or a vector space consisting of latent variables. Latent variables or hidden variables are those variables that are important for a domain but cannot be directly observed.

[0030] The discriminator model takes as input examples from the domain (real or generated) and predicts a binary class label of true or false (generated).

[0031] Generative modeling is an unsupervised learning problem, although a clever property of the GAN architecture is that the training of a generative model can be viewed as a supervised learning problem.

[0032] The two models, the generator and the discriminator, are trained together. The generator generates a batch of samples and these samples along with real samples from the domain are fed to the discriminator and classified as real or fake.

[0033] The discriminator is then updated to better distinguish real from fake samples in the next round, and importantly, the generator is updated based on how well the generated samples fool the discriminator.

[0034] In another exemplary embodiment, the GAI model is a variational autoencoder (VAE) model. A VAE includes an encoder network that compresses input data into a low-dimensional representation (called a latent code) and a decoder network that generates new data from the latent code. In either case, the GAI model includes a generative classifier, which can be implemented as, for example, a naive Bayes classifier.

[0035] The present solution is applicable to any type of GAI model, although an implementation specifically for use with a GPT model will be described.

[0036] Figure 11 is a block diagram illustrating a system 100 for automatically generating CDS model objects from natural language text according to an exemplary embodiment. Here, a program 102 includes an intermediate representation generation component 104 that receives natural language text from a user. The intermediate representation generation component 104 appends a system message to the natural language text and sends it as a prompt to the LLM 106. The system message will be described in more detail below, but generally instructs the LLM to generate the creative portion of the desired CDS computer code (the portion that will not or cannot be generated programmatically). In an exemplary embodiment, the system message instructs the LLM 106 to generate an intermediate representation 108 in a specific protocol (e.g., JSON). Upon receiving the intermediate representation 108, a programming component 110 performs one or more programming functions on the intermediate representation 108 and converts it into a final representation 112, which is a compilable computer code (here, a CDS model).

[0037] In an exemplary embodiment, the programming component 110 is designed to allow for minimal degrees of freedom in the intermediate representation 108. Degrees of freedom herein refer to the number of independent ways in which the LLM 106 can generate the intermediate representation 108 without violating any constraints imposed on it. Degrees of freedom can also be thought of as the number of independent variables / parameters in the calculations performed by a machine learning model (such as an LLM). Therefore, in this case, it is desirable that the programming component 110 be created in such a way that it makes as many "choices" as the LLM 106 would otherwise make during the code generation process, thereby reducing the number of variables that the LLM 106 needs to consider and ultimately improving the reliability of the final representation 112, since the programming component 110 solves deterministic subtasks better than creative subtasks, while the LLM 106 solves creative subtasks better than deterministic subtasks. Therefore, during the design of the system 100, the programmer / user / administrator can determine which features do not need to be used in the LLM portion of the generation process, and can design the programming component 110 to perform these features.

[0038] In another exemplary embodiment, an iterative process is used during the design of the system 100 to minimize the number of degrees of freedom. The iterative process may include: at each iteration, removing a degree of freedom from the LLM generation portion and designing the programming component 110 to handle the degree of freedom; testing the system to generate a sample intermediate representation; and testing the intermediate representation using the programming component 110 to ensure that a valid final representation 112 is produced that satisfies any constraints of the programmer / user / administrator who designed the system 100. If so, another iteration may be performed in which the additional degrees of freedom are removed. If it is determined in any iteration that the test results in an invalid final representation 112 or does not satisfy the constraints of the programmer / user / administrator, the changes to the programming component 110 may be "undone" (or at least, not saved), returning the program component 110 to the state it was in before the particular degree of freedom was removed. Another iteration may then be performed by removing alternative degrees of freedom. If there are no such alternative degrees of freedom (indicating that the iterative process has attempted to remove each of the remaining degrees of freedom and none of these iterations have been successful), it may be determined that the program component 110 has now been designed in a manner that minimizes the degrees of freedom, and the design process may be considered to have been completed.

[0039] It should be noted that during this iterative process, dummy parameters may be ignored when calculating the degrees of freedom.Dummy parameters are those parameters that do not have any effect on the output of the programming component 110 (the final representation 112).

[0040] For example, a user may provide the following natural language text: "The data model consists of the entities, Authors, and Books. Each author has many books".

[0041] A system message can be added to this natural language text to form a prompt. The prompt might look like this:

[0042] Create CDS models for authors and books.

[0043] You are an expert in domain modeling. Create domain models for authors and books following JSON schema.

[0044]

[0045]

[0046]

[0047] LLM can then generate a JSON object based on this hint.

[0048] As mentioned above, the implementation using JSON as the intermediate representation format and CDS as the final representation format is just one example of a combination of intermediate and final representation formats that the above techniques can be used for. Unless otherwise specified, the scope of the claims should not be limited to JSON and CDS implementations. In an exemplary embodiment, the intermediate representation format can be any format that is not compilable but still describes computer code, and the final representation format can be any format that can compile computer code.

[0049] Figure 2 2 is a flow chart illustrating a method 200 for automatically generating a CDS model object from a natural language text according to an exemplary embodiment. At operation 202, a natural language text describing a compilable computer code to be generated is received. In some exemplary embodiments, the natural language text specifies that the compilable computer code should be in a format that is at least partially proprietary, indicating a format whose mode or format definition is controlled by a single entity. At operation 204, a prompt is generated by adding a system message to the natural language text. The system message includes instructions for generating code in an intermediate representation format. In some exemplary embodiments, the system message can be customized to a specific compilable computer code format to be ultimately generated. Thus, for example, if the natural language text specifies that the compilable computer code should be in a CDS format, a system message specifically corresponding to CDS is retrieved and appended to the natural language text instead of, for example, a system message specifically corresponding to a non-CDS format, which was originally used when the natural language text had specified that the compilable computer code should be in a non-CDS format.

[0050] At operation 206, the hint is passed to a large language model (LLM) to generate an intermediate representation. At operation 208, the intermediate representation is received. At operation 210, the intermediate representation is passed to a programming component, which applies one or more programming functions to the intermediate representation to modify the intermediate representation and ultimately produce a final representation.

[0051] The final representation may be stored in a database, such as a database of CDS files, at operation 212. These CDS files may then be compiled and executed.

[0052] In view of the above disclosure, various examples are set forth below. It should be noted that one or more features of the examples, whether alone or in combination, should be considered within the disclosure of the present application.

[0053] Example 1. A system comprising:

[0054] at least one hardware processor; and

[0055] A computer-readable medium storing instructions that, when executed by the at least one hardware processor, cause the at least one hardware processor to perform operations comprising:

[0056] receiving natural language text describing compilable computer code to be generated;

[0057] generating a prompt by adding a system message to the natural language text, the system message comprising instructions for generating a computer code for an intermediate representation;

[0058] Passing the hint to a Large Language Model (LLM);

[0059] receiving a generated intermediate representation from the LLM; and

[0060] The generated intermediate representation is passed to a programming component that validates the generated intermediate representation and converts the generated intermediate representation into a final representation, which is a compilable computer code.

[0061] Example 2. The system of Example 1, wherein the compilable computer code is in an at least partially proprietary format.

[0062] Example 3. The system of Example 2, wherein the compilable computer code is a Core Data Services (CDS) model.

[0063] Example 4. A system according to any of Examples 1 to 3, wherein the intermediate representation is non-compilable.

[0064] Example 5. The system of Example 4, wherein the intermediate representation is a JavaScript Object Notation (JSON) file.

[0065] Example 6. A system according to any of Examples 1 to 5, wherein the programming component automatically corrects one or more errors in the intermediate representation.

[0066] Example 7. The system of Example 6, wherein the programming component is designed using an iterative process to minimize degrees of freedom in the generated intermediate representation.

[0067] Example 8. A method comprising:

[0068] receiving natural language text describing compilable computer code to be generated;

[0069] generating a prompt by adding a system message to the natural language text, the system message comprising instructions for generating a computer code for an intermediate representation;

[0070] Passing the hint to a Large Language Model (LLM);

[0071] receiving a generated intermediate representation from the LLM; and

[0072] The generated intermediate representation is passed to a programming component that validates the generated intermediate representation and converts the generated intermediate representation into a final representation, which is a compilable computer code.

[0073] Example 9. The method of Example 8, wherein the compilable computer code is in an at least partially proprietary format.

[0074] Example 10. The method of example 9, wherein the compilable computer code is a Core Data Services (CDS) model.

[0075] Example 11. A method according to any one of Examples 8 to 10, wherein the intermediate representation is not compilable.

[0076] Example 12. The method of Example 11, wherein the intermediate representation is a JavaScript Object Notation (JSON) file.

[0077] Example 13. A method according to any one of Examples 8 to 12, wherein the programming component automatically corrects one or more errors in the intermediate representation.

[0078] Example 14. The method of Example 13, wherein the programming component is designed using an iterative process to minimize degrees of freedom in the generated intermediate representation.

[0079] Example 15. A non-transitory machine-readable medium storing instructions that, when executed by one or more processors, cause the one or more processors to perform operations comprising:

[0080] receiving natural language text describing compilable computer code to be generated;

[0081] generating a prompt by adding a system message to the natural language text, the system message comprising instructions for generating a computer code for an intermediate representation;

[0082] Passing the hint to a Large Language Model (LLM);

[0083] receiving a generated intermediate representation from the LLM; and

[0084] The generated intermediate representation is passed to a programming component that validates the generated intermediate representation and converts the generated intermediate representation into a final representation, which is a compilable computer code.

[0085] Example 16. The non-transitory machine-readable medium of Example 15, wherein the compilable computer code is in an at least partially proprietary format.

[0086] Example 17. The non-transitory machine-readable medium of Example 16, wherein the compilable computer code is a Core Data Services (CDS) model.

[0087] Example 18. The non-transitory machine-readable medium of any one of Examples 15 to 17, wherein the intermediate representation is non-compilable.

[0088] Example 19. The non-transitory machine-readable medium of Example 18, wherein the intermediate representation is a JavaScript Object Notation (JSON) file.

[0089] Example 20. The non-transitory machine-readable medium of any one of Examples 15 to 19, wherein the programming component automatically corrects one or more errors in the intermediate representation.

[0090] Figure 3 is a block diagram 300 illustrating a software architecture 302 that may be installed on any one or more of the devices described above. Figure 3 This is merely a non-limiting example of a software architecture, and it should be understood that many other architectures may be implemented to facilitate the functionality described herein. In various embodiments, the software architecture 302 is comprised of, for example, Figure 4 302 is implemented by the hardware of a machine 400 including a processor 410, a memory 430, and an input / output (I / O) component 450. In this exemplary architecture, the software architecture 302 can be conceptualized as a stack of layers, where each layer can provide specific functionality. For example, the software architecture 302 includes layers such as an operating system 304, a library 306, a framework 308, and an application 310. In operation, the application 310 calls an API call 312 through the software stack and receives a message 314 in response to the API call 312, which is consistent with certain embodiments.

[0091] In various implementations, operating system 304 manages hardware resources and provides common services. Operating system 304 includes, for example, kernel 320, services 322, and drivers 324. Kernel 320 serves as an abstraction layer between the hardware and other software layers, consistent with certain embodiments. For example, kernel 320 provides memory management, processor management (e.g., scheduling), component management, networking, and security settings, among other functionalities. Services 322 may provide other common services to other software layers. According to certain embodiments, drivers 324 are responsible for controlling or interfacing with underlying hardware. For example, drivers 324 may include display drivers, camera applications, or Low-power drivers, Flash memory drivers, serial communication drivers (for example, Universal Serial Bus (USB) drivers), Drivers, audio drivers, power management drivers, etc.

[0092] In some embodiments, the library 306 provides a low-level common infrastructure utilized by the application 310. The library 306 may include a system library 330 (e.g., a C standard library) that may provide functions such as memory allocation functions, string manipulation functions, mathematical functions, etc. In addition, the library 306 may include an API library 332, such as a media library (e.g., a library that supports the presentation and manipulation of different media formats, such as Moving Picture Experts Group-4 (MPEG4), Advanced Video Coding (H.264 or AVC), Moving Picture Experts Group Layer-3 (MP3), Advanced Audio Coding (ACC), Adaptive Multi-Rate (AMR), Audio Codec, Joint Photographic Experts Group (JPEG or JPG), or Portable Network Graphics (PNG)), a graphics library (e.g., an OpenGL framework for rendering graphics contexts in two dimensions (2D) and three dimensions (3D) on a display), a database library (e.g., SQLite for providing different relational database functions), a World Wide Web library (e.g., WebKit for providing web browsing functionality), etc.). The library 306 may also include various other libraries 334 to provide many other APIs to the application 310 .

[0093] According to some embodiments, the framework 308 provides a high-level common infrastructure that can be utilized by the applications 310. For example, the framework 308 provides various GUI functions, advanced resource management, advanced location services, etc. The framework 308 can provide a wider range of other APIs that can be utilized by the applications 310, some of which can be specific to a particular operating system 304 or platform.

[0094] In an exemplary embodiment, the applications 310 include a home application 350, a contact application 352, a browser application 354, a reader application 356, a positioning application 358, a media application 360, a messaging application 362, a game application 364, and a variety of other applications, such as third-party applications 366. According to some embodiments, the application 310 is a program that performs the functions defined in the program. Different programming languages ​​can be used to create one or more applications 310 structured in various ways, and the programming language can be an object-oriented programming language (e.g., Objective-C, Java, or C++) or a procedural programming language (e.g., C or assembly language). In a specific example, the third-party application 366 (e.g., an ANDROID application developed by an entity other than the manufacturer of a particular platform) TM or IOS TM Applications developed with a software development kit (SDK) can be mobile software that runs on a mobile operating system such as IOS TM ANDROID TM , Phone or another mobile operating system. In this example, third-party applications 366 can call API calls 312 provided by operating system 304 to facilitate the functionality described herein.

[0095] Figure 4 A diagrammatic representation of a machine 400 in the form of a computer system is shown according to an exemplary embodiment within which a set of instructions may be executed to cause the machine 400 to perform any one or more of the methodologies discussed herein. Figure 4 A diagrammatic representation of a machine 400 in the exemplary form of a computer system is shown within which instructions 416 (e.g., software, programs, applications, applet, app, or other executable code) may be executed to cause the machine 400 to perform any one or more of the methodologies discussed herein. For example, the instructions 416 may cause the machine 400 to perform Figure 2 Additionally or alternatively, instruction 416 may implement Figure 1 to Figure 2Etc. Instructions 416 transform a general, unprogrammed machine 400 into a specific machine 400 that is programmed to perform the functions described and shown in the described manner. In alternative embodiments, the machine 400 operates as a standalone device or can be coupled (e.g., networked) to other machines. In a networked deployment, the machine 400 can operate as a server machine or a client machine in a client-server network environment, or as a peer machine in a peer-to-peer (or distributed) network environment. The machine 400 may include, but is not limited to, a server computer, a client computer, a personal computer (PC), a tablet computer, a laptop computer, a netbook, a set-top box (STB), a personal digital assistant (PDA), an entertainment media system, a cellular phone, a smart phone, a mobile device, a wearable device (e.g., a smart watch), a smart home device (e.g., a smart device), other smart devices, a network device, a network router, a network switch, a network bridge, or any machine capable of sequentially or otherwise executing instructions 416 specifying the actions taken by the machine 400. Further, while a single machine 400 is illustrated, the term "machine" shall also be taken to include any collection of machines 400 that individually or jointly execute instructions 416 to perform any one or more of the methodologies discussed herein.

[0096] Machine 400 may include processor 410, memory 430, and I / O components 450, which may be configured to communicate with each other, such as via bus 402. In an exemplary embodiment, processor 410 (e.g., a central processing unit (CPU), a reduced instruction set computing (RISC) processor, a complex instruction set computing (CISC) processor, a graphics processing unit (GPU), a digital signal processor (DSP), an application specific integrated circuit (ASIC), a radio frequency integrated circuit (RFIC), another processor, or any suitable combination thereof) may include, for example, processor 412 and processor 414 that may execute instructions 416. The term "processor" is intended to include multi-core processors, which may include two or more independent processors (sometimes referred to as "cores") that may execute instructions 416 simultaneously. Although Figure 4 Multiple processors 410 are shown, but the machine 400 may include a single processor 412 with a single core, a single processor 412 with multiple cores (e.g., a multi-core processor 412), multiple processors 412, 414 with a single core, multiple processors 412, 414 with multiple cores, or any combination thereof.

[0097] The memory 430 may include a main memory 432, a static memory 434, and a storage unit 436, each of which may be accessed by the processor 410, such as via the bus 402. The main memory 432, the static memory 434, and the storage unit 436 store instructions 416 that embody any one or more of the methods or functions described herein. During execution of the instructions 416 by the machine 400, the instructions 416 may also reside, completely or at least, within the main memory 432, within the static memory 434, within the storage unit 436, within at least one processor 410 (e.g., within a cache memory of a processor), or any suitable combination thereof.

[0098] I / O components 450 may include various components to receive input, provide output, generate output, send information, exchange information, capture measurements, and the like. The specific I / O components 450 included in a particular machine will depend on the type of machine. For example, a portable machine such as a mobile phone will likely include a touch input device or other such input mechanism, while a headless server machine will likely not include such a touch input device. It should be understood that I / O components 450 may include Figure 4 Many other components not shown in the figure. The I / O components 450 are grouped according to functionality for the sole purpose of simplifying the following discussion, and the grouping is by no means limiting. In different exemplary embodiments, the I / O components 450 may include output components 452 and input components 454. The output components 452 may include visual components (e.g., displays such as plasma display panels (PDPs), light emitting diode (LED) displays, liquid crystal displays (LCDs), projectors, or cathode ray tubes (CRTs)), acoustic components (e.g., speakers), tactile components (e.g., vibration motors, resistance mechanisms), other signal generators, etc. The input components 454 may include alphanumeric input components (e.g., keyboards, touch screens configured to receive alphanumeric input, optical keyboards, or other alphanumeric input components), point-based input components (e.g., mice, touch pads, trackballs, joysticks, motion sensors, or another pointing device), tactile input components (e.g., physical buttons, touch screens that provide the location and / or force of touch or touch gestures, or other tactile input components), audio input components (e.g., microphones), etc.

[0099] In further exemplary embodiments, the I / O component 450 may include a biometric component 456, a motion component 458, an environmental component 460, or a positioning component 462, as well as various other components. For example, the biometric component 456 may include components for detecting expressions (e.g., gestures, facial expressions, vocal expressions, body postures, or eye tracking), measuring physiological signals (e.g., blood pressure, heart rate, body temperature, sweat, or brain waves), identifying people (e.g., voice recognition, retinal recognition, facial recognition, fingerprint recognition, or EEG-based recognition), etc. The motion component 458 may include an acceleration sensor component (e.g., an accelerometer), a gravity sensor component, a rotation sensor component (e.g., a gyroscope), etc. Environmental component 460 may include, for example, an illumination sensor component (e.g., a photometer), a temperature sensor component (e.g., one or more thermometers that detect ambient temperature), a humidity sensor component, a pressure sensor component (e.g., a barometer), an acoustic sensor component (e.g., one or more microphones that detect background noise), a proximity sensor component (e.g., an infrared sensor that detects nearby objects), a gas sensor (e.g., a gas detection sensor for detecting hazardous gas concentrations or measuring pollutants in the environment for safety purposes), or other components that can provide indications, measurements, or signals corresponding to physical measurements of the surroundings. Positioning component 462 may include a positioning sensor component (e.g., a global positioning system (GPS) receiver component), an altitude sensor component (e.g., an altimeter or barometer that detects air pressure from which altitude can be derived), an orientation sensor component (e.g., a magnetometer), and the like.

[0100] Various technologies may be used to implement communications. I / O components 450 may include a communication component 464 that operably couples machine 400 to network 480 or device 470 via coupler 482 and coupler 472, respectively. For example, communication component 464 may include a network interface component or another suitable device that interfaces with network 480. In further examples, communication component 464 may include a wired communication component, a wireless communication component, a cellular communication component, a near field communication (NFC) component, Components (e.g., low power ), Components, as well as other communication components that provide communication via other modalities. Device 470 can be another machine or any of a variety of peripheral devices (e.g., a peripheral device coupled via a universal USB).

[0101] In addition, the communication component 464 can detect the identifier or include a component that operatively detects the identifier. For example, the communication component 464 can include a radio frequency identification (RFID) tag reader component, an NFC smart tag detection component, an optical reader component (e.g., an optical sensor for detecting one-dimensional bar codes (such as universal product code (UPC) bar codes), multi-dimensional bar codes (such as QR codes, Aztec codes, data matrix, Dataglyph, Max Code, PDF417, Super Code, UCC RSS-2D bar codes, and other optical codes), an acoustic detection component (e.g., a microphone for identifying an audio signal of a tag). In addition, various information can be derived via the communication component 464, such as positioning via Internet Protocol (IP) geolocation, location information ... Positioning by signal triangulation, positioning via detection of NFC beacon signals that can indicate a specific location, and so on.

[0102] Various memories (e.g., 430, 432, 434 and / or the memory of processor 410) and / or storage unit 436 may store one or more sets of instructions 416 and data structures (e.g., software) that embody or are utilized by any one or more of the methods or functions described herein. These instructions (e.g., instructions 416) when executed by processor 410 cause various operations to implement the disclosed embodiments.

[0103] As used herein, the terms "machine storage medium", "device storage medium" and "computer storage medium" mean the same thing and may be used interchangeably. These terms refer to a single or multiple storage devices and / or media (e.g., centralized or distributed databases, and / or associated caches and servers) that store executable instructions and / or data. Thus, these terms should be understood to include, but are not limited to, solid-state memory and optical and magnetic media, including memory internal or external to the processor. Specific examples of machine storage medium, computer storage medium and / or device storage medium include non-volatile memory, including, for example: semiconductor memory devices such as erasable programmable read-only memory (EPROM), electrically erasable programmable read-only memory (EEPROM), field programmable gate arrays (FPGAs), and flash memory devices; magnetic disks, such as internal hard disks and removable disks; magneto-optical disks; and CD-ROM and DVD-ROM disks. The terms "machine storage medium", "computer storage medium" and "device storage medium" expressly exclude carrier waves, modulated data signals, and other such media, at least some of which are covered by the term "signal media" discussed below.

[0104] In various exemplary embodiments, one or more portions of network 480 may be an ad hoc network, an intranet, an extranet, a virtual private network (VPN), a local area network (LAN), a wireless LAN (WLAN), a wide area network (WAN), a wireless WAN (WWAN), a metropolitan area network (MAN), the Internet, a portion of the Internet, a portion of a public switched telephone network (PSTN), a plain old telephone service (POTS) network, a cellular telephone network, a wireless network, network, another type of network, or a combination of two or more such networks. For example, network 480 or a portion of network 480 may include a wireless or cellular network, and coupler 482 may be a code division multiple access (CDMA) connection, a global system for mobile communications (GSM) connection, or another type of cellular or wireless coupling. In this example, coupling 482 may implement any of various types of data transmission technologies, such as single carrier radio transmission technology (1xRTT), evolution data optimized (EVDO) technology, general packet radio service (GPRS) technology, enhanced data rates for GSM evolution (EDGE) technology, third generation partnership project (3GPP) (including 3G, fourth generation wireless (4G) network), universal mobile telecommunications system (UMTS), high speed packet access (HSPA), worldwide interoperability for microwave access (WiMAX), long term evolution (LTE) standards, other technologies defined by different standard setting organizations, other remote protocols, or other data transmission technologies.

[0105] Instructions 416 may be sent or received over network 480 using a transmission medium via a network interface device (e.g., a network interface component included in communication component 464) and utilizing any of a number of well-known transmission protocols (e.g., HTTP). Similarly, instructions 416 may be sent or received to device 470 via coupling 472 (e.g., peer-to-peer coupling) using a transmission medium. The terms "transmission medium" and "signal medium" represent the same thing and may be used interchangeably in this disclosure. The terms "transmission medium" and "signal medium" should be deemed to include any intangible medium capable of storing, encoding, or carrying instructions 416 for execution by machine 400 and including digital or analog communication signals or any intangible medium for facilitating the communication of such software. Therefore, the terms "transmission medium" and "signal medium" should be deemed to include any form of modulated data signals, carrier waves, and the like. The term "modulated data signal" represents a signal having one or more characteristics of the signal set or changed in a manner that encodes information in the signal.

[0106] The terms "machine-readable medium," "computer-readable medium," and "device-readable medium" mean the same thing and are used interchangeably in this disclosure. These terms are defined to include both machine storage media and transmission media. Thus, these terms include both storage devices / medium and carrier / modulated data signals.

Claims

1. A system comprising: at least one hardware processor; as well as A computer-readable medium storing instructions that, when executed by the at least one hardware processor, cause the at least one hardware processor to perform operations comprising: receiving natural language text describing compilable computer code to be generated; generating a prompt by adding a system message to the natural language text, the system message comprising instructions for generating a computer code for an intermediate representation; Passing the hint to a Large Language Model (LLM); receiving a generated intermediate representation from the LLM; as well as The generated intermediate representation is passed to a programming component that validates the generated intermediate representation and converts the generated intermediate representation into a final representation, which is a compilable computer code.

2. The system of claim 1, wherein the compilable computer code is in an at least partially proprietary format.

3. The system of claim 2, wherein the compilable computer code is a Core Data Services (CDS) model. The system of claim 1 , wherein the intermediate representation is non-compilable.

5. The system of claim 4, wherein the intermediate representation is a JavaScript Object Notation (JSON) file.

6. The system of claim 1, wherein the programming component automatically corrects one or more errors in the intermediate representation.

7. The system of claim 6, wherein the programming components are designed using an iterative process to minimize degrees of freedom in the generated intermediate representation.

8. A method comprising: receiving natural language text describing compilable computer code to be generated; generating a prompt by adding a system message to the natural language text, the system message comprising instructions for generating a computer code for an intermediate representation; Passing the hint to a Large Language Model (LLM); receiving a generated intermediate representation from the LLM; as well as The generated intermediate representation is passed to a programming component that validates the generated intermediate representation and converts the generated intermediate representation into a final representation, which is a compilable computer code.

9. The method of claim 8, wherein the compilable computer code is in an at least partially proprietary format.

10. The method of claim 9, wherein the compilable computer code is a Core Data Services (CDS) model. The method of claim 8 , wherein the intermediate representation is non-compilable.

12. The method of claim 11, wherein the intermediate representation is a JavaScript Object Notation (JSON) file.

13. The method of claim 8, wherein the programming component automatically corrects one or more errors in the intermediate representation.

14. The method of claim 13, wherein the programming components are designed using an iterative process to minimize degrees of freedom in the generated intermediate representation.

15. A non-transitory machine-readable medium storing instructions that, when executed by one or more processors, cause the one or more processors to perform operations comprising: receiving natural language text describing compilable computer code to be generated; generating a prompt by adding a system message to the natural language text, the system message comprising instructions for generating a computer code for an intermediate representation; Passing the hint to a Large Language Model (LLM); receiving a generated intermediate representation from the LLM; as well as The generated intermediate representation is passed to a programming component that validates the generated intermediate representation and converts the generated intermediate representation into a final representation, which is a compilable computer code.

16. The non-transitory machine-readable medium of claim 15, wherein the compilable computer code is in an at least partially proprietary format.

17. The non-transitory machine-readable medium of claim 16, wherein the compilable computer code is a Core Data Services (CDS) model.

18. The non-transitory machine-readable medium of claim 15, wherein the intermediate representation is non-compilable.

19. The non-transitory machine-readable medium of claim 18, wherein the intermediate representation is a JavaScript Object Notation (JSON) file.

20. The non-transitory machine-readable medium of claim 15, wherein the programming component automatically corrects one or more errors in the intermediate representation.

Images