SAP Patente

In an example embodiment, a mechanism is provided to allow an LLM to generate multiple text blocks in which different grammars are strictly enforced with a single invocation. This mechanism defines a set of trigger tokens and end tokens. When a trigger token is encountered by the LLM, a strict grammar referenced by the trigger token is begun to be enforced and this enforcement ends when an end token is encountered. Between the time an end token is encountered, and another trigger token is encountered, no grammar is strictly enforced. By including multiple types of such trigger token/end token pairs, it becomes possible for the LLM to generate texts having different strictly enforced grammars in a single invocation.

A system and method include receipt of a query from a user, determination, from a plurality of stored text portions, of first text portions which are semantically similar to the query, determination of a first score associated with each of the first text portions, generation of a first prompt based on the first scores, the first prompt including the query and the first text portions, transmission of the first prompt to a text generation model, receipt of a response to the first prompt from the text generation model, presentation of the response and the first text portions, receipt, from the user, of a rating of one of the presented first text portions, and updating of the first score associated with the one of the first text portions based on the rating.

Techniques and solutions are disclosed for managing subprocess versions and their associated components in a computing system. These techniques enable dynamic adaptation and traceability through version control. A subprocess definition is received and updated to reflect modifications to its components, configurations, or execution sequence. Changes are identified and propagated using unique version identifiers and events. Iterative refinement is supported through actions such as validating updated subprocesses, reprocessing data, or maintaining provenance chains. The disclosed solutions provide efficient and structured management of subprocesses.

A computer implemented method receives a query to perform a join operation that joins a first table with a second table based on matching values in a selected column of the first table with values in a selected column of the second table, obtains a first dictionary for the selected column of the first table and a second dictionary for the selected column of the second table, and determines an output size of the join operation based on the first dictionary and the second dictionary. A dictionary for a given column includes a plurality of unique values in the given column and corresponding range indices. A count of a given unique value in the given column is mapped to a range associated with a range index corresponding to the given unique value. Related systems and software for implementing the method are also disclosed.

A system and method include execution of a chatbot session consisting of user queries and chatbot feedbacks, insertion of one of the chatbot feedbacks into an analytics document as analytical insight data, reception of a user selection of one or more of the chatbot feedbacks, generation of a data lineage graph from the selected one or more of the chatbot feedbacks, and storage of the data lineage graph in association with the analytical insight data.

A transaction which targets an object store employing an open table format (OTF) may be detected by a database execution engine. Next, the database execution engine performs a determination step to determine which OTF enhancement levels to apply to the detected transaction. Then, the database execution engine applies one or more OTF enhancement levels to the transaction based on the determination step. Next, the database execution engine causes the transaction to be processed with the applied one or more OTF enhancement levels. Then, the database execution engine returns a result of the transaction processing to a computing device.

A database client may establish a database session with a database server, including a session state, for a first TCP network connection through a first reverse proxy. A reattachment token is sent to the database client, and a database operation request is received from the database client through the first reverse proxy. Before or during execution of the database operation request (including any updates to the session state) an indication is received that the first reverse proxy will be terminated after a reattachment window. The server instructs the database client to perform a session reattachment and receives, from the database client, a session reattachment request, including the reattachment token, for a second TCP network connection through a second reverse proxy. The server verifies the reattachment token and resumes the database session with the database client, including the updated session state, for the second TCP network connection.

Techniques and systems are disclosed for evaluating and optimizing logical plans using machine learning. In an aspect, a logical plan is received and submitted to a machine learning model, which predicts whether applying a rule to the logical plan provides a benefit, such as reduced execution time or resource use. Based on the prediction, the rule is applied or marked for application, or not applied or not marked for application. Training operations for the machine learning model include calculating and comparing execution costs of applying or not applying a rule, generating a numerical representation of the logical plan, and assigning labels based on cost differences. A machine learning model trained with the representations and labels predicts rule benefits for logical plans, including both new logical plans and those used during training.

An extractor engine receives one or more metric rules defining a set of metrics to extract from a source database for insertion into a target database. Also, the extractor engine retrieves a schema of the source database. Next, the extractor engine generates, based on the one or more metric rules and the schema of the source database, one or more query language statements for extracting the set of metrics from the source database for insertion into the target database. Then, the extractor engine causes the generated one or more query language statements to be executed to extract the set of metrics from the source database and insert the set of metrics into the target database. Next, a database execution engine and/or the extractor engine generates a dashboard of the plurality of metrics in the target database and causes the dashboard to be displayed in a user interface.

