According to some embodiments, systems and methods are provided including a memory storing program code: and one or more processing units to execute the program code to cause the system to: receive a request at an Artificial Intelligence (AI) assistant, the request received from a user of a remote device via a distributed communication network; receive, from an application associated with the request, a list of one or more frontend functions; select an AI Assistant capability based on the received request and the received list of one or more frontend functions; generate, by the AI Assistant, an executable command including a listed frontend function for the application based on the selected AI Assistant capability and the received request; and execute the executable command in response to receipt of the executable command by the application. Numerous other aspects are provided.
An application data store may contain advanced programming language code that includes function calls. A computer processor of a code analysis tool may access the advanced programming language code from the application data store. A first function call in the advanced programming language code is identified and a first hash value for the first function call is calculated (e.g., using SHA-1, MD5, or any other appropriate algorithm). The hash values might be calculated, for example, based on input, change, and/or output parameters of the function calls. The code analysis tool can then automatically determine that a second function call in the advanced programming language code is potentially identical to the first function call based on the first hash value and a second hash value calculated for the second function call. An indication of the determination is then transmitted to a user in connection with a trace tool.
The present disclosure relates to computer-implemented methods, software, and systems for persisting remittance information associated with transactions executed at a decentralized ledger. Transaction information for a first transaction executed by a payer at the decentralized ledger can be obtained by a payee system. The transaction information is associated with a transfer of digital assets from a payer account to a payee account of a payee. The transaction information comprises an identifier associated with the first transaction. Based on the identifier associated with the first transaction, remittance information associated with the first transaction can be obtained from the decentralized ledger or through a remittance storage service. The remittance information can be provided to the payee account of the payee as part of providing the transfer of the digital assets to the payee.
G06Q 20/10 - Payment architectures specially adapted for electronic funds transfer [EFT] systemsPayment architectures specially adapted for home banking systems
A in-memory certificate conversion system configured to determine that a configuration file contains a JKS certificate that is not compatible with a live data connector (LDC) and automatically convert the JKS certificate to a Public-Key Cryptography Standards (PKCS12) format certificate via a Java Virtual Machine of the LDC by generating a PKCS12 container containing the public key, private key, and the chain of trusted authority certificates for the JKS certificate and generating a PKCS12 format certificate by exporting the PKCS12 container as a bytes array. The in-memory conversion system provides, via the LDC, the PKCS12 format certificate to a web server for SSL configuration, where the web server is configured to establish secure communications using the PKCS12 format certificate in real time from a request to access a service via the web server.
H04L 9/32 - Arrangements for secret or secure communicationsNetwork security protocols including means for verifying the identity or authority of a user of the system
In an example embodiment, a machine learning framework is provided that enhances reliability of analysis of non-invasive cognitive input, correlates the cognitive input with additional non-cognitive input, and identifies context-based possible selections from software processes. A graphical user interface may be provided that depicts the possible selections to the user in a manner that makes it clear to the user which thoughts lead to which selections. This graphical user interface may be iteratively updated with each selection by the user, with each selection leading to one or more possible selections displayed in the graphical user interface being replaced with different possible selections. The result is a seamless framework that aids in enhancing cognitive interfaces.
Disclosed techniques facilitate the analysis of computing resource usage by data management objects, such as information lifecycle management objects. A selection of one or more data management objects is received, where each object abstracts underlying data storage entities, such as database tables or views. The selection may be based on user input specifying search terms, including business area identifiers, or direct object selection. The system identifies storage entities associated with the selected objects and determines a resource use footprint by obtaining memory usage data. When available, snapshot data is retrieved; otherwise, real-time computation is performed based on record count and storage allocation statistics. A user interface displays resource use data and enables user-specified adjustments to object residence time or allocated computing resources. Adjustments may trigger migration of data from memory to persistent storage or modification of storage parameters to optimize data residence and resource allocation.
In an example embodiment, an operation dialer for a cognitive user interface is provided. The purpose of the operation dialer is to identify organizational processes related to the intent of the user, determine workflows of those processes, and present a user interface that allows the user to select particular steps of the workflows using the cognitive interfaces. In other words, it allows the system to automatically determine which workflow the user is attempting to operate in and to present specific steps of that workflow for selection, depending upon where in the workflow the system is currently operating.
G06F 3/0482 - Interaction with lists of selectable items, e.g. menus
G06F 3/01 - Input arrangements or combined input and output arrangements for interaction between user and computer
G06F 3/04845 - Interaction techniques based on graphical user interfaces [GUI] for the control of specific functions or operations, e.g. selecting or manipulating an object, an image or a displayed text element, setting a parameter value or selecting a range for image manipulation, e.g. dragging, rotation, expansion or change of colour
In an example embodiment, a solution is provided that selects a portion of a non-in-memory database to migrate prior to a database migration option (DMO) performing a downtime portion of the migration. While it is typically not possible for the entire database to be migrated prior to the downtime portion due to the need for certain portions of the database to be used for the DMO portion itself, a substantial portion of the non-in-memory database can be migrated prior to the DMO performing the downtime portion of the migration by using specialized techniques. By migrating a substantial portion of the database prior to the downtime portion, the size of the portion of the database that needs to be migrated during the downtime portion is reduced, thus substantially reducing the length of time needed for the downtime portion.
Methods, systems, and computer-readable storage media for providing a set of Siamese pairs, a first sub-set of Siamese pairs representing positive pairs and a second sub-set of Siamese pairs representing negative pairs, executing iterations of training of a Siamese network using the set of Siamese pairs to minimize a first loss value and provide a trained Siamese network, generating a set of embeddings by processing at least a portion of the set of training data through the trained Siamese network, executing iterations of training of a classification model using the set of embeddings to minimize a second loss value and provide a trained classification model, and deploying the trained Siamese network and the trained classification model to a cloud computing environment to process log data generated within the cloud computing environment and classify the log data in one of a first class and a second class.
In an example embodiment, a combination of machine learning and rule-based techniques are used to automatically detect social engineering attacks in a computer system. More particularly, three phases of detection are utilized on communications in a thread or stream of communications: attack contextualization, intention classification, and security policy violation detection. Each phase of detection causes a score to be generated that is reflective of the degree of danger in the thread or stream of communications, and these scores may then be combined into a single global social engineering attack score, which then may be used to determined appropriate actions to deal with the attack if it transgresses a threshold.
Provided are systems and methods that can generate a simplified application programming interface for a custom software system that includes a pre-built application programming interface. In one example, a method may include receiving source code of an application programming interface (API) of a custom software system with built-in functionality for accessing the custom software system, identifying a subset of program components within the API which are not active based on a configuration of the software system, removing the subset of program components from the API to generate a simplified API for the custom software system, and transferring the simplified API to the storage.
A computer-implemented method can receive a user prompt from a user interacting with a generative artificial intelligence (AI) model; determine, in runtime, a topic of the user prompt; select, in runtime, a set of values for a plurality of hyper-parameters of the generative AI model based on the topic of the user prompt; and prompt, in runtime, the generative AI model using the user prompt while applying the set of values for the plurality of hyper-parameters of the generative AI model. The plurality of hyper-parameters controls a degree of determinism for generating responses based on the user prompt. Related systems and software for implementing the method are also disclosed.
Disclosed herein are system, method, and computer program product embodiments for securely performing a password change. An embodiment operates by receiving a password change request from a user. The password change request comprises an encrypted version of a new password for the user, a cleartext version of the new password, and a login name for the user. The embodiment then executes a command from a password rotator user account with the cleartext version of the new password, the encrypted version of the new password, and the login name. The embodiment then retrieves a public key associated with the login name. The embodiment then determines, based on the public key, that the password change request comes from the user and that the cleartext version of the new password has not been modified. The embodiment then sets the password of a user login associated with the user to the new password.
In an example embodiment, an iterative process is used to calculate the number of parallel work processes to set for a computer system. Specifically, an execution unit is started and the execution time for that execution unit is measured. This execution time for the single execution unit is called “unit time.” Then a fixed number (e.g., 20) of execution units are started, and the execution times of each are measured. If the execution time consumption of each of the execution units is lower than some fixed threshold percentage of the unit time (e.g., 120%), then this means that the maximum parallel processing capacity is higher than the fixed number of execution unit. Then more execution units can be added and the process repeated until the execution units'execution times exceed that fixed threshold percentage.
The described examples focus on a technology designed to improve road maintenance planning. This technology addresses the challenges faced in maintaining road infrastructure effectively. Traditional methods for selecting these treatments often rely on subjective assessments and historical data. These methods can lead to inefficient resource allocation and increased maintenance costs. The described examples propose a data-driven, optimization-based approach to road maintenance planning.
G06Q 10/20 - Administration of product repair or maintenance
G06Q 10/0637 - Strategic management or analysis, e.g. setting a goal or target of an organisationPlanning actions based on goalsAnalysis or evaluation of effectiveness of goals
The disclosure generally describes methods, software, and systems for open resource discovery protocol describing entity types. An identifier of a first entity type is received. The first entity type defines a relation between an application programming interface (API) and event information. A reference for the first entity type is generated based on the identifier of the first entity type. The reference links the first entity type to the API. A description of the first entity type is provided for storage using the reference for the first entity type. the description includes a structure of an underlying data model. A request to provide the first entity type based on the description of the first entity type is received. The first entity type is provided using an exposed API and the reference for the first entity type.
The present disclosure involves systems, software, and computer implemented methods for generating recommendations for relevant software fixes. One example method includes generating trend data for historical software issue notices for software products that indicate trends regarding implementations in deployments of the software products of corrections to the software products. A model is trained using the trend data, implementation counts for the historical software issue notices, and software issue notice metadata to predict whether a new software issue notice is relevant for a given software product deployment. A request is received for relevant software issue notices for a first software product deployment. The trained model determines a set of relevant software issue notices for the first software product deployment from among a set of recent software issue notices. A recommendation is generated based on the set of relevant software issue notices and is provided in response to the request.
In an example embodiment, a templating and detemplating component that allows for transparent integration with a cloud environment irrespective of the implementation is provided. It allows for two distinct ways of making changes in the cloud environment: (1) execution of commands through a command line tool; and (2) creation of custom resources by a user or system component.
In an example embodiment, a solution is provided that performs the rotation of access keys of cloud components that are shared in on-premise software components (such as in a hybrid deployment environment) such that a minimal number of keys are needed. The solution also provides for having a specified validity of the access key, so that the hybrid or on-premise components can retain access to the software components while the new access keys are being generated.
A scale-out computing cluster may include a large number of computing servers and storage devices. In order to provide high reliability, the computing cluster must be able to handle failures of individual devices. Reliability of the computing cluster may be improved by providing a standby server for each active server in the computing cluster. If any active server fails, the corresponding standby server is activated. The failed server may be brought back online or replaced, at which time the restored server becomes the standby server for the now-active original standby server. During the restoration period, if any other active server fails, the standby server for that active server is immediately activated. As a result, the recovery ability of the computing cluster is only challenged if both servers of an active/standby pair fail during the restoration period, substantially improving reliability.
G06F 11/20 - Error detection or correction of the data by redundancy in hardware using active fault-masking, e.g. by switching out faulty elements or by switching in spare elements
G06F 11/16 - Error detection or correction of the data by redundancy in hardware
The present disclosure relates to computer-implemented methods, software, and systems for identifying cyclic patterns in data observations collected as time series with irregular time spacing between each other. Distribution of the time occurrences associated with the data observations is analyzed to identify a cyclic pattern. A list of time gaps between each of the data observations is defined. Time gaps are defined according to a common time measure. The time gaps of the list of time gaps are evaluated using two reader operators that separately browse through the list of time gaps. A cyclic pattern is identified in the list of time gaps based on the iteratively evaluating. The identifying comprises identifying (i) a length of cycle within the cycle patterns and (ii) an index element of a time gap of the list of time gaps.
In an example embodiment, an in-context model is trained on synthetic datasets using an auto-regressive approach in lieu of a transformer approach. This allows replacing the backbone of the model with an auto-regressive architecture. The trained auto-regressive model is then capable of in-context predictions on tabular data. An in-context model leverages the immediate information provided to it during an interaction or session to generate predictions or responses, dynamically adjusting to the task or context at hand. An auto-regressive model is a type of model that generates predictions or outputs sequentially, where each output is conditioned on the previous outputs. It generates a new token (or piece of data) based on the data it has already produced, rather than looking at all the data at once. The trained in-context auto-regressive model is able to process tabular data more efficiently than a transformer model would.
A story data store may contain records representing a plurality of data visualization story arrangements associated with Key Performance Indicator (“KPI”) elements of an enterprise, each record including a story identifier. A watchlist data store may contain records that represent a plurality of watchlist layouts associated with the enterprise, each record including a watchlist identifier and at least one KPI display widget. A watchlist support platform may access a first data visualization story arrangement from the story data store and receive, from a user, a selection of a KPI element of the first data visualization story arrangement. A KPI display widget can then be added to a watchlist layout in the watchlist data store based on the selected KPI element of the first data visualization story arrangement. The watchlist support platform may then render a watchlist display, based on the watchlist layout, including the added KPI display widget.
A computer-implemented method includes receiving an event published by an application running on a server in response to a request for a service; filtering a full list of users of the server, using a tenant filter, to identify a group of tenant users who belong to a tenant identified by the event; filtering the group of tenant users, using a service filter, to identify a group of service-specific users interacting with the service identified by the event; filtering the group of service-specific users, using one or more user filters, to identify a group of eligible users permitted to receive the event; filtering the group of eligible users, using one or more topic filters, to identify a group of target users who subscribe to a topic of the event; and routing the event, via WebSocket connections, to a group of target clients associated with the group of target users.
Methods, systems, and computer-readable storage media for using a set of agents that are based on large language models (LLMs) to generate data queries for configuring applications, where a first LLM-based agent that is used to provide application properties based on application data sources and a knowledge graph during a design-time, and a second LLM-based agent is used to provide data queries at least partially based on the application properties during a runtime, the data queries being executable to retrieve data from one or more data sources within a cloud computing environment.
Arrangements for pre-deployment of configuration settings using shared container technology are provided. A customized table may be generated with the tenant identifier field being removed. A view of the database table which defines joins from the customized table including customer key ranges and a centralized table including vendor key ranges may be generated. Instead-of triggers used to modify the view upon an insert, upsert, or update operation on the view may be defined. An instead-of trigger may be executed in response to a modification action to the view. An instead-of trigger may determine whether the modification action applies to a customer key range or a vendor key range. The modification action may be redirected to the customized table in response to a determination that the modification action applies to the customer key range, or blocked in response to a determination that the modification action applies to the vendor key range.
System, method, and various embodiments for an application-specific digital assistant system are described herein. An embodiment operates by receiving a request from a user regarding usage of a first application. One or more data retrieval tools (DRTs) associated with generating an response to the request execute against a plurality of document. The one or more DRTs are configured to identify a subset of documents that are related to the request and generate a rank of at least a portion of documents from the subset of documents based on relative importance in generating an response to the request. A response prompt is generated for instructing a large language model (LLM) to generate the response to the request based on the subset of documents and the rank. The response to the request is provided to the user.
G06F 16/383 - Retrieval characterised by using metadata, e.g. metadata not derived from the content or metadata generated manually using metadata automatically derived from the content
28.
CUSTOM APPLICATION RESPONSES IN DATA PRIVACY INTEGRATION PROTOCOLS
The present disclosure involves systems, software, and computer implemented methods for custom processing in data privacy integration protocols. One example method includes receiving custom logic from a customer of a DPI (data privacy integration) service for customizing applications to evaluate requesting ground values received from the DPI service. The DPI service receives a protocol request that includes a requesting ground value. The DPI service generates and sends a work package that includes the requesting ground value. Each responder application that receives the work package evaluates the work package using the custom logic. The responder applications that received the work package send work package responses to the DPI service that include status information of the responder applications processing the work package. The DPI service evaluates the work package responses and sends a response to the protocol request that includes an overall status of DPI processing of the protocol request.
Systems and methods disclosed herein deploy microservices to a test system, simulate a production environment, and test the microservices to gather data about the actual relative resource consumption and capacities of the microservices. Using the gathered data, a resource allocation to be used for the microservices is determined. The production environment is configured according to the determined resource allocation. An administrator may manually adjust the determined resource allocations.
Example methods and systems are directed to automated assessment of note quality using clustering. Features for each note may be automatically determined. A clustering algorithm is applied to cluster the notes based on their features. The clusters may be labeled as good, bad, or poor. An isolation forest algorithm may also be applied to the notes to detect anomalous notes that are substantially lower in quality than average notes. The set of anomalous notes is compared with the cluster of poor quality notes to identify a set of filtered poor quality notes to be brought to the attention of a user for improvement. Specific suggestions for the improvement of notes may be generated by evaluating sentences in historical support tickets.
A system and method including receiving a signal to initiate execution of a modeled workflow including at least one artificial intelligence (AI) task to perform at least one activity towards a specified result and the AI task being assigned to an artificial intelligence (AI) agent; determining a current context for the modeled workflow; determining to call the AI agent to execute the AI task; determining by the AI agent, based in part on the current context, to call a large language model (LLM) to execute the at least one activity of the AI task, a prompt for the LLM model being derived from at least attributes of the AI task and the AI agent; and determining by the AI agent, based in part on a result of the call to the LLM model, at least one next action to perform towards an achievement of the result.
Methods, systems, and computer-readable storage media for providing an initial query tree responsive to a query for querying a database system, the initial query tree including a set of calculation view nodes, determining that all calculation views represented on the set of calculation view nodes can be unfolded, and in response, for a calculation view node in the set of calculation view nodes, identifying a condition provider procedure that is to be executed, executing the condition provider procedure to provide a filter string, and inserting the filter string into the initial query tree, providing a final query tree including the initial query tree and inserted filter strings, generating a query execution plan, executing, by an execution engine, the query execution plan to query a database and generate results responsive to the query, and returning the results.
Methods, systems, and computer-readable storage media for automatic handling of loosely-coupled objects during database export and import. An example method includes adding a target object identified for an export operation of a source database system to an export object list. Target objects are determined that are related to a loosely-coupled object that is not explicitly linked to the target object in a definition of the target object. Information for the related objects and the loosely-coupled object is added to the export object list with a flag that indicates that the loosely-coupled object is a loosely-coupled object type. An export file is generated based on the export object list and is provided to a target database system for importing the export file into the target database system.
Various examples are directed to systems and methods for querying a database management system. A system may receive a first chat tool input message from a user and provide the first chat tool input message as input to a trained computerized model. The system may determine a first output of the trained computerized model based on the chat tool input message indicates a first query to the database management system. The system may receive, from the database management system, first query response data in response to the first query. Based on the determining that the first output of the trained computerized model indicates the first query to the database management system, the system may generate comprising the first chat tool input message, the first query response data, and user metadata describing the user.
G06F 16/2457 - Query processing with adaptation to user needs
H04L 51/02 - User-to-user messaging in packet-switching networks, transmitted according to store-and-forward or real-time protocols, e.g. e-mail using automatic reactions or user delegation, e.g. automatic replies or chatbot-generated messages
35.
EFFICIENT TEXT REPLACEMENT WITH LARGE LANGUAGE MODELS
In an example embodiment, a framework is provided to interact with a large language model (LLM) in a way that allows for more efficient text replacement by the LLM. More specifically, a host program is provided that generates a specialized prompt to the LLM to request that the LLM correct or otherwise modify a portion of the document while only outputting the specific changes to be made as opposed to unchanged portions. A change implementation component on the host program will then implement the specific changes from the LLM on the original document to create a modified version of the document that incorporates the specific changes from the LLM.
A system includes obtaining a set of tasks designated for execution within a hyperscaler, collecting data on an operational readiness of operational resources required by the designated tasks, estimating a future success metric for a task of the designated tasks based on the operational readiness of the required operational resources, comparing the estimated future success metric to a minimum acceptable success threshold, in response to determining that the likelihood of successful completion is below the minimum acceptable success threshold, queuing the task for deferred execution, and in response to determining that the likelihood of successful completion is not below the minimum acceptable success threshold, passing the task to a scheduling mechanism of the hyperscaler for execution.
In a computer-implemented method for electronic data interchange (EDI), a base mapping representing commonality between a source and target data structure is generated. Based on the base mapping, a partner-specific overlay mapping is generated for a data exchange partner referring to the base mapping and containing mapping elements specific to the data exchange partner and different from the base mapping. Changes made to the base mapping is applied automatically to all partner-specific overlay mappings.
Systems and methods are provided for generating and storing vector embeddings for each set of data of the sets of data in respective table of a plurality of tables and storing, for each table, a model type and version corresponding to a model used to generate the vector embeddings stored in each respective table of the plurality of tables. The systems and methods further generate a response to a query by generating vector embeddings for the query with a same model type and version as the model type and version used to generate vector embeddings for one or more tables with relevant data to the query.
In an example embodiment, a software solution is provided that automates various aspects of a Period End Close (PEC) process and its evaluation. This provides a proactive and autonomous system that addresses complications that occur with prior art ERP systems involving PEC activities and provides graphical user interfaces for interacting with the system.
Methods, systems, and computer-readable storage media for receiving a query, processing the query through a named entity recognition (NER) machine learning (ML) model to generate a set of entities, identifying, from a set of tuples of a vector database, a sub-set of tuples responsive to the set of entities, determining, from the sub-set of tuples, a sub-set of chunks responsive to the query, generating a prompt including the sub-set of tuples and at least a portion of the query, prompting a first LLM using the prompt to providing a LLM response, and returning a response to the query, the response including at least a portion of the LLM response.
Embodiments of the present disclosure include techniques for improving out of memory management. In one embodiment, an out of memory (OOM) reserve buffer is used to store data pages when a page buffer is out of memory. The OOM reserve buffer includes a counter that counts a number of data pages in the OOM reserve buffer where both (i) a particular data page in the OOM reserve buffer has zero pointers directed at it and (ii) the particular data page has been sent to a write component to be written to the persistent memory. A request to add a new data page to the OOM reserve buffer is denied if the counter is zero, but if the counter is greater than zero, the system automatically waits a time period and then adds the new data page.
Embodiments of the present disclosure include techniques for writing data to persistent memory. In one embodiment, a system periodically enters a shared mode where data pages are written to disk and modified. The system may request exclusive access. If the request is granted, the system may block further modifications to the data pages. Requests for exclusive access may repeat a number of times. If a time period is exceeded without obtaining exclusive access, then the system may force an exclusive access to flush data to disk.
Methods, systems, and computer-readable storage media for providing an initial query tree responsive to a query, the initial query tree including a set of view nodes, determining a sub-set of view nodes from the set of view nodes, each view node in the sub-set of view nodes being included in the sub-set of view nodes in response to metadata indicating that row-level security is to be applied, for a first view node in the sub-set of view nodes, identifying a first condition provider procedure that is to be executed, determining that the first condition provider procedure comprises a first set of input parameters comprising predefined input parameters, and in response, executing the first condition provider procedure using values for the first set of input parameters provided for the first view node to provide a first filter string, and inserting the first filter string into the initial query tree.
Techniques are disclosed for extracting and applying structured debugging knowledge to resolve software bugs. A computing system processes electronic representations of software bug reports, including comments describing reasoning processes for debugging. A first neural language model extracts structured reasoning paths from the reports, which are used to fine-tune a second neural language model. When a new bug is encountered, the second model generates suggested actions or deploys a fix. Alternatively, structured reasoning paths are embedded into a vector database, enabling similarity searches against new bug descriptions. Retrieved reasoning paths are submitted to a neural language model to generate debugging recommendations or automated fixes. A hierarchical structure preserves relationships between reasoning paths, facilitating reasoning path retrieval and refinement. The system supports tree reconstruction, relational database storage, and hierarchical summarization of debugging knowledge to improve software maintenance and reduce resolution time.
As discussed herein, a generative AI (GenAI) tool is improved by using multiple LLMs, at least one of which is allowed to access tools that provide additional information to improve the quality of results. The output from a first LLM is provided as part of a prompt to a second LLM for review. If the second LLM rejects the results provided by the first LLM, a revised prompt for the first LLM is generated. This process is repeated until the second LLM approves a response by the first LLM. The functionality of the GenAI tool may also be expanded by allowing it to respond to a user query with a sequence of scenarios instead of a single scenario.
In an example embodiment, additional metadata is attached to a delta tables, via delta shares, in the form of a common schema notation (CSN) entity. When a request is received from a client for a share of a range of delta tables where the range comprises the delta table to which the additional metadata is attached, the most recent CSN entity for each of the delta tables in the range are aggregated and returned to the client.
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.
In an example embodiment, hallucinations in LLMs are reduced by incorporating specific training data that includes question/answer pairs where the answer in the training data is some variation of "I cannot answer this question." This technique involves constructing questions that cannot be answered due to unknown factual knowledge or logical questions that cannot be answered due to missing information. By training the LLM with such data, the model learns to recognize when it lacks the necessary information to provide a correct answer, thereby reducing the likelihood of generating plausible-sounding but incorrect responses. The described technique enhances user trust in LLMs by minimizing the risk of decisions being made based on incorrect information.
The described examples offer a solution by providing a design-time environment and a run-time environment. The design-time environment helps developers create and maintain configuration and other information that can be formed into chatbot runtime capabilities more easily. Developers can define what data can be accessed and how the data is to be filtered or displayed. The run-time environment is where the actual interaction with the user happens. When a user inputs a query, the system translates the query into a structured format that the ERP system can understand. This involves several steps, including identifying a capability that matches the query, generating a prompt for a large language model (using the capability), receiving a query, executing the query, and then processing the results to present them to the user.
Methods, systems, and computer-readable storage media for receiving a first job with a first time-series of a first type of historic resource utilization and a second time-series of a second type of historic utilization, receiving a second job with a third time-series of the first type of historic resource utilization and a fourth time-series of the second type of historic utilization, determining a first correlation coefficient between the first time-series and the third time-series, determining a second correlation coefficient between the second time-series and the fourth time-series, combining the first correlation coefficient with the second correlation coefficient to generate a first total correlation coefficient, and in response to the first total correlation coefficient being below a threshold, transmitting the first job and the second job as a first job pair to a first executor of the plurality of job executors to be executed concurrently by the first executor.
A computer implemented method can receive n training samples including sample values corresponding to m attributes and respective target values (n and m are positive integers), duplicate the sample values corresponding to the m attributes, pack the sample values into ciphertexts based on a batching option, and train a regression tree using the ciphertexts. The training is configured to encrypt the regression tree through homomorphic operations on the ciphertexts.
H04L 9/06 - Arrangements for secret or secure communicationsNetwork security protocols the encryption apparatus using shift registers or memories for blockwise coding, e.g. D.E.S. systems
52.
Preserving tabular data integrity for query processing system
System, method, and various embodiments for a tabular data integrity and query processing system are described herein. An embodiment operates by receiving a query to be executed against a knowledgebase. One or more keywords are identified from the query, and a vector search is performed against the knowledgebase based on the one or more keywords, the knowledgebase including documents that have been divided into a plurality of chunks. A subset of chunks related to generating an answer for the query are identified based on the vector search, the subset including a first chunk with a table ID. A table image corresponding to the table ID is identified. A prompt is generated instructing a language model to generate the answer to the query based on the subset of chunks, including the first chunk and the table image. The answer is provided.
Disclosed herein are system, method, and computer program product embodiments for implementing database queries using a major commit time stamp (CTS). An embodiment operates by receiving a data query indicating a predetermined delay from a user equipment (UE) and retrieving a major CTS from a memory. The data query corresponds to data in the memory. The major CTS indicates an age of the data. The embodiment determines that the major CTS is within the predetermined delay. In response to determining that the major CTS is within the predetermined delay, the embodiment transmits the data corresponding to the major CTS to the UE.
Generative AI (GenAI) applications make use of a prompt to guide the output of the Large Language Model (LLM). The prompt is generally composed of a static template with placeholders for input data, which are populated when the LLM is invoked. A solution is presented herein for generating synthetic data directly from the use case prompt template, reducing the dependency on actual data collection processes across a wide range of task domains. In some example embodiments, two main steps are performed. First, the LLM is asked to generate personas. Using the personas, the LLM is asked to generate input data for the placeholders of a prompt template. The responses for multiple personas are aggregated and de-duplicated, resulting in a synthetic set of values for the placeholder of the prompt template.
Methods, systems, and computer-readable storage media for querying database systems using queries generated by prompting of LLMs to generate query statements from natural language, where a LLM system provides a set of query statements in response to user input that is provided in natural language, the set of query statements includes a first query statement provided using an in-context prompt, a second query statement provided using a chain-of-thought (CoT) prompt, a third query statement provided using a contrastive CoT prompt, and a fourth query statement provided using a mixture-of-experts (MoE) prompt, and a query statement is selected from the set of query statements and is used to query a database system, which returns a query result responsive to the query statement.
During machine learning training, encoding and decoding are decoupled into two different processes. In a first process, an untrained version of an encoder is trained by optimizing encoder parameters in order to increase an amount of stochastic dependence between a vector embedding set and ground truth data, where the vector embedding set is generated by the untrained version of the encoder. In a second process, an untrained version of a decoder is trained with the vector embedding set generated by the trained version of the encoder. Output data generated by a trained version of the decoder is provided to one or more software applications to enable the one or more software application to perform one or more tasks.
Embodiments of the present disclosure include techniques for improving dynamic log level management. In one embodiment, a plurality of logging systems in a plurality of applications stores a plurality of log topics in a data storage system, each log topic having a first log level. Different log levels produce different amounts of information for log messages. A first logging system in a first application receives a first instruction to change the first log level of a first log topic to a second log level, having greater level of detail, changes the first log topic to the second log level in the application and the data storage system. The plurality of applications periodically detects modification of the first log topic data and change the first log level for the first log topic to the second log level in the plurality of applications excluding the first application.
A computer-implemented method can receive a submitted vulnerability specifying a vulnerability type and steps to reproduce a suspected bug of a software, determine a first base model score based on keywords appeared in the vulnerability form, determine a second base model score based on vulnerability type-specific contextual information extracted from the vulnerability form, determine a first probability modifier based on features identified from the vulnerability form, determine a second probability modifier based on mapping any file attachment associated with the vulnerability form to a corresponding step, determine a third probability modifier based on pairing and grouping selected steps, determine a vulnerability score based on the first and second base model scores, and the first, second, and third probability modifiers, and classify the vulnerability form as valid or invalid based on the vulnerability score. Related systems and software for implementing the method are also disclosed.
G06F 21/57 - Certifying or maintaining trusted computer platforms, e.g. secure boots or power-downs, version controls, system software checks, secure updates or assessing vulnerabilities
60.
UPGRADE OF NON-IMPORTED CONFIGURATION DATA IN A VERSION REPOSITORY DURING SOFTWARE CHANGES
For a first table storing configuration data for an enterprise resource planning software application, the first table is renamed with a second name. Next, a second table is created as a separate version of the first table. Then, a first view is created of the first table, where the first view is a union of the first table and the second table, where the union is implemented with a first select clause for the first table for all clients other than a first client, and where the union is implemented with a second select clause for the second table for only the first client. Finally, one or more queries are executed by accessing first data via the first view.
In an example embodiment, an COMPRESSED schema representation is used for input to LLMs to reduce the token count of such input, thus decreasing inference time and cost in contrast to previous LLM-based solutions. This COMPRESSED schema representation is then used by the LLM when presented with a prompt to generate an intermediate representation of computer code, leading to more COMPRESSED LLM generation of the intermediate representation.
In some implementations, the techniques may include receiving a first input indicating a request for modifying a displayed translation. In addition, the techniques may include receiving a second input indication a portion of the displayed translation. The techniques may include determining domain information for the portion of the displayed translation. The techniques may include accessing a data repository for a modified translation based at least in part on the domain information. When the modified translation is not stored in the data repository techniques may include receiving the modified translation from an expert user and storing the modified translation and the domain information in the data repository. The techniques may include modifying the displayed translation using the modified translation. The techniques may be performed on one or more computing devices. The techniques may be performed by a system or stored as a series of instructions on a computer-readable tangible medium.
G06F 3/0481 - Interaction techniques based on graphical user interfaces [GUI] based on specific properties of the displayed interaction object or a metaphor-based environment, e.g. interaction with desktop elements like windows or icons, or assisted by a cursor's changing behaviour or appearance
G06F 40/58 - Use of machine translation, e.g. for multi-lingual retrieval, for server-side translation for client devices or for real-time translation
63.
COMBINING STRUCTURED AND UNSTRUCTURED DATA FOR RAG
A system and method include identification of a plurality of stored multi-dimensional numerical vectors similar to a first multi-dimensional numerical vector representing the received text, identification of a first plurality of documents associated with respective ones of the identified plurality of stored multi-dimensional numerical vectors, determination of a second plurality of the first plurality of documents which are associated with a respective metadata value of the first metadata field, and prompting of a text generation model to determine relevancies of each metadata value to the received text based on the second plurality of documents.
A computing system receives a machine learning model that has been trained using historical event data to predict deviations between scheduled and actual event outcomes. Example training include temporal attributes, contextual attributes, or observed deviation patterns. The system processes attributes of a planned event using the trained model to generate a predicted deviation. If the predicted deviation exceeds a configurable threshold, the system initiates at least one of: generating an alert, blocking execution of related operations, adjusting scheduling parameters, modifying execution conditions, receiving user input to override an alert or adjust scheduling data, or dynamically updating threshold parameters based on historical deviation trends or real-time conditions. The technology can be integrated into workflow automation, scheduling optimization, and decision-support applications to improve planning accuracy, operational efficiency, and predictive reliability across various domains.
G06Q 10/04 - Forecasting or optimisation specially adapted for administrative or management purposes, e.g. linear programming or "cutting stock problem"
A computer-implemented method can receive a log message comprising a sequence of L characters, wherein L is a positive integer, generate embeddings for the sequence of L characters, and generate feature vectors for N tokens based on the embeddings. A token represents M consecutive characters in the log message, M is an integer greater than one, and N is a smallest integer greater than or equal to L divided by M. The method can predict N binary coded values based on the feature vectors for N tokens, and generate a sequence of L parameter masks based on the N binary coded values. A parameter mask indicates that a corresponding character in the log message is a static character or a variable character. Related systems and software for implementing the method are also disclosed.
Methods, systems, and computer-readable storage media for receiving, by a first LLM-based agent, a data schema description, a task description, and a set of examples, prompting, by the first LLM-based agent, a first LLM using a first prompt that is provided based on the data schema description, the task description, and the set of examples, the first LLM returning a set of metrics responsive to the first prompt, filtering data from a query document and data from a target document using the set of metrics, prompting, by a second LLM-based agent, a second LLM using a second prompt that is provided based on unstructured data of the query document, the second LLM returning a set of property-value pairs responsive to the second prompt, providing a merged query document, and processing the merged query document and the target document using a global ML model to generate a set of results.
System, method, and various embodiments for an application modification system, are described herein. An embodiment operates by receiving a user instruction to modify a data object, and identifying a plurality of applications to which the user has access. The data object is compared to the specification for at least a subset of the plurality of applications, and a first specification that includes the data object is identified. One or more requirements for performing the modification to the data object in accordance with first specification are identified. Feedback corresponding to the one or more requirements is received from the user. The API call to the first application is generated, and the data object of the first application is modified in accordance with the generated API call.
A system and method including specifying, for a defined integration flow, a first entity type of at least one data object associated with at least one producer system and a second entity type of at least one data object associated with at least one consumer system are logically equivalent; receiving, from the at least one producer system and the at least one consumer system, metadata including key fields of the at least one data object of the first entity type from the at least one producer system and a source identifier of the at least one data object of the second entity type from the at least one consumer system that references the at least one producer system; and determining, based on the metadata, a same value for an object identifier for each of the at least one first entity type and the second entity type, respectively.
A system includes monitoring of performance metrics associated with one or more predefined system performance requirements to obtain historic performance metric data, predicting from the historic performance metric data a quantitative compliance metric indicating compliance with the one or more predefined system performance requirements for a plurality of future time frames, estimating an impact of a proposed maintenance activity on the quantitative compliance metrics, calculating, for each future time frame, a risk factor indicative of a likelihood of violation of each predefined system performance requirement, the risk factor being based on the predicted quantitative compliance metric and the estimated impact of the proposed maintenance activity, computing, for each future time frame, a combined risk factor from the risk factors, obtaining a selected time frame for performing the maintenance activity based on the combined risk factors, and initiating the maintenance activity in the selected time frame.
Using a data analysis activity (DAA) definition, a DAA associated with a software application is triggered. An instance selector query is executed to generate a set of instance values as input for a data query. A data query to generate a data set is executed using instance values of the set of instance values. Using the data set, an instruction for an artificial intelligence (AI) engine is computed. A result based on the instruction for an AI engine is received from the AI engine. The result based on the instruction for an AI engine is stored into an AI Result History Store. Prior results from earlier DAA executions is read from the AI Result History Store. A notification to a defined target audience is sent using the software application.
Systems and methods include reception of a request from an application for text generation including a scenario identifier and a payload, determination of a stored scenario definition associated with the scenario identifier, determination of a prompt template definition from the scenario definition, determination of a model deployment from the scenario definition, generation of a prompt based on the prompt template definition and the payload, transmission of the prompt to the model deployment, reception of a response to the prompt from the model deployment, and return of the response to the application.
Systems and methods described herein relate to data expansion techniques for machine learning. A generative model trained on an initial dataset generates candidate images based on input images and corresponding class labels. A mask is applied to each candidate image to obtain masked images that are then reconstructed using the generative model. Candidate images are filtered by removing those that are too dissimilar when compared to their reconstructed versions. The remaining candidate images are combined with the initial dataset to form an expanded dataset.
G06V 10/72 - Data preparation, e.g. statistical preprocessing of image or video features
G06V 10/74 - Image or video pattern matchingProximity measures in feature spaces
G06V 10/764 - Arrangements for image or video recognition or understanding using pattern recognition or machine learning using classification, e.g. of video objects
A computing system and methods for aligning process graph representations and processing multi-representational datasets are disclosed. A first process graph representation is aligned with a second reference process graph representation using a matcher implemented in a matcher code module. A similarity evaluation is performed at one or more levels of process abstraction, and process-wide metrics are generated to assess overall alignment quality. A user interface renders the metric results and allows user modification of alignment parameters or element correspondences. Additionally, a dataset with at least two representations is processed to generate embedding vectors using different embedding techniques. The embedding vectors are combined into a hybrid vector representation, which is analyzed to determine a similarity measure relative to an input query. Search results are rendered based on the similarity measure. The disclosed techniques improve alignment accuracy, computational efficiency, and the relevance of search results in multi-representational datasets.
A system and method include receiving a text description of a service, generating a prompt based on the text description to request object properties of the service, prompting a text generation model with the prompt to generate the object properties of the service, receiving the generated object properties from the text generation model, converting the generated object properties from a first format to a second format, and instructing an object generator to generate artifacts of the service based on the converted object properties.
G06F 40/143 - Markup, e.g. Standard Generalized Markup Language [SGML] or Document Type Definition [DTD]
H04L 51/02 - User-to-user messaging in packet-switching networks, transmitted according to store-and-forward or real-time protocols, e.g. e-mail using automatic reactions or user delegation, e.g. automatic replies or chatbot-generated messages
A system and method include reception of a prompt, determination that the prompt is not semantically similar to any of a plurality of text generation model prompts, in response to the determination, prompt a first text generation model to determine whether the prompt is malicious, in response to a determination that the prompt is not malicious, prompt a second text generation model with the prompt to determine a first prompt output, prompt a third text generation model to determine whether the first prompt output is malicious, and, in response a the determination that the third text generation model determined that the first prompt output is not malicious, return the prompt output in response to the prompt.
In an event-based introspection protocol for landscape and event exchange monitoring, an event client subscribes as an event client with a messaging infrastructure. The event client publishes a client connected message to the messaging infrastructure. The event client publishes a client alive ping message to the messaging infrastructure. The event client consumes event data from one or more other event clients subscribed to the messaging infrastructure from the messaging infrastructure. The event client processes status information based on the consumed event data from one or more other event clients. The event client adds the processed status information to a status table. The event client sends a client disconnected message to the messaging infrastructure to disconnect from the messaging infrastructure.
An enterprise Retrieval-Augmented Generation (“RAG”) pipeline data store may contain electronic records that represent RAG pipelines, each record including a pipeline identifier and at least one tuning parameter. A Generative Artificial Intelligence (“GenAI”) launchpad platform, associated with at least one Large Language Model (“LLM”), includes an enterprise RAG pipeline engine that accesses information associated with a first RAG pipeline that was created by a first tenant. The enterprise RAG pipeline engine receives from a user an adjustment to a tuning parameter of the first RAG pipeline (e.g., for document ingestion, chunk tuning, embed tuning, similarity search, and/or context tuning) and automatically calculates an overall pipeline credibility score for the adjusted first RAG pipeline. The pipeline engine may then display the overall pipeline credibility score to the user and store information about the adjusted first RAG pipeline into the RAG pipeline data store.
In an example embodiment, a filtering system is introduced to optimize the organization and processing of LLM request. By carefully categorizing queries based on their input prompt lengths and anticipated output token numbers, the workflow is streamlined prior to submission to an LLM inference server. Each bucket corresponds to a different range of number of tokens (both input and output combined). Each bucket also has a size, indicating the maximum number of requests that can be placed in the bucket. Each request is assigned to a bucket when it is received, and when a bucket is filled the requests in the bucket are batched together and send to the LLM for processing.
The present disclosure involves systems, software, and computer implemented methods for system provisioning. One example method includes receiving a request for provisioning of a software solution. A knowledge graph is accessed that comprises a graph of object types of sample data and dependency information for the object types. The knowledge graph is traversed to identify object types and object dependencies included in the software solution. An interface is invoked to determine whether a data repository includes, for each identified object type, data for the identified object type. In response to determining that the data repository includes data for each identified object type, the interface is invoked to iteratively retrieve, in a dependency order determined based on the object dependencies of the identified object types, data from the data repository of each identified object type. Retrieved data is provided, in the dependency order, for deployment during provisioning of the software solution.
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 computer-implemented method can receive a vulnerability report for a software. The vulnerability report specifies a vulnerable library used by the software and a path of the vulnerable library within the software. The method can generate a summary of the vulnerability report using a generative artificial intelligence (AI) model, retrieve, from a bug report database, a set of relevant bug reports specifying the vulnerable library, generate a synopsis for the set of relevant bug reports using the generative AI model, generate multiple preliminary decisions on validity of the vulnerability report using the generative AI model based on the summary of the vulnerability report and the synopsis for the set of relevant bug reports, and generate a final decision on validity of the vulnerability report based on the multiple preliminary decisions. Related systems and software for implementing the method are also disclosed.
G06F 21/00 - Security arrangements for protecting computers, components thereof, programs or data against unauthorised activity
G06F 21/57 - Certifying or maintaining trusted computer platforms, e.g. secure boots or power-downs, version controls, system software checks, secure updates or assessing vulnerabilities
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 - Matching criteria, e.g. proximity measures
G06F 18/2113 - Selection of the most significant subset of features by ranking or filtering the set of features, e.g. using a measure of variance or of feature cross-correlation
G06F 123/02 - Data types in the time domain, e.g. time-series data
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.
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.
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.
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 of image or video features relating to colour
G06V 10/74 - Image or video pattern matchingProximity measures in feature spaces
G06V 10/762 - Arrangements for image or video recognition or understanding using pattern recognition or machine learning using clustering, e.g. of similar faces in social networks
95.
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.
