A system associated with a cloud computing environment may include an UPSERT batch optimization engine that identifies an UPSERT VALUES (?, ?, ?, …) WITH PRIMARY KEY case. The optimization engine may then receive batch parameters for the UPSERT VALUES (?, ?, ?, …) WITH PRIMARY KEY case and create a temporary table with the received batch parameters. According to some embodiments, the optimization engine can then execute a single left outer join with the temporary table and an UPSERT target table. The optimization engine may then fetch a result of the single left outer join. A Data Manipulation Language (“DML”) execution engine dispatches a set of rows to be inserted and a set of rows to be updated. A partition-wise insert and update run can then be executed in accordance with the set of rows to be inserted and the set of rows to be updated.
Techniques and solutions are provided for configuring a process mining template to include events for particular process mining enhancements. For example, users can select to add events relevant to specific industries or for value drivers. The events are associated with database queries that can be executed to determine occurrences of events. Events for process mining enhancements can be determined by clustering events from one or more existing process mining templates. A sample of an entity's data, in a database, can be processed prior to deploying a process mining template to determine overlap between currently defined events of the client and the events for the process mining enhancements, or to compare an entities metrics to reference values.
Some embodiments provide a non-transitory machine-readable medium that stores a program. The program may receive a set of data from a data source. The program May generate a plurality of time series data based on the set of data. The program may determine a subset of the plurality of time series data as anomalies. The program may provide notifications indicating that the subset of the plurality of time series data are anomalies.
G06F 18/22 - Critères d'appariement, p. ex. mesures de proximité
G06F 18/2113 - Sélection du sous-ensemble de caractéristiques le plus significatif en classant ou en filtrant l'ensemble des caractéristiques, p. ex. en utilisant une mesure de la variance ou de la corrélation croisée des caractéristiques
G06F 123/02 - Types de données dans le domaine temporel, p. ex. des données de séries temporelles
4.
FORECASTING MASTER DATA IN A SKEWED DATA SET USING HYBRID MACHINE LEARNING MODELS
Systems and methods described herein relate to hybrid machine learning techniques for forecasting master data, such as scrap data. A hybrid machine learning model includes a first machine learning model (e.g., balanced random forest classifier) that generates a prediction with respect to whether or not a manufacturing process will result in scrap generation. If the first machine learning model predicts that no scrap will be generated in the manufacturing process, then an output prediction is that no scrap will be generated in the manufacturing process. If the first machine learning model predicts that scrap will be generated in the manufacturing process, then a second machine learning model (e.g., gradient boost regressor) predicts a value of scrap percentage. The value of scrap percentage is provided as an output prediction of a percentage of scrap that will be generated in the manufacturing process.
G06F 16/215 - Amélioration de la qualité des donnéesNettoyage des données, p. ex. déduplication, suppression des entrées non valides ou correction des erreurs typographiques
5.
SOFTWARE DEVELOPMENT OBJECT ARTIFICIAL INTELLIGENCE TRAINING DATA GENERATION
The present disclosure involves systems, software, and computer implemented methods for artificial intelligence (AI) training data generation. A method includes identifying a request to generate training data based on software development objects of a software development system. A plurality of exporters each configured for a given object type are invoked. Each exporter invokes a respective interface of the software development system to iterate, in a shared object repository, over objects of an object type to retrieve object data and object metadata for instances of the object type. Object data and object metadata are received from each exporter. Received object data and metadata are stored in a first format in an exported data repository. AI training data is generated by transforming the object data and metadata in the first format to a second format suitable for training AI models. The AI training data is provided to at least one AI system.
A computer-implemented system includes: a component of a local development environment generating a request to complete a source code and a code suggestion system. The request includes the context of the local development environment. The code suggestion system parses the context to define dependencies of code snippets of the source code under development. The code suggestion system determines corresponding databases including additional code objects associated to code objects of the source code under development identified by the dependencies of the source code. The code suggestion system retrieves the additional code objects and generates a prompt using a portion of the additional code objects. The prompt is formatted for minimizing a prompt size and provided to the prompt to a large language model to generate a response including a suggested code for completing the source code under development.
A system and method include determination of input fields of automation scripts, acquisition of metadata of database object fields, prompting of a text generation model using a chain-of-thoughts prompt, the input fields and the acquired metadata to determine mappings between the input fields and the database object fields, prompting of an embedding model to generate embeddings based on each input field, associating each embedding with each mapping that includes the input field on which the embedding was generated, identification of a first input field of an automation script, prompting of a second embedding model to generate a first embedding based on the first input field, searching for embeddings similar to the first embedding, identification of a candidate mapping associated with each of the embeddings, and determination of a first database object field to bind to the first input field based on the identified candidate mappings.
A computer-implemented system, includes: an application programming interface (API) generating a request to complete code documentation for a source code including code entities and a software code suggestion system. The software code suggestion system processes the request to identify a code type of the source code by performing a syntax analysis and a semantics analysis of a structure of the code entities. The software code suggestion system retrieves a matching code for the source code corresponding to the code type of the source code. The software code suggestion system retrieves a context of the matching code for the source code. The software code suggestion system generates a prompt using the matching code and the context. The software code suggestion system provides the prompt to a large language model of the large language model type to generate a response including a code documentation.
A central framework unifies the data protection and privacy domain with the business domain using application objects and business scenarios. Application objects are linked to a particular data category, a name of a data object, and primary key attributes of the data object. Each data category is linked to a purpose. And business scenarios include a set of application objects and a sequence for the set. Worklist entries are generated in response to a particular instances of application objects being created or modified. For each worklist entry, purposes are determined for the particular application object using purpose assignment rules for the particular application object. Each of the determined purposes for the particular application object are stored in a purpose assignment table. Then each determined purpose are proposed for master data to be used across the plurality of different application.
In an example embodiment, constrained generation during LLM inference is performed using a multi-layered approach to incremental parsing. This constrained generation process is able to more effectively generate computer code for sentence-based programming languages. Specifically, it is designed to wait until a full statement is generated prior to analyzing the syntactical correctness of a statement, because the meaning of a token in a sentence-based programming language can change its meaning based on later tokens in the same statement. Furthermore, the external (block) structure of statements can be analyzed by looking only at the first word of statements without looking into the statements more closely.
In an example embodiment, a large language model (LLM) is used to capture semantic relationships between entities so that machine learning techniques can be used to analyze patterns and relationships of entities and dependencies. This includes analyzing version requirements and dependencies among software products. The system is trained to recognize compatibility patterns and understand the impact of product upgrades on dependencies.
Methods, systems, and computer-readable storage media for receiving an image and a reference color scheme, the image being generated by an AI model, the reference color scheme having populated a prompt that the image was generated in response to, for each pixel in the image, generating a color space vector representative of a color represented by the pixel to provide a set of vectors, processing the set of vectors to define a set of clusters, each cluster representative of colors of a sub-set of vectors, for each cluster in the set of clusters and for each color in the reference color scheme, determining a similarity score that is included in a set of similarity scores, calculating a color alignment metric based on the set of similarity scores, determining a color alignment result based on the color alignment metric, and executing one or more tasks responsive to the color alignment result.
G06V 10/56 - Extraction de caractéristiques d’images ou de vidéos relative à la couleur
G06V 10/74 - Appariement de motifs d’image ou de vidéoMesures de proximité dans les espaces de caractéristiques
G06V 10/762 - Dispositions pour la reconnaissance ou la compréhension d’images ou de vidéos utilisant la reconnaissance de formes ou l’apprentissage automatique utilisant le regroupement, p. ex. de visages similaires sur les réseaux sociaux
13.
EVALUATING LARGE LANGUAGE MODEL GENERATED CODE USING APPLICATION SERVER CONTEXT
The present disclosure involves systems, software, and computer implemented methods for evaluating code generation. A method includes identifying a code artifact for a benchmark task. A portion of code for the benchmark task is determined in a first copy of the artifact. A second copy of the artifact is automatically generated by replacing, in the first copy of the artifact, the portion of code with a fill-in marker. A prompt and at least a portion of the second copy of the artifact are provided to a model. The prompt instructs the model to generate code to replace the fill-in marker. A third copy of the artifact is automatically generated by replacing, in the second copy of the artifact, the fill-in marker with model-generated code. The model-generated code is evaluated by executing an executable version of the third copy of the artifact.
A prompt optimization interface retrieves semantic information characterizing a source code under development that includes code entities. A code suggestion system coupled to the prompt optimization interface, generates, from the semantic information, a dependency graph exposing relations and dependencies between the code entities. The code suggestion system generates a ranked list of code entities indicative of a relevance of each code entity of the code entities in the dependency graph based on a relevance to a query code entity. The code suggestion system minimizes the dependency graph using the ranked list of code entities and a context of the query code entity for generating a minimized dependency graph to be within a set window. The code suggestion system converts the minimized dependency graph into a prompt format processable by a large language model to generate matching code for the source code under development.
A non-user-interface (non-UI) test automate associated with a web application test case includes a sequence of state-change requests. The state-change requests and responses thereto are captured during recording of a UI test automate for the test case or adapted from an existing UI test automate for the test case, whereas non-state-change requests of the corresponding UI test automate are excluded from the non-UI test automate. Responsive to a prompt to perform a non-UI automated test for the test case, mappings between properties of the state-change requests, responses, and test data are determined. At runtime of the non-UI test automate, the mappings are referenced to preserve sequence and data dependencies among the state-change requests. Pop-up window content received in network responses during execution of the non-UI test automate is classified by type using a classification machine learning model and handled based on the determined type.
Systems and methods include reception of a request to modify an instance of a reuse component and, in response to the request, determine an interface entity of the reuse component and a property of the reuse component which stores an identifier of a host object instance of the reuse component instance, call a first predefined operation with the type of the host object and an identifier of the host object instance to set a lock on the host object instance, create a data container of key field values of the host object instance based on data types of the key fields, and call a second predefined operation with the type of the host object and the data container to check an authorization to modify the host object instance.
In an example embodiment, a novel data structure called a “mind graph” is introduced, which defines all of the different possible combinations of tasks within a software project, as well as the potential flows among the tasks. This mind graph is then passed as input, along with a prompt generated by natural language input from a user, to an LLM. The LLM uses the mind graph and the prompt to generate an execution plan which defines which tasks from the mind graph will be generated and the path the flow takes though those tasks. This execution plan is then presented to the user in a graphical user interface that allows the user to edit the execution plan. The edited execution plan is then submitted to the LLM to generate the actual code for each of the tasks. This code is again presented to the user to accept, or modify, the code for each of these tasks.
Methods, systems, and computer-readable storage media for retrieving data from a data store, the data being in a storage format and including multiple dimensions in a hierarchy, at least one dimension having a sub-hierarchy, converting the data from the storage format to an analytics format including a set of nodes, each node representing a dimension of the multiple dimensions, a set of hierarchy characters, one or more hierarchy characters separating two or more nodes to represent a hierarchical relationship between nodes, and an attribute delimiter to separate attribute values of a node, generating a prompt that references the data in the analytics format, transmitting the prompt to a LLM system, and receiving a response to the prompt from the LLM system.
Systems and methods described herein relate to automated control of software development pipeline progression. Examples herein provide for automated validation and progression through multiple sequential stages without manual intervention between states. A user interface of a continuous integration tool receives a user selection of a target state in a software development pipeline. Based on the selected target state, the system automatically progresses an increment through a sequence of states by executing automated tests associated with a current state, detecting when a current state precedes the target state, and automatically transitioning to a next state after successful completion of the automated tests if the current state precedes the target state. In some examples, the automated progression repeats until the current state reaches the target state, with results data presented via the user interface indicating at least the current state and the successful completion of the automated tests.
A blackboard data store contains records representing a plurality of AI agent operation results associated with the system (including an operation identifier). A decision support platform, coupled to the blackboard data store and being associated with at least one LLM, may receive a decision support request from a user associated with the system and determine a series of operations associated with the decision support request. A coordination agent may arrange for the series of operations to be performed by a plurality of AI agents, with operation results being recorded in the blackboard data store. Decision support information can then be presented to the user in response to the decision support request. According to some embodiments, the plurality of AI agents include a question planning and analysis agent, a research agent a decision option suggestion agent, a decision option evaluation agent, a critique agent, and/or a decision presentation agent.
Methods, systems, and computer-readable storage media for executing semi-supervised training of a network backbone using unlabeled training data, the semi-supervised training including two or more iterations including selecting a batch of unlabeled training data, generating first predictions using a first ML model and second predictions using a second ML model, determining a contrastive loss based on the first predictions and the second predictions, the contrastive loss being determined based on a global normalized confusion matrix (NCM) and a global cluster matrix (CM), adjusting second parameters of the second ML model in response to the contrastive loss, and adjusting first parameters of the first ML model using the second parameters of the second ML model.
G06V 10/764 - Dispositions pour la reconnaissance ou la compréhension d’images ou de vidéos utilisant la reconnaissance de formes ou l’apprentissage automatique utilisant la classification, p. ex. des objets vidéo
G06V 10/82 - Dispositions pour la reconnaissance ou la compréhension d’images ou de vidéos utilisant la reconnaissance de formes ou l’apprentissage automatique utilisant les réseaux neuronaux
22.
CLOUD COMPUTING INTEGRATION SUITE MESSAGE RECORDER
A system associated with a cloud computing environment includes a message interceptor that intercepts details of messages of a process executed by an enterprise. The message interceptor then determines an occurrence of a process failure, and, responsive to the determination, automatically records details of the intercepted messages that may be relevant to the process failure. A collected message data store contains details of the intercepted messages that may be relevant to the process failure. A message recorder can then access the collected message data store and arrange for information about the recorded messages to be transmitted to a support team. In some embodiments, the message recorder also provides at least some of the information about the relevant messages to a LLM (e.g., via a prompt that includes some of a process code base), and a response includes possible troubleshooting information to fix the code base.
The present disclosure involves systems, software, and computer implemented methods for data privacy. One example method includes determining to perform a test of a first multiple-application landscape and a first data privacy integration service instance that manages data privacy integration of multiple applications in the first multiple-application landscape. A test work package is created in response to determining to perform the test of the first multiple-application landscape and the first data privacy integration service instance. The test work package is provided to applications of the first multiple-application landscape and test work package responses are received from applications of the first multiple-application landscape. The test work package responses are evaluated to determine a correctness of the first multiple-application landscape and the first data privacy integration service instance.
G06F 21/57 - Certification ou préservation de plates-formes informatiques fiables, p. ex. démarrages ou arrêts sécurisés, suivis de version, contrôles de logiciel système, mises à jour sécurisées ou évaluation de vulnérabilité
G06F 21/62 - Protection de l’accès à des données via une plate-forme, p. ex. par clés ou règles de contrôle de l’accès
24.
REDUCING PARTICIPANTS IN DATA PRIVACY INTEGRATION PROTOCOLS
The present disclosure involves systems, software, and computer implemented methods for data privacy. One example method includes receiving a first request to start a data privacy integration protocol for a first object instance. At least one second request is sent to at least one other service for information regarding which subset of applications of a multiple-application landscape have received a copy of the first object instance. A work package is created for the first object instance and the data privacy integration protocol and is sent to applications in the subset and not sent to landscape applications not in the subset. Work package responses are received from applications in the subset of applications. A data privacy integration protocol result is determined based on the work package responses and is sent in response to the first request to start the data privacy integration protocol.
The present disclosure involves systems, software, and computer implemented methods for data privacy. One example method includes identifying, at a data privacy integration service that manages data privacy integration, a data privacy integration protocol request. Application availability of applications in a multiple-application landscape is determined, including a determination that at least one application is not currently available for data privacy integration requests. A determination is made to proceed with data privacy integration protocol processing for the data privacy integration protocol request even though the at least one application is unavailable. A data privacy integration work package is sent to applications of the multiple-application landscape and data privacy integration work package responses are received. The data privacy integration work package responses are evaluated to determine a data privacy integration protocol result and the data privacy integration protocol result is provided in response to the data privacy integration protocol request.
G06F 16/27 - Réplication, distribution ou synchronisation de données entre bases de données ou dans un système de bases de données distribuéesArchitectures de systèmes de bases de données distribuées à cet effet
26.
SCHEDULING OF DATA PRIVACY INTEGRATION PROTOCOL PROCESSING BASED ON APPLICATION AVAILABILITY
The present disclosure involves systems, software, and computer implemented methods for data privacy. One example method includes logging data privacy integration protocol activity information. A data privacy integration protocol request having a context is received. Logged data privacy integration protocol activity information is determined based on the context, along with first work package timing information for a first application subset that differs from second work package timing information for a second application subset. A first work package is sent to applications in the first and second application subsets based on the first and second timing information, respectively. A data privacy integration protocol result is determined based on work package responses to the first and second work packages. The data privacy integration protocol result is provided in response to the first data privacy integration protocol request.
Systems and methods select a candidate scenario of a plurality of scenarios in a scenario group associated with a hard level, based on a user query, generate a candidate selection rationale using a first machine learning model and analyze, using a second machine learning model, the user query, the candidate scenario, and the candidate selection rationale to generate a selection decision and selection decision feedback. The systems and methods further, until a selection decision is positive or a maximum number of iterations has been reached, select a new candidate scenario of the plurality of scenarios in the scenario group and generate a new candidate selection rational for based on the user query and the selection decision feedback, using the first machine learning model, and generate a new selection decision and new selection decision feedback based on the user query and new candidate selection rationale, using the second machine learning model.
Arrangements for holistic end-to-end process data automation operations are provided. Process data including entity-level data and group-level data may be identified. The entity-level data may include individual tasks, and the group-level data may include sets of tasks to be executed in a predefined sequence. The group-level data may be synchronized with the entity-level data by mapping respective content and configurations. A logical tree structure for the entity-level data and the group-level data may be generated. The generating may include dividing, via a topmost sub-hierarchy layer, the logical tree structure into a first subtree of nodes representing the entity-level data and a second subtree of nodes representing the group-level data. An instance may be generated from the logical tree structure based on one of the first subtree or the second subtree. A consolidated report unifying the entity-level data and the group-level data may be output based on the generated instance.
A database of text associated with different domains is maintained. Large language models (LLMs) are prepared for use in the different domains by providing the associated text to an instance of an LLM. Thus, using multiple instances of the same pre-trained LLM, domain-specific LLMs are generated. The text provided to the LLM instance may be selected based on an account identifier of the user accessing the LLM, the tenant accessing the LLM, a user selection of a domain, or any suitable combination thereof. A pool of prepared LLM instances may be generated before the access request is received. If a response provided by an LLM instance in a domain to a prompt was rejected by a user and additional information was received during the session to improve the response of the LLM instance, the additional information may be to the text used to prepare future LLM instances for the domain.
In some implementations, there is provided a computer-implemented method comprising receiving, by a processor, at least a first text-based input, determining, by the processor and using a first machine learning model, at least a first predicted result corresponding to at least the first text-based input, training a second machine learning model on at least the first text-based input and at least the first corresponding predicted result, determining, by the trained second machine learning model, an explanation for at least the first predicted result determined by the first machine learning model, and outputting, to a user interface of user equipment, the explanation for at least the first predicted result.
An enterprise documentation data store contains records representing a plurality of documents in an enterprise corpus (including a document identifier). A semantic search pipeline data store contains records representing semantic search pipelines (including a pipeline identifier and at least one tuning parameter). A GenAI validation platform can then identify at least one document in the enterprise documentation data store to be validated. The GenAI validation platform accesses information in the semantic search pipeline data store associated with a semantic search pipeline. It automatically performs a fact-based validation of the identified document using the semantic search pipeline to generate a validation report suggesting changes to the identified document. Embodiments may also arrange to automatically implement the suggested changes.
The present disclosure provides techniques for managing cookies in interactions involving multiple network domains. Upon receiving a request to set cookies for a second network domain while processing a web page of a first network domain, both partitioned and unpartitioned cookies are issued and stored. Having both types of cookies available allows for seamless operation regardless of the browser, first-party domain, or third-party domain support for different cookie handling mechanisms, including when traditional third-party cookies are not available. Policies can be set to determine when both cookie types should be set, or when only one type of cookie is needed. If a third-party domain does not support the issuance of both types of cookies, a web proxy can be used to perform the relevant operations.
This disclosure describes systems, software, and computer implemented methods for initiating a large language model (LLM) with a base prompt, the base prompt providing the LLM with a set of possible output actions, and constraining the LLM to respond with a thought response, output action, or an answer response; receiving, a natural language query; providing the natural language query to the LLM; receiving a first response from the LLM comprising a first token and a structured query; passing the structured query including the arguments to a database on behalf of the user; receiving a return from the database; generating a return token and providing the return token and the return from the database to the LLM; receiving a second response from the LLM, the second response comprising a second token indicating that the second response is an answer response; and providing the second response to the user.
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.
Methods, systems, and computer-readable storage media for converting a first set of values of first digital content to a second set of values, dividing a sub-set of values of the second set of values into a set of blocks, applying a transform to each block to provide, for each block, a frequency domain representation, for each block in the set of blocks, embedding a sub-set of watermark bits based on the parameters, executing an inverse transformation of the set of blocks to provide a modified second set of values representative of an image with a digital watermark in the second color space, converting the modified second set of values to a modified first set of values representative of the image with the digital watermark in the first color space, and providing second digital content including the image with the digital watermark.
In an example embodiment, rather than use large language model (LLM) to directly generate desired computer code, an intermediate representation is generated by the LLM. The LLM is used to generate the portion of the computer code that cannot be computed programmatically (which may be called the “creative” part for purposes of the present disclosure). The intermediate representation can then be fed into a separate programmatic component that compiles the intermediate representation into compilable computer code. This fine-tuning may involve, for example, sanitizing the intermediate representation, enhancing the intermediate representation, and formatting the intermediate file, as well as modifying the intermediate representation based on a feature set.
G06F 16/3329 - Formulation de requêtes en langage naturel
G06F 16/383 - Recherche caractérisée par l’utilisation de métadonnées, p. ex. de métadonnées ne provenant pas du contenu ou de métadonnées générées manuellement utilisant des métadonnées provenant automatiquement du contenu
39.
GENERATIVE ARTIFICIAL INTELLIGENCE (GAI) REUSE SERVICE FOR INTEGRATION OF GAI INTO APPLICATION SCENARIOS
Methods, systems, and computer-readable storage media for receiving a scenario service request for a scenario of an application, determining a scenario flowchain represented in the scenario service request, retrieving a scenario flowchain configuration of the scenario flowchain from a database, the scenario flowchain configuration including a data object that defines a set of steps that are to be executed in an order, each step being associated with a step type and a set of parameters, executing steps in the set of steps, where at least one step is executed to prompt a large language model (LLM), and returning a result to the application, the result comprising a response from the LLM that is responsive to the prompt.
Methods, systems, and computer-readable storage media for receiving a first request parameter for each of the plurality of tenants, receiving a second request parameter for each of the plurality of tenants, assigning the plurality of tenants to an N plurality of tenant groups based on the first request parameter for each of the plurality of tenants, assigning each tenant in the N plurality of tenant groups to a server group in an M plurality of server groups based on the second request parameter for each of the plurality of tenants, and directing, by a load balancer, tenant requests of tenants in the plurality of tenants to servers based on the M plurality of server groups.
A database management system (DBMS) receives an input query and parses the received input query to generate an abstract parse tree. Next, the DBMS traverses the abstract parse tree to detect any parameterized structured query language (SQL) views. If a first parameterized SQL view is detected in the abstract parse tree, the DBMS generates a first view parse tree if a first search of a first cache for the first parameterized SQL view results in a miss. Otherwise, the DBMS retrieves, from the first cache, a previously generated view parse tree if the first search of the first cache results in a hit. Then, the DBMS generates a first query compile tree if a second search of a second cache for the first parameterized SQL view results in a miss. Finally, the DBMS generates and executes a query execution plan based on the first query compile tree.
Techniques and solutions are provided for obtaining a suggested configuration for a configurable object. Typically, a particular object and object configuration are recommended based on technical characteristics of the object. However, a user or process wishing to obtain a recommendation may be more familiar with their operational requirements. Disclosed techniques can include an overall solutions category containing solutions of different solutions category subtypes. Sets of requirements attributes and configuration (technical) attributes can be defined for the solutions category. In some cases, a first machine learning model is trained using input values for the requirements attributes and the configuration attributes, and is used to recommend a particular solution in response to a set of input requirement attribute values. Different machine learning models can be trained for the various solutions, including using the configuration attributes for a particular solution, and can be used to recommend a configuration of a selected/recommend solution.
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.
Methods, systems, and computer-readable storage media for receiving an inference request including inference data, and determining, from the inference request, that generic line-item matching (GLIM)-based inference is to be executed, and in response, transmitting a GLIM inference request including at least a portion of the inference data and a model identifier, retrieving a GLIM model from a model repository using the model identifier, processing the at least a portion of the inference data through the GLIM model to generate inference results, and returning the inference results to an application.
In an example embodiment, a large language model (LLM) is utilized to generate a semantic vector for each given time series. These semantic vectors represent additional information generated based on descriptions of the type of the time series (e.g., a description of the material, whose demand over time comprises the time series). The semantic vectors can then be used to stabilize the assignment of clusters in a cluster-based machine learning model, especially for short time series, to improve reliability of predictions.
If the sizing for an application is incorrect, either too many resources are allocated for the application or too few. Traditionally, sizing is based on answers to a questionnaire, assumptions, data gathered after the application is deployed, or various combinations thereof. As discussed herein, directed testing is used to gather information about the hardware requirements of the application. The gathered information is used along with quality of service information to accurately size the application. A load unit component performs load testing of the application to find a linear dependence of the application on hardware resources for one or more dimensions of demand on the application. Based on the data gathered by the load unit component, a multi-variable linear regression is performed to determine a resource unit for the application and a number of instances of the resource unit to be allocated to the application.
Embodiments of the present disclosure include techniques for data aggregation and suggestion generation. In one embodiment, profile information from remote systems is cached in a local database. As searches are issued in the remote systems, event messages comprising search artifacts are generated and sent to the database. The search artifacts are aggregated and stored in the local database. A profile may be analyzed based on the stored data and suggestions are provided regarding attribute values that may be added to the profile to improve search performance.
Disclosed herein are a system, method, and computer program product embodiments for enabling document collection creation in accordance with a semi-structured data type, retrieving and filtering data from both relational databases and a document collection, and determining a data type in which the data is retrieved. For example, a statement configured to generate a collection of semi-structured documents in a document store based on a schema is processed. The statement specifies a semi-structured data type in which a plurality of entities from the collection are to be returned from the document store. A determination is made that an entity of the plurality of entities is defined by the schema as being a particular data type different from the semi-structured data type. A query for the entity is provided to the document store. The entity is received, based on the query, in accordance with the particular data type.
Embodiments are described for a graphic-based programing system comprising a display, a memory, and at least one processor coupled to the display and the memory. The at least one processor is configured to receive a programing layout that comprises one or more function components and one or more connections between the one or more function components and store locations of the one or more function components in the memory. The at least one processor is further configured to determine that at least one function component out of the one or more function components corresponds to a first characteristic data and determine a working area in the programing layout. The at least one processor is further configured to determine that the at least one function component is outside the working area and display at least one indicator based on the location of the at least one function component.
The disclosure generally describes methods, software, and systems for generation of negative commits. An object representation of a dataset is received, the object representation exposes readily accessible attributes of modified files in the dataset. Positive commits corresponding to source code issue tracking tickets referencing the modified files in the dataset are determined, by processing the readily accessible attributes of modified files in the dataset. Candidate negative commits are determined for each of the positive commits, by processing the source code issue tracking tickets. A matching score between the positive commits and the candidate negative commits is determined. A sorted set of commits including in each set a positive commit and one or more negative commits for the modified files in the dataset is generated, using the matching score. A machine learning model for detection of source code security issues is trained, using the sorted set of negative commits.
The disclosure generally describes methods, software, and systems for generation of attack vectors and threat modeling using artificial intelligence models. A request to perform threat modeling for a software system including nodes performing operations vulnerable to threats is received. Tokens that include pairs of nodes and one or more edges are generated. A set of paths corresponding to a known threat applicable to a portion of the nodes of a respective path is generated, using the tokens. A similarity search for the set of paths is performed, to determine similar paths corresponding to known threats and known mitigations. A prompt for a prediction model is generated, using the similar path, the known threats, and the known mitigations. A list of threats and a mitigation plan to modify the software system to mitigate the threats is received, from the prediction model.
A system and method include reception of a user query from a user in a chatbot session, issuance of a function call to a data source based on the user query, reception of data from the data source in response to the function call, determination of one or more suggested function calls based on the function call and records associating function calls with subsequently-issued function calls, and returning of a response to the user query to the user in the chatbot session, the response based on the received data and including suggested user input associated with each of the one or more suggested function calls.
G06F 16/3329 - Formulation de requêtes en langage naturel
H04L 51/02 - Messagerie d'utilisateur à utilisateur dans des réseaux à commutation de paquets, transmise selon des protocoles de stockage et de retransmission ou en temps réel, p. ex. courriel en utilisant des réactions automatiques ou la délégation par l’utilisateur, p. ex. des réponses automatiques ou des messages générés par un agent conversationnel
H04L 51/046 - Interopérabilité avec d'autres applications ou services réseau
Techniques are provided for determining elements of a routing. A set of inputs is obtained, where respective inputs are associated with sets of one or more characteristics. Values for the characteristics are associated with a set of labels defining operational routing attributes and are used to train a machine learning model. Inference data including characteristic values for inputs is analyzed using the machine learning model to produce an inference result identifying predicted labels. The predicted labels are used to execute at least a portion of a routing operation including assignments of work centers, execution sequences, or resources. Updated inference data may result in different predicted labels and different routing assignments. Using characteristic values enables improved inference accuracy and allows a greater portion of available data to be used for training.
In an example embodiment, resource utilization and resource assignment among StatefulSet instances is monitored and usage metrics are maintained. Multiple different StatefulSets are established, with each set having a different level of resource allocation. Individual instances can then be dynamically assigned/reassigned to the different StatefulSets based on resource utilization. An auto-scaler is provided to scale each StatefulSet to the needed number of instances.
A core data services (CDS) explain agent receives a CDS explain request to generate an explanation with respect to a CDS data model. A CDS explain process is orchestrated for the CDS data model using a CDS explain handler of the CDS explain agent. A validator of the CDS explain agent and advanced business application programming (ABAP) dictionary metadata is used to validate if a CDS entity exists and if the CDS entity can be explained. Using a prompt assembler of the CDS explain agent, a large language model (LLM) prompt is assembled by combining multiple prompt snippets that satisfy the explanation with respect to a CDS data model. Using a CDS explain request processor of the CDS explain agent, the LLM prompt is transmitted to an LLM. Using a post-processor of the CDS explain agent, relevant information of a response from the LLM is extracted.
Embodiments of the present disclosure include techniques for analyzing and reducing dependent code. In one embodiment, application source code is linked to dependency code, some of which is used and some of which is not used. The application source code and dependency code are analyzed to produce a usage graph comprising nodes corresponding to functional code elements and edges between the nodes corresponding to calls between the code elements. Edges may be associated with weights that may be used to determine an amount of used in subtrees of the dependency code. Dependency code that is little used may be replaced by dependency code without indirect dependencies. Replacement dependency code may be autogenerated by extracting existing dependency code elements to build a prompt for a generative AI.
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.
A system and method include training a classification model to classify data based on first data associated with a first usage scenario, receiving second data associated with a second usage scenario inputting the second data to the classification model and receiving a likelihood of a first classification from the classification model, determining a similarity between the second data and a plurality of data associated with the second usage scenario, modifying the likelihood based on the determined similarity, determining a second classification of the second data based on the modified likelihood, and processing the second data according to the second classification of the second data.
A computer-implemented method includes finding, using a plugin, a set of reachable dependencies in a production environment. Using the plugin, a set of reachable dependencies in a test environment is found. Using the plugin, a set of candidate dependencies is found. Using the plugin, a determination is made that an empty set does not exist. Using the plugin and as incorrect dependencies, a set of incorrectly scoped dependencies is found. The found incorrect dependencies are reported.
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.
G06F 16/901 - IndexationStructures de données à cet effetStructures de stockage
H04L 51/02 - Messagerie d'utilisateur à utilisateur dans des réseaux à commutation de paquets, transmise selon des protocoles de stockage et de retransmission ou en temps réel, p. ex. courriel en utilisant des réactions automatiques ou la délégation par l’utilisateur, p. ex. des réponses automatiques ou des messages générés par un agent conversationnel
The disclosure generally describes methods, software, and systems for identification of code embeddings. A source code fragment is received. Embedding models corresponding to the source code fragment are determined. Each of the embedding models converts the source code fragment into numerical vectors that capture a semantic meaning and a functionality of the source code fragment. Probes corresponding to properties of the source code fragment are determined. Each of the probes perform an analysis of the properties of the source code fragment. Performance metrics indicative of encapsulations of the probes in the embedding models are generated, using a machine learning model trained to process the embedding models and the probes. A ranked representation of the embedding models is generated using the performance metrics.
The disclosure generally describes methods, software, and systems for generation of code property graph trees integrating control-flow and dataflow. A code property graph (CPG) of source code is received. The CPG includes a graph representation of the source code. The CPG merges information from an abstract syntax tree (AST) of the source code and a control flow graph of the source code. The CPG includes multiple CPG edges. A CPG edge of the plurality of CPG edges is added to the AST. The CPG edge includes a directed edge identifying a target node. An AST edge connecting the target node to a root node is identified, using the CPG edge. If a removal of the AST edge retains a tree property of the AST, the AST edge connecting the target node to a parent node is removed to generate a CPG tree including AST edges and CPG edges.
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.
In an example embodiment, a solution is provided that places all threads under control to prevent a scenario where a thread attempts to access memory that has already been released as part of a large computer system shutdown. While this solution address potential instability caused by a parallel processing shutdown technique, it can also be more broadly applied in any large computer system shutdown process to prevent crashes or other issues.
A combined change-point analyzer automatically detects change points in time series data by sequentially applying a Bayesian model and a Pruned Exact Linear Time (PELT) model. After a pre-processing stage, the Bayesian model identifies potential change points in the time series data by determining respective Bayes factors for positions in the time series data and outputs the potential change points to the PELT model. The PELT model determines respective costs of the pre-change points using a penalized cost function and minimizes the penalized cost function over the time series data to determine final change points from among the potential change points. A feedback loop system can be implemented in which the respective final change points are manually verified as confirmed, modified, or pending change points or removed. User input received during the manual verification process can be stored and used for model parameter optimization to enhance accuracy and efficiency.
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.
A semantically-aware visual layout for a Failure Mode and Effects Analysis (FMEA) is generated based on semantic data for the FMEA and rendered for display via a user interface. A graph traversal is performed on the semantic data to create preliminary layout data, which is processed along with the semantic data to determine absolute positions for nodes and edges which take into account their semantic types and creation times. A visual representation of a layout for the FMEA is rendered based on the processed layout data, in which a focus FMEA group is centrally arranged, with superordinate and subordinate groups positioned to the left and right of the focus FMEA group at a downward offset. Within a given group, function nodes are centered below a system element node, and failure mode nodes are arranged in a cherry-on-tree formation below and to the right of a corresponding function node.
Methods, systems, and computer-readable storage media for executing a load balancer optimization engine for a cluster that includes a set of nodes, a first sub-set of nodes being used for load balancing by one or more external load balancers, a second sub-set of nodes being excluded from load balancing, determining, by the load balancer optimization engine, a delta value based on a pool count and a number of nodes in a candidate node list, transmitting, by the load balancer optimization engine, a request to adjust a number of nodes in the first sub-set of nodes and a number of nodes in the second sub-set of nodes responsive to the delta value, and adjusting, by a cloud controller of the cluster, the number nodes in the first sub-set of nodes by the delta value and a number of nodes in the second sub-set of nodes by the to the delta value.
The present disclosure involves systems, software, and computer implemented methods for secure and private proxy fine tuning. One example method includes receiving an inference input for a first machine learning model. The input is provided to the first model, a second machine learning model that has an output structure that is consistent with a corresponding portion of the first model and a smaller overall size than the first model, and a tuned second machine learning model that is a tuned version of the second machine learning model. Output data is identified for the first model, the second model, and tuned second model. An output difference is determined based on the output data for the second model and the tuned second model. The output difference is applied to the output data for the first model to generate adapted output data that is used to generate a normalized output.
The solution enables secure, compliant, and easy deployment of integrated applications to customer infrastructure by leveraging its existing security features in unison. A deployment orchestrator provides a user interface that may be embedded in a host application. Using the user interface, a customer administrator generates a role. The deployment orchestrator provides a role template for the role. The role template identifies the permissions needed for the deployment. The customer create a role that includes those permissions and no others. The role template may be dynamically generated and include an expiration time that is based on the time of generation. Using the role, a deployment orchestrator automatically deploys the customer application to the customer infrastructure. An integration module of the deployment orchestrator sets up integration of the host application and the customer application and validates the deployment.
Techniques and solutions are disclosed for annotating and processing data across schemas using a matching model. Data associated with a first source schema is received from a first source and submitted to the matching model. The model generates results identifying matches between instances in the first source schema and a second source schema, where the schemas may be the same or different. Based on these results, annotations are added to the first source schema to reflect relationships with data in the second source schema. Annotations may include derivation relationships and schema mappings, such as those implemented in knowledge graphs. Annotated data may be used to train or refine the matching model iteratively. Additionally, previously ingested data may be reprocessed with updated models, and version information of the matching model associated with annotated data to track updates and provide traceability.
Described herein are systems and method for using machine learning to merge document formats. In some embodiments, a computer-implemented method includes comparing, using a first machine learning model, a first document format and a second document format, the first machine learning model matching a first set of nodes in the first document format to a second set of nodes in the second document format; in response to a third set of nodes of the first document format detected as not having a match in the second plurality of nodes of the second document format, providing, to a second machine learning model, the second document format and the third set of nodes of the first document format; and receiving, from the second machine learning model, a fourth set of nodes matching the third set of nodes of the first document format. Related systems, methods, and articles of manufacture are also disclosed.
A computer-implemented method can include generating a first knowledge graph from a first version of an application programming interface (API), generating a second knowledge graph from a second version of the API, identifying changes from the second knowledge graph to the first knowledge graph, and generating a difference graph based on the identified changes from the second knowledge graph to the first knowledge graph. The difference graph connects the second knowledge graph to the first knowledge graph via one or more revision edges, which represent the identified changes from the second knowledge graph to the first knowledge graph.
Methods, systems, and computer-readable storage media for receiving a set of tokens representative of user input to a LLM-based application that executes transactions with a LLM, determining a number of target input tokens based on an input ratio, predicting a number of output tokens of the LLM using an output token estimation model, selecting a completion time estimation model from a set of completion time estimation models based on a set of parameters associated with the user input, generating an estimated completion time by processing the number of output tokens through the completion time estimation model, and displaying the estimated completion time in a user interface.
Methods, systems, and computer-readable storage media for processing a target image and a reference image through a segmentation model to provide a set of target masks and a set of reference masks, and determining that a difference exists between a target mask and a reference mask, and in response, providing a potential defect patch for a ROI of the target image corresponding to the difference, generating a potential defect embedding using the potential defect patch, comparing the potential defect embedding to each defect embedding in a set of defect embeddings to provide a set of similarity scores, and selectively indicating presence of a defect in the product based on a similarity score in the set of similarity scores.
In an example embodiment, a solution is provided that combines the precision of a database approach with the commonsense/smart approach of an LLM. Documents, such as Jira™ items, are each bound with a unique identification upon ingestion. The unique identification is used as a high-dimensional index to facilitate efficient search operations. Additionally, a local LLM model is used to process and analyze the data, which ensures that all data processing is kept locally. This helps prevent data exposure of confidential data contained in the files to external systems or networks. Finally, a secondary embedding search mechanism is implemented before presenting results to the user. The query is run more than once, and the outputs can then be compared. The results are only displayed if the match rate among the sets exceeds a predefined threshold. This enhances the precision of the LLM results, minimizing the risk of LLM-generated illusions or inaccuracies.
A first application on a mobile device renders first graphical content for display in a first portion of a mobile device display screen. Also, the first application generates a tag as a placeholder for second graphical content to be displayed in a second portion of the screen, where the second graphical content is to be generated by a second application on the mobile device. In response to receiving a request for the second graphical content to be generated, the second application searches a plurality of layers of a WebView until the tag is found. Next, the second application renders the second graphical content as an HTML element into a given WebView layer where the tag was found within the plurality of layers of the WebView. Then, the first application displays the first graphical content and the second graphical content on the mobile device display screen.
The disclosure generally describes methods, software, and systems for request processing. An authentication request to access applications provided as a service is received during a single sign-on session. A cookie processing request for cookies corresponding to the session is processed. A storage access header of the authentication request is processed. The storage access header includes the browser's storage access permissions. The storage access permissions are used to determine storage access issues related to the cookies that prevent cross-application tracking. A partition key is used to generate new partitioned cookies for activating storage access. A conflict between the new partitioned cookies and previously stored cookies is identified. The previously stored cookies are removed to resolve the conflict. A response to the authentication request is provided using the new partitioned cookies to access the applications.
Various examples are directed to systems and methods of storing data in a computing system. An application may access argument data describing a first argument value. The application may access a first record from a node data structure using the first argument value, the first record from the node data structure describing a first argument identifier and a first node predicate position record from a node predicate position data structure using the first argument identifier. The application may access a first position predicate node record from a position predicate node data structure using the first predicate instance identifier and a second position identifier. The application may return first predicate instance data describing the first predicate instance, the first argument value at the first predicate instance position of the first predicate instance, and a second argument value at the second predicate instance position of the first predicate instance.
Methods, systems, and computer-readable storage media for generating a set of data embeddings from context data, each data embedding including N-dimensions and representing context data within a first embedding space, determining, for each dimension of the N-dimensions, a set of statistics, providing a set of thresholds, each threshold in the set of thresholds corresponding to a dimension of the N-dimensions and being determined based on a respective set of statistics for the dimension, generating a set of binary embeddings through binary quantization of data embeddings in the set of data embeddings using the set of thresholds, each binary embedding including the N-dimensions and representing context data in the set of context data within a second embedding space, retrieving a sub-set of context data responsive to a query based on the set of binary embeddings, and prompting a LLM using a prompt comprising the sub-set of context data.
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.
G06F 16/25 - Systèmes d’intégration ou d’interfaçage impliquant les systèmes de gestion de bases de données
H04L 67/146 - Marqueurs pour l'identification sans ambiguïté d'une session particulière, p. ex. mouchard de session ou encodage d'URL
H04L 67/2895 - Traitement intermédiaire fonctionnellement situé à proximité de l'application fournisseur de données, p. ex. intermédiaire de mandataires inverses
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.
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.
The present disclosure involves systems, software, and computer implemented methods for creating sourcing objects from free-form data. One example method includes automatically identifying a free-form text message received by a user of a first organization. A first trained artificial intelligence model determines that the free-form text message corresponds to a request to create a sourcing event for a sourcing application. Sourcing event fields for the sourcing event can be automatically extracted from the free-form text message using a second trained artificial intelligence model. A third trained artificial intelligence model automatically determines a sourcing event template for the sourcing event. An interface of the sourcing application is automatically invoked to create the sourcing event in the sourcing application. Sourcing event fields extracted from the free-form text message and an indication of the sourcing event template are provided to the interface.
G06F 16/383 - Recherche caractérisée par l’utilisation de métadonnées, p. ex. de métadonnées ne provenant pas du contenu ou de métadonnées générées manuellement utilisant des métadonnées provenant automatiquement du contenu
The present disclosure involves systems, software, and computer implemented methods for automatically determining sourcing event templates using machine learning. One example method includes training, using automatically-identified historical sourcing event data, a sourcing event template recommendation model to automatically recommend, from among a plurality of candidate sourcing event templates, a sourcing event template object for an upcoming sourcing event. Sourcing event field data is automatically extracted, using a sourcing event field extraction model, from a request to create the first upcoming sourcing event. Extracted sourcing event field data is provided to the sourcing event template recommendation model, which provides a first recommended sourcing event template for the first upcoming sourcing event. A sourcing event object is automatically created in a sourcing system for the first upcoming sourcing event, based on the extracted sourcing event field data for the first upcoming sourcing event and the first recommended sourcing event template.
In some embodiments, there is provided a method including in response to the indication of the error, receiving a request to resolve the error; generating a first prompt for a machine learning model; receiving, in response to the first prompt, a first prompt response; in response to receiving a first prompt response, generating a first query for augmentation information, the first query generated based on the first prompt response; executing the first query; receiving, in response to the first query, a first query response; in response to receiving the first query response to the first query, providing the first query response to the prompt builder to build a second prompt for the machine learning model. The process of prompting the second ML model, receiving a prompt response, and using the prompt response to generate a query may repeat until the error is resolved or no queries are available.
In an example embodiment, an average model prediction from predictions made by a tree-based machine learning model on training data is transformed using a sigmoid function. The sigmoid-transformed output is then used along with the numeric predictions about the training data made by the tree-based machine learning model and odds-based values generated by a tree explainer on the numeric predictions to fit a linear regressor. The fitting of the linear regressor produces coefficient and intercept values for the linear regressor, which can then be used at inference time to convert the output of the tree explainer from odds domain to the probability domain. The probability model explanations, along with the model predictions on the inference data, inference data and the average prediction in probability are passed to a generative artificial intelligence (GAI) model, which generates text-based explanations for the model predictions.
A system and method including receiving a parameterized query including at least one parameter; determining a selectivity for variant filters associated with the parameterized query, the variant filters having at least a minimum influence threshold on a query plan optimization for the parameterized query; determining, based on the determined selectivity for the variant filters associated with the parameterized query, whether there is a cache hit or a cache miss with a cached query plan and a query plan of the parameterized query; in response to determining there is a cache hit, fetching the cached query plan and executing the cached query plan for the parameterized query; and in response to determining there is a cache miss, compiling and executing the query plan for the parameterized query.
In some implementations, there is provided a computer-implemented method including receiving a query to grant user access to content generated by a large-language model, the query including a user identifier; verifying, based on the user identifier and using a first filter of a filter pipeline, a clearance level associated with the user identifier; granting, based on the verifying, the user access to at least a subset of the content generated by the large-language model; verifying, using at least a second filter of the filter pipeline, a temporal context of the query and a spatial context of the query, the temporal context comprising a time at which the query is received and the spatial context comprising a location from which the query is received; and providing, based on the verifying of the clearance level, the temporal context, and the spatial context, content generated by the large-language model.
A system includes an abstraction layer, a serverless service, and a predictive auto-scaling resource adviser coupled to the serverless service. The predictive auto-scaling resource adviser automatically scales the serverless service by adding or removing compute nodes based on computational needs of one or more planned workloads. Accordingly, the predictive auto-scaling resource adviser trains a first machine learning model to predict a first amount of computational resources expected to be utilized by a first client. Next, the predictive auto-scaling resource adviser activates a first plurality of compute nodes based on the prediction of the first amount of computational resources expected to be utilized by the first client for a first workload. Then, after activation, the system executes, with the first plurality of compute nodes, the first workload of the first client.
H04L 67/1031 - Commande du fonctionnement des serveurs par un répartiteur de charge, p. ex. en ajoutant ou en supprimant de serveurs qui servent des requêtes
Cloud systems store metadata for multiple tenants in cache memory. In uncompressed form, caching the metadata for an entity for multiple properties uses memory that is proportional to the number of tenants. As disclosed herein, global metadata is generated for one or more entities. The global metadata of an entity includes all properties of the entity from all tenants. For each entity, only one set of global metadata is stored. For each tenant, only the differential data for the entity is stored. As a result, the size of a tenant's differential metadata is substantially smaller than the tenant's original full metadata, saving cache resources of the cloud system. Full entity metadata for a tenant can be retrieved by making a copy of the global metadata for the entity and modifying the copy based on the tenant's differential data for the entity.
A computer-implemented method for generic tenant data replication for disaster recovery, includes regularly checking, by a primary replication agent on a primary site, for changes to a primary change log on the primary site. Based on an insert of a new change record in a secondary change log on a secondary site, triggering a stored procedure from secondary stored procedures on the secondary site, that extracts a change operation and data from the secondary change log and performs the changed operation on a secondary tenant table on the secondary site. By a secondary replication agent on the secondary site and from the primary replication agent, receiving a call not containing a sequence id for a change record marked as completed in the secondary change log, and deleting the change record. Using a replication agents control plane, providing central monitoring for the primary replication agent and the secondary replication agent.
G06F 11/00 - Détection d'erreursCorrection d'erreursContrôle de fonctionnement
G06F 11/14 - Détection ou correction d'erreur dans les données par redondance dans les opérations, p. ex. en utilisant différentes séquences d'opérations aboutissant au même résultat
In some embodiments, there may be provided extracting, from a redo log, a first chunk of data; checking whether a population indicator is set; in response to the first chunk of data, creating a main buffer; in response to a population indicator not set, writing the first chunk of data to the created main buffer and repeat the writing for one or more additional chunks until a last chunk is extracted; and after the last chunk is written to the main buffer, reading the main buffer to write the first chunk of data, the one or more additional chunks, and the last chunk to main memory. Related systems, methods, and articles of manufacture are also disclosed.
A computer-implemented method includes receiving, from a user interface, a query entered by a user inquiring usage of a set of dashboards associated with a process, obtaining one or more text segments that are semantically related to the query, composing a prompt using a prompt template which includes at least one placeholder for receiving the one or more text segments, prompting a generative artificial intelligence model using the prompt to generate a guide instructing usage of at least one dashboard in response to the query, and presenting the guide on the user interface. Related systems and software for implementing the method are also disclosed.
A system and method include reception of multiple streams of technical operational messages from a plurality of sources within the computing platform, definition of a set of technical operational message clusters, wherein each cluster is associated with a set of representative technical operational messages, comparison of the received technical operational messages to the sets of representative technical operational messages using Retrieval Augmented Generation (RAG), and classification of 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.
Techniques are disclosed for hierarchical semantic reranking of strings. In response to a natural language query, a search is performed using a vector-based search algorithm and/or a keyword-based search algorithm, thereby generating one or more ranked lists of strings. A hierarchical semantic reranking process is performed on the ranked list(s) of strings returned by the search, which includes a recursive selection process in which a language model performs successive rounds of pairwise comparisons to determine a top-ranked string from among the strings returned by the search, which is output in response to the query. In an explicit hierarchical reranking process, the pairwise comparisons are performed via submission of respective prompts to the language model; in an implicit hierarchical reranking process, the pairwise comparisons are performed via submission of a single prompt to the language model, which includes instructions for the language model to internally perform the recursive selection process.
A computer implemented method can detect performance regression of executing a query using a current query plan. Responsive to detecting the performance regression, the method can automatically search for one or more candidate solutions for resolving the performance regression, and select, from the one or more candidate solutions, an effective solution that resolves the performance regression. The selecting includes evaluating performance of executing the query using one or more alternative query plans generated by the one or more candidate solutions. The method can store the effective solution for future execution of the query. The effective solution is configured to generate an updated query plan selected from the one or more alternative query plans. The updated query plan has better performance than the current query plan for executing the query. Related systems and software for implementing the method are also disclosed.
An application generates a first user interface to enable a plurality of prompts to be combined into one or more groups of prompts, where each prompt of the plurality of prompts represents a filter for data targeted by subsequent queries. Next, the application generates a second user interface displaying the one or more groups of prompts in response to detecting that the plurality of prompts have been combined into the one or more groups of prompts in the first user interface. Then, a web intelligence engine executes a query in response to one or more values being specified, in the second user interface, for the one or more groups of prompts, where the one or more values filter the data returned by the query. Next, the web intelligence engine returns a result of the query to a first computing device based on executing the query.
A computer-implemented method for clean slate application transformation with transparent legacy system access, includes configuring an access and integrate legacy system (AILS) legacy data access module for access to a legacy application. Master data migration of a required subset of master data to a target application is triggered. Using the AILS legacy data access module and an AILS user interface (UI) widget in a target application UI, switching usage to the target application. Using the AILS legacy data access module and the AILS UI widget, closing usage of the legacy application for changes. The legacy application is decommissioned.
A scheduling framework may include a change rate data store that contains information about replication change rates for a source system over time. A computing resources scheduling server may access change rate information from the change rate data store representing data replication from the source system to a target system. The scheduling server may automatically calculate a computing resource value (e.g., a number of replication-worker instances) based on a Gaussian ceiling function and the change rate information. The scheduling server can then dynamically adjust at least one replication computing resource allocation in accordance with the calculated computing resource value. The system may arrange for the allocated computing resource to facilitate data replication from the source system to the target system. The dynamic adjustment of the replication computing resource allocation might also be based on a start-up time, a boundary, prior change rates, a PID controller, etc.