The present disclosure relates to computer-implemented methods, software, and systems for managing user interaction data. One example method includes data producers and data consumers of software applications defined on a platform solution; defining user interaction types to represent specific types of data that are to be produced by one or more of the data producers; defining a mapping between one or more purposes and one or more user interaction types; configuring access configurations on tenant level for one or more customers of the platform solution; and in response to receiving a request from a user for performing a data read operation or data write operation at a first software application of the software applications, invoking a user data management service defined for the platform solution for performing evaluation of the access configurations and the mappings.

Some embodiments are directed to processing of technical operational message processing in a computing platform. The method may include comparing a received technical operational messages to sets of representative technical operational messages using Retrieval Augmented Generation (RAG), and classifying a received technical operational message with the cluster associated with a matching set of representative technical operational messages, thus obtaining a sequence of cluster classifications corresponding to the received technical operational messages.

The present disclosure relates to computer-implemented methods, software, and systems for providing data access to shared data. One example method includes managing a collection of records associated with interactions of users with one or more of a set of software products defined at a platform solution, wherein the collection of records is obtained according to relevant compliance policies for data storage defined correspondingly for the set of software products; and in response to receiving a request for data management in relation to a first record of the collection of records, determining a relevant compliance policy for the first record, the relevant compliance policy being associated with a respective software product of the set of software products; and providing access to the first record in accordance with a scope determined for the first record, the scope being based on the relevant compliance policy.

The present disclosure provides techniques and solutions for determining the completeness of a collection of datatype instances. Completeness can reflect the degree to which instances include values for instance properties. A first collection of instances is received, each including one or more instance types and stored as one or more data types in a data structure. The instance types define properties of the instances, and some instances lack values for certain properties while having values for others. A first completeness metric for a first instance type is determined by analyzing the presence or absence of property values and comparing unfilled properties to a defined set. If the first completeness metric does not meet a threshold, actions are taken, such as adjusting a computing process to access a second collection of instances or receiving values for missing properties.

A machine accesses a schedule that defines when to generate a document customized for a user and inclusive of a dynamically updatable widget configured to present dynamic data to be obtained from a data source. The machine executes a single service that includes a publisher sub-service and an exporter sub-service. The publisher sub-service causes the exporter sub-service to generate the document based on the accessed schedule. The exporter sub-service spawns a browser container within which a tenant process generates the document for the user. The generating of the document may comprise sending a request to obtain the dynamic data from the data source, receiving the dynamic data, and generating the dynamically updatable widget based on the dynamic data. Then, the machine provides the generated document to a device of the user.

Disclosed herein are system, method, and computer program product embodiments for providing a lock-free read access to one or more data structures. An embodiment operates by allocating a first portion of a memory corresponding to a first data structure of the one or more data structures. The embodiment then receives a first request to insert second data to the first data structure, and determines whether an increase of a size is to be executed. The embodiment then, based on the determination that an increase of the size is to be executed, inserting the second data to a modified first data structure or a pointer to second data in a modified container list, comprising: executing garbage collection to free-up the first portion of the memory based on at least one parallel operation associated with the first data structure.

Embodiments of the present disclosure include techniques for automatically generating machine learning models. In one embodiment, sets of hyperparameters corresponding to machine learning models trained on one training data set are provided as an input. The hyperparameters are iteratively selected using an algorithm, such as a bandit algorithm, and used to train an ML model using another training data set. The performance of the trained ML model is evaluated on each iteration until the ML model performance is above a threshold. The resulting model may be used to train a resulting model. In some embodiments, ML models are combined across iterations to improve performance.

Systems and methods described herein relate to automatic creation and management of indexes for graph workspaces. Missing indexes for a graph workspace are identified and automatically created as appropriate. The automatically created indexes are reused for other graph workspaces working on the same set of data. The automatic creation and management of indexes for graph workspaces allows for a graph workspace to be created with a single user command instead of multiple user commands involving creation of indexes prior to creation of the graph workspace.

A received query is parsed by a first machine learning (ML) model to retrieve one or more semantic entities. Next, a second ML model is trained with a list of application programming interfaces (APIs) and corresponding first data to generate a second trained ML model which receives the one or more semantic entities as inputs. Based on these inputs, the second trained ML model selects a given API from the list of APIs. Then, a third ML model is trained with the given API and corresponding second metadata to generate a third trained ML model. Next, the third trained ML model receives the one or more semantic entities as inputs and generates a given API call for invoking the given API. Then, the given API call is executed and the query is completed to a first computing system based on invoking the given API.

Systems and methods described herein provide a computer-implemented approach for process simulations using multi-agent systems. Software agents are trained using historical process data associated with a process. Each software agent represents a single task in the process. Based on a candidate process model, the process is simulated to generate simulation results by executing a multi-agent system. The software agents operate autonomously within the multi-agent system based on trained behavior. The process is also executed using a runtime configuration that is based on the candidate process model. The execution of the process generates runtime results for comparison with the simulation results. In some examples, the candidate process model is adjusted based on the comparison, and the simulation and the execution of the process are repeated using an adjusted multi-agent system and an adjusted runtime configuration, respectively. A deployment process model is generated based on the adjusted candidate process model.

The present disclosure involves systems, software, and computer implemented methods for private function evaluation. One example method includes identifying a function provided by a function-providing entity. A neural network is trained to approximate the function. A shallow neural network is generated from the neural network. The shallow neural network approximates the function and includes shallow network parameters. The shallow network parameters are secret shared to a first set of entities. A request is received to execute the function using at least one input parameter. The input parameters are secret to the first set of entities. Secret-shared function outputs are received that are generated by the first set of entities using a set of secret-shared input parameters and the shallow neural network with secret-shared shallow network parameters. A function output is generated for the function using the secret-shared function outputs.

In an example embodiment, a solution is provided that allows users to interact directly with underlying object data lake storages in hyperscalers when accessing user data. This feature is known as direct access. Use of this solution increases performance of the user systems and the cloud systems, without impacting the functionality nor increasing the complexity. This is true even for Spark users, where the driver abstracts the communication path between the Spark application and HDL files. This results in an opt-in solution that allows users to reduce their cost by increasing complexity.

A computing system leverages large language models to automate the configuration and execution of predictive analytics techniques. The system receives input identifying a data set and generates prompts to extract necessary information from predictive analytics documentation, or a representation thereof. The large language model processes requests to generate commands to create computing objects for use in carrying out the predictive analysis, as well as to configure procedures for executing the selected predictive analytics technique. The system helps ensure data set compliance with prerequisites of a predictive analytics technique by generating and executing code to preprocess the data. Similarity searches can be performed in a vector database to identify relevant predictive analytics techniques and their requirements. The system supports both user-specified and automatically identified predictive analytics techniques.

Systems and methods described herein relate to a generative artificial intelligence (AI) access layer that is implemented for dynamic control of a software application. Input is received from the software application. A generative AI model is used to detect a relevant capability based on the input. Prompt data is generated based on generative AI scenario settings for the relevant capability. The prompt data includes at least some of the input and context data accessible to the software application. A capability result is generated by using the generative AI model to process the prompt data. The generation of the capability result is dynamically controlled using the generative AI scenario settings. The software application executes the relevant capability based on the capability result. Output is presented within a user interface of the software application.

The present disclosure relates to techniques for automatically generating new data objects from user input. The system receives user input comprising a plurality of words and executes a first query on a vector store to identify schema elements similar to keywords in the user input. The vector store provides a response with similarity scores for identified elements. A second query is executed on a knowledge graph to identify association paths between data objects that include the identified elements. The knowledge graph response includes association information linking source and target data objects through selected elements. Full association paths are constructed from this information, and a command is generated to instantiate a new data object with elements corresponding to the user input. This approach leverages the strengths of large language models, vector stores, and knowledge graphs to efficiently and accurately create new data objects, ensuring data integrity and relevance.

Various examples are directed to systems and methods of managing a database in a multi-tenant cloud environment. A database management application may receive a first query directed to a first table. The first query may be received from a cloud application associated with a first tenant of the multi-tenant cloud environment. The database management application may access a first shared table associated with the first table and stored at a common storage of the multi-tenant cloud environment and a first tenant delta table associated with the first table and stored at a tenant data storage. The database management application may generate a first query response based at least in part on the first query, the first shared table and the first tenant delta table.

In an example embodiment, a data warehousing environment, or a similar architecture, is extended to permit data storage in either an in-memory database or a Lakehouse architecture, which leverages one or more hyperscalers for the underlying storage. More specifically, a single artifact is defined in Datasphere that stores data in either the in-memory database or the Lakehouse architecture, and does so in a storage-agnostic manner.

A landing zone is established in an open table format object storage. More specifically, the landing zone is implemented as a local ingestion table file. This represents a special subtype of the local data file that is used in the inbound layer when ingesting data from an external system. This local ingestion table file is further subdivided into an active data portion and an inbound buffer. When data is written from the external system, it is first placed in the inbound buffer. This data is then merged into the active data, after processing and postprocessing. The result of these postprocessing operations is then stored in the active data portion of the local ingestion table file.

Embodiments of the present disclosure include techniques for detecting and correcting drift in a data set. Data sets may be divided into classifications. A first classifier is trained on data from multiple data sets using data from each data set having a first classification. A second classifier is trained on data from the multiple data sets using data from each data set having a second classification. The performance of the classifiers are measured. Drift is detected when the performance of either classifier is above a threshold. Some embodiments may use the trained classifiers to determine data elements from one data set that are combined with another data set for training.

A solution for transforming and managing data in a data lake environment is disclosed. A definition of a transformation flow is received via a graphical user interface. The transformation flow specifies operations to transform source data into target data stored in a first format object storage. A virtual procedure corresponding to the transformation flow is generated and stored in an in-memory cloud database. Then the virtual procedure is executed, causing retrieval of metadata from the first format object storage and triggering a transformation job on a computing cluster. The transformation job reads the source data from the first format object storage, applies one or more transformations specified in the definition of the transformation flow, and writes results to target data in the first format object storage.

Zusammenfassung wird geladen …

Zusammenfassung wird geladen …

Provided are systems and methods for managing inventory among a plurality of storage locations via a user interface that includes movable interactive GUI elements corresponding to the storage locations. In one example, a method may include displaying a user interface that comprises a plurality of GUI elements therein corresponding to the plurality of storage locations, respectively, detecting, via the user interface, movement of a first GUI element towards a second GUI element based on inputs received on the user interface and input of a quantity value, determining to perform a transfer of a quantity value from a first storage location corresponding to the first GUI element to a second storage location corresponding to the second GUI element, and modifying data records stored within a database based on the determined transfer from the first storage location to the second storage location.

The present disclosure relates to a method for recognizing an object in an input image. The method comprises: providing an image encoder (120, 502, 601) configured to encode an image to provide a visual feature vector representing the image in an image space, the image encoder comprising a trained convolutional neural network (121), wherein the image space is defined by a fully connected layer of the convolutional neural network. Visual center of mass vectors (122, 123, 124, 504.1-M, 533.1-M) representing object classes in the image space may be provided. The image encoder (120, 502, 601) may encode the input image (505) to provide an input visual feature vector (506) representing the input image (505). The object may be recognized by selecting one of the visual center of mass vectors (504.1-M, 533.1-M) using a proximity criterion relative to the input visual feature vector (506).

In an example embodiment, a replication state database is utilized in conjunction with a version clock to track changes to data in an event-driven architecture. The replication state database then can be used to ensure data consistency of the data. Opportunistic Concurrency Control can also be utilized to allow for parallel processing by instances.

The present disclosure involves systems, software, and computer implemented methods for transaction auditing. One example method includes training at least one machine learning model to determine features that can be used to determine whether an image is an authentic image of a document or an automatically generated document image, using a training set of authentic images and a training set of automatically generated document images. A request to classify an image as either an authentic image of a document or an automatically generated document image is received. The machine learning model(s) are used to classify the image as either an authentic image of a document or an automatically generated document image, based on features included in the image that are identified by the machine learning model(s). A classification of the image is provided. The machine learning model(s) are updated based on the image and the classification of the image.

Zusammenfassung wird geladen …

Embodiments of the present disclosure include techniques for moving data. In one embodiment, OAuth tokens are used to automate the retrieval of data on remote systems. A frontend application user may select objects to be moved between systems. An OAuth token may be generated by the source server. In some embodiments, the token is passed between content management systems to move data between the content management systems. The OAuth token may be used in an automated background process to retrieve data objects from a source server and send the tokens from a source CMS to a target CMS, where a user may access the data objects.

Zusammenfassung wird geladen …

Zusammenfassung wird geladen …

Zusammenfassung wird geladen …