Computer implementation methods, computer programs, and computer systems (generation of software function descriptions using generative machine learning models)

Abstract

This can lead to inaccurate and / or error-prone descriptions and the resulting software artifacts. [Solution] A computer implementation method includes the steps of: identifying development relationship information in at least one functional architecture associated with a given item of software; generating at least one knowledge graph representing at least a portion of the development relationship information; generating at least one prompt at least partially based on one or more portions of the at least one knowledge graph; generating one or more software function descriptions for at least a portion of a given item of software by processing the at least one prompt using at least one generative machine learning model; and performing one or more automated actions at least partially based on one or more software function descriptions.

Description

Technical Field

[0001] [Copyright Notice] A portion of the disclosure of this patent document contains subject matter that is subject to copyright protection. The copyright owner reserves all copyright rights whatsoever except that any person may reproduce and copy the patent document or the patent disclosure as printed in the patent wrappers or records of the Patent and Trademark Office without any dissent.

[0002] This application generally relates to information technology, software development, generating machine learning models, artificial intelligence agents that interact with generating machine learning models, and utilization of resources of generating machine learning models to assist in software development tasks.

Summary of the Invention

Problems to be Solved by the Invention

[0003] Descriptions of software functions used in software development can help the development team better understand and meet user needs. However, in many conventional software development methods, such descriptions are limited to individual parts of a given software and often lack a proper understanding of the overall system architecture, thus leading to inaccurate and / or error-prone descriptions and the resulting software artifacts.

Means for Solving the Problems

[0004] In at least one embodiment, a computer implementation method may include the steps of: identifying development relation information in at least one functional architecture associated with a given item of software; and generating at least one knowledge graph representing at least a portion of the development relation information. The method may also include the steps of: generating at least one prompt at least partially based on one or more portions of the at least one knowledge graph; and generating one or more software feature descriptions for at least a portion of a given item of software by processing the at least one prompt using at least one generative machine learning model. Furthermore, the method may include the steps of performing one or more automated actions at least partially based on one or more software feature descriptions.

[0005] Another embodiment or element of the present invention may be implemented in the form of a computer program product that, when implemented as described herein, tangibly embodies computer-readable instructions causing a computer to perform a plurality of method steps. Furthermore, another embodiment or element of the present invention may be implemented in the form of a system comprising memory and at least one processor coupled to the memory, and may be configured to perform the method steps described herein. Moreover, another embodiment or element of the present invention may be implemented in the form of means for performing the method steps or elements described herein; such means may include a hardware module, or a combination of hardware and software modules, the software module being stored in a tangible computer-readable storage medium (or a plurality of such mediums).

[0006] These and other objects, features and advantages of the present invention will become apparent from the following detailed description of their exemplary embodiments, which will be read in conjunction with the accompanying drawings. [Brief explanation of the drawing]

[0007] [Figure 1]This figure shows an exemplary system architecture for automatically generating software function descriptions according to an exemplary embodiment of the present invention.

[0008] [Figure 2] This figure shows the workflow of an exemplary architecture graph parser according to an exemplary embodiment of the present invention.

[0009] [Figure 3] This figure shows an exemplary workflow for aligning different entity descriptions according to an exemplary embodiment of the present invention.

[0010] [Figure 4] This figure shows an exemplary workflow for generating a user story according to an exemplary embodiment of the present invention.

[0011] [Figure 5] The following is exemplary pseudocode for generating a user story prompt template in an exemplary embodiment.

[0012] [Figure 6] A flowchart illustrating the technique according to an exemplary embodiment of the present invention.

[0013] [Figure 7] This figure shows a computing environment in which at least one embodiment of the present invention may be implemented. [Modes for carrying out the invention]

[0014] As described herein, at least one embodiment includes automatically generating a software feature description (also referred to herein as a user story) based at least partially on one or more feature architecture graphs and requirements, using at least one generative machine learning model (e.g., at least one large-scale language model (LLM)). As used herein, a user story generally refers to a description of a software feature used in software development, such a description may include focusing on, for example, one or more user needs, one or more values, etc. More specifically, a software feature description used in software development can help a development team better understand and meet user needs. However, in many conventional software development methodologies, such descriptions are often limited to individual parts of a given software and lack a reasonable understanding of the overall system architecture, thus leading to inaccurate and / or error-prone descriptions and the resulting software artifacts.

[0015] According to one aspect of the present invention, a computer system, a computer program product, and a computer implementation method are provided for performing an operation comprising: identifying development relation information in at least one functional architecture associated with a given item of software; generating at least one knowledge graph representing at least a portion of the development relation information; generating at least one prompt at least partially based on one or more portions of the at least one knowledge graph; generating one or more software function descriptions for at least a portion of a given item of software by processing the at least one prompt using at least one generative machine learning model; and performing one or more automated actions at least partially based on one or more software function descriptions. Such an operation improves the speed of software development and increases the efficiency of resource requirements associated with software development.

[0016] In embodiments, identifying development relationship information within at least one functional architecture associated with a given item of software includes analyzing information about one or more elements and one or more relationships within at least one functional architecture. Such operations improve accuracy in the development of the corresponding software feature. Additionally or alternatively, in embodiments, identifying development relationship information within at least one functional architecture associated with a given item of software includes processing one or more extensible markup language files associated with at least one functional architecture, and / or processing one or more image features associated with at least one functional architecture. Such operations lead to more comprehensive deliverables with respect to the corresponding software development task.

[0017] In other embodiments, performing one or more automated actions includes automatically initiating one or more software development tasks for a given item of software, based at least partially on one or more software feature descriptions. Such actions enable automated system actions with respect to software development and eliminate error-prone manual work. Additionally or alternatively, in embodiments, performing one or more automated actions includes automatically training at least a portion of at least one generative machine learning model using feedback related to one or more software feature descriptions. Such actions create a more specialized and accurate generative machine learning model. In other embodiments, performing one or more automated actions also includes automatically sending one or more software feature descriptions to at least one software development relational system and one or more software development relational users. Such actions improve efficiency and speed in the delivery of software development artifacts.

[0018] Furthermore, in embodiments, generating at least one knowledge graph includes aligning two or more different descriptions of at least a portion of development relational information. Such operation makes the software development results more robust and accurate. Additionally, in embodiments, generating at least one prompt includes generating one or more software development relational requirements, one or more instructions for generating one or more software feature descriptions, and one or more formatting instructions, at least partially based on one or more portions of at least one knowledge graph. Such operation improves the accuracy and system compatibility of the software development artifacts. Also in embodiments, generating one or more software feature descriptions for at least a portion of a given item of software includes generating a first software feature description, processing feedback from at least one artificial intelligence agent relating to the first software feature description, and generating a second software feature description by modifying at least a portion of the first software feature description, at least partially based on one or more portions of the feedback. Such operation enables automated customization of software development tasks, thereby reducing processing delays and relational resource requirements.

[0019] One or more embodiments include using at least one LLM to process an overall architecture diagram and one or more subsystem architecture diagrams of a given software development task, along with development system inputs (e.g., inputs from at least one data engineer), to automatically generate at least one user story about a given software development task. As further detailed herein (e.g., in relation to Figure 1), such an embodiment includes implementing at least one architecture graph parser for analyzing elements and relationships in the functional architecture of a given software, at least in part on inputs such as, for example, the original extensible markup language (XML) and image features. In such an embodiment, the at least one architecture graph parser generates and / or outputs at least one knowledge graph representing the functional architecture elements and relationships of a given software. In at least one embodiment, elements and relationships represent nodes and edges in the architecture graph, respectively. For example, elements may include items such as applications, real-time ingestion, etc., and relationships may include items such as feed relationships between two nodes in an architecture diagram.

[0020] Also, such an embodiment may include implementing at least one user story generator for generating one or more user stories for a given software, at least partially based on processing at least one knowledge graph using at least one large language model (LLM). More specifically, one or more embodiments may include extracting element information and / or relationship information from at least one knowledge graph to generate and / or modify at least one prompt template (e.g., generative pre-trained transformer (GPT), bidirectional encoder representations from transformer (BERT), etc.) for at least one LLM to generate one or more user stories. Further, in at least one embodiment, feedback regarding one or more generated user stories may be obtained (e.g., from one or more users such as members of a development team), and used to improve at least a portion of the one or more user stories before outputting the one or more user stories for use in relation to the development of the given software.

[0021] Additionally, at least one embodiment includes providing beneficial effects such as, for example, improving the quality of user stories, reducing the time and resources required to generate user stories, accelerating agile development processes, and improving software development deliverables with respect to user needs and / or requirements, including generating and / or implementing an automated user story generation system.

[0022] FIG. 1 is a diagram showing an exemplary system architecture for automatically generating software function descriptions according to an exemplary embodiment of the present invention. By way of example, FIG. 1 shows an automated software function description generation system 105 that includes an architecture graph parser 104 and a user story generator 116. Thus, one or more embodiments include automatically generating user stories 112 based at least in part on a functional architecture graph (e.g., user story knowledge graph 106) and at least one LLM 122. More specifically, the architecture graph parser 104 analyzes elements and relationships within the functional architecture graph 114 based at least in part on processing image features associated with the functional architecture graph 114 and at least one original XML file.

[0023] Additionally, as shown in FIG. 1, the user story knowledge graph 106 is generated and / or output by the architecture graph parser 104 and / or based on the output of the architecture graph parser 104. In one or more embodiments, the user story knowledge graph 106 represents and / or stores at least a portion of the elements and relationships via the architecture graph. Additionally or alternatively, one or more embodiments may include aligning different descriptions from different functional architecture graphs 114 and constructing a user story knowledge graph 106 for one or more overall functions.

[0024] Furthermore, information from the user story knowledge graph 106 and / or therefrom is provided to the user story generator 116. In addition to the information from the user story knowledge graph 106 and / or therefrom, the user story generator 116 processes information from one or more software relation requirements 108, information from at least one relation knowledge base 110, and input from the user 102. Based at least in part on such processing, the user story generator 116 generates and outputs a user story 112. More specifically, within the user story generator 116, the artificial intelligence agent 118 processes at least a portion of the stated input to generate and / or modify a prompt template 120, which is then processed by the LLM 122 to generate the user story 112 (which can be fine-tuned using feedback processed via the artificial intelligence agent 118). The user story 112 can then be output and / or transmitted to the user 102 (e.g., a software development relation engineer).

[0025] As used herein, an artificial intelligence agent (e.g., artificial intelligence agent 118) refers to a system or program capable of autonomously performing one or more tasks on behalf of at least one user and / or system by designing one or more corresponding workflows and utilizing one or more available tools. Also, in at least one embodiment, the artificial intelligence agent 118 does not possess and / or maintain a complete knowledge base required to perform all tasks reasonable for the agent's design. Thus, as stated above, the artificial intelligence agent 118, which may represent a learning artificial intelligence agent, can utilize available tools such as reasonable requirements data (e.g., requirements 108), at least one relational knowledge base 110, and at least one user story knowledge graph 106. When missing information is retrieved from one or more such tools, the artificial intelligence agent 118 can update its own agent knowledge base 123, which can then be used to re-evaluate the plan of action and / or self-correct one or more aspects of a given task.

[0026] In at least one embodiment, the artificial intelligence agent 118 includes a prompt generator 121 that utilizes a prompt template 120 to construct tailored prompts, at least partially based on an LLM 122 for natural language processing and information stored in the agent knowledge base 123, and at least partially based on guidance and / or knowledge from the user story knowledge graph 106, relational knowledge base 110, and requirements 108. More specifically, in such one embodiment, the prompt generator 121 includes a generative machine learning model that is trained to generate prompts (e.g., via supervised training). Furthermore, in one or more embodiments, the artificial intelligence agent 118 can generate one or more structured prompts (via the prompt generator 121) and process one or more structured prompts using the LLM 122 to create a user story 112, thereby ensuring intent recognition and contextual relevance by referencing elements and relationships in the knowledge graph, as well as verifying the output for consistency.

[0027] Furthermore, as a mere example, an exemplary embodiment may include implementing the following workflow in relation to the artificial intelligence agent 118: Using input from the user story knowledge graph 106, the relation knowledge base 110, and / or one or more relation requirements 108, the artificial intelligence agent 118 leverages the prompt template 120 and the prompt generator 121 to generate a prompt. The artificial intelligence agent 118 then invokes the LLM 122 with the prompt, the part of which informs the LLM 122 what the task is (e.g., to generate a user story) and what types of tools are available for use (e.g., the user story knowledge graph 106, the relation knowledge base 110, and / or one or more relation requirements 108), and the artificial intelligence agent 118 also allows the LLM 122 to make a decision on which tools to use, along with reasonable parameters for invoking the tools. As an example, the prompt template 120 may include a variable such as tools_related_prompt, which provides a description of a list of available tools. For each such tool, the prompt template 120 may include the tool name, a description of the tool, one or more required parameters for the tool, and a description of each parameter of the tool. Furthermore, the prompt template 120 may include a variable such as action_result, which represents and / or indicates the output of the tool described above.

[0028] Based on such a decision from LLM122, the artificial intelligence agent 118 interacts with a given tool, retrieves results and / or information from the given tool, adds such results to a prompt, and calls LLM122 again. One or more embodiments may include repeating the above steps until it indicates that the decision of LLM122 is considered the final answer and thus its processing can be terminated.

[0029] In this process, the artificial intelligence agent 118 learns over time to adapt to the user's expectations (for example, through feedback from user 102 to the generated user story 112). The artificial intelligence agent 118 stores such feedback and relational information about past interactions in the agent knowledge base 123, and then uses such stored data to plan future actions and facilitate a customized experience and / or comprehensive response.

[0030] Figure 2 shows a workflow of an exemplary architecture graph parser according to an exemplary embodiment of the present invention. For illustrative purposes, Figure 2 shows a workflow performed by an exemplary architecture graph parser 204 that processes files associated with a functional architecture graph 214 to assemble a user story knowledge graph. More specifically, step 225 includes extracting elements and relationships from one or more XML files associated with the functional architecture graph 214. In one or more embodiments, the corresponding XML files may be exported directly through architecture software. Step 226 also includes storing the extracted element and relationship information in at least one graph database.

[0031] While XML files can contain important element and attribute relationship information, certain node attribute relationships may be absent, potentially leading to information loss in the generated graph. Therefore, step 227 includes using optical character recognition (OCR) to extract supplemental information relating to the attributes of one or more relationships from one or more image files associated with the functional architecture graph 214. Step 228 also includes supplementing information stored in at least one graph database (e.g., element and relationship information extracted from step 225) with the attribute information extracted in step 227. For example, node attributes may be supplemented according to positional relationship information.

[0032] Referring again to step 227, in one or more embodiments, at least a portion of the functional architecture graph 214 may be converted into at least one image file which can retain nodes and relationships. Additionally, such an embodiment may include analyzing the image content using OCR technology and analyzing embedded node information for attribute relationships that are not present from the analysis in step 225. Additionally, at least one embodiment may include generating a complete architecture graph based at least in part on the outputs of steps 226 and 228.

[0033] Figure 3 shows an exemplary workflow for aligning different entity descriptions as part of constructing a user story knowledge graph according to an exemplary embodiment of the present invention. For illustrative purposes, Figure 3 shows one or more elements 330, which are used to perform embedded searches in relation to one or more vector databases 331 using one or more embedded models, and to perform key searches using an analysis engine 333. In such an embodiment, the embedded search involves transforming text data into a high-density vector representation using a model such as a sentence transformer, thereby enabling semantic similarity measurements (e.g., cosine similarity) to efficiently retrieve contextually relevant elements from the user story knowledge graph. Additionally, in such an embodiment, the key search utilizes unique identifiers assigned to each graph element for direct lookups, thereby enabling efficient access to specific components and their attributes. With respect to architecture graphs, many architects use the same names for the same objects, and in such scenarios, key searches are effective. To avoid typographical errors and / or other corrections, one or more embodiments also include combining one or more embedded models to perform embedded searches.

[0034] Furthermore, as shown in Figure 3, step 332 includes retrieving search results from embedded search and key search. Step 334 then includes determining whether another identical entity exists. If so, step 335 includes combining and using the existing elements within the user story knowledge graph. Otherwise, step 336 then includes creating a new entity within the user story knowledge graph.

[0035] Figure 4 shows an exemplary workflow for generating a user story according to an exemplary embodiment of the present invention. For illustrative purposes, Figure 4 shows generating and / or modifying a prompt template 420 based on inputs including software relation requirements 408, at least one knowledge base from an architecture graph 440, at least one relational knowledge base 410, and user input 445. Within the prompt template 420, at least a portion of the aforementioned inputs is used to insert and / or modify instructions for creating a user story 441, a knowledge context 442, a few-shot user story example 443 (e.g., one further detailed in relation to Figure 5), and a JSON formatting instruction 444. Based at least in part on such content, a prompt is generated and output to an LLM 422, which processes the prompt and outputs a user story 412 in JSON format. LLM422 can also update and / or fine-tune the user story 412 based at least partially on feedback from the artificial intelligence agent 418, which can then base at least partially on its processing of user input 445.

[0036] Figure 5 shows exemplary pseudocode for generating a user story prompt template in an exemplary embodiment. In this embodiment, the exemplary pseudocode 500 is executed by or under the control of at least one processing system and / or device. For example, the exemplary pseudocode 500 may be considered to include a portion of at least a portion of the software implementation of the automated software function description generation system 105 in the embodiment of Figure 1.

[0037] Exemplary pseudocode 500 illustrates an exemplary user story prompt template generation sequence based on a specific architecture with concrete component and data flow details. Such exemplary user story prompt templates include and / or adhere to the following rules: each story should have a story title, category, description, business requirements, persona, acceptance criteria description, and acceptance criteria test; each story should be formatted as a JavaScript® object notation (JSON) document and have a different story title; each story category should meet user requirements with architectural considerations in mind. Accordingly, an exemplary output of such a user story prompt template is shown in exemplary pseudocode 500.

[0038] This specific example pseudocode shows only one exemplary implementation for generating a user story prompt template, and it should be understood that other or alternative content may be included, and alternative implementations that follow other or alternative rules may be used in other embodiments.

[0039] In relation to one or more embodiments and as used as further detailed herein, LLM represents a category of foundation models, which are a type of artificial intelligence system trained on a broad set of unlabeled data that can be used for different tasks with minimal fine-tuning. Unlabeled data may include images and / or language, in some cases. In response to prompts input to a foundation model, the system generates an output, such as an entire paper or a complex image, based on the parameters specified in the input prompt. A foundation model may produce an output that attempts to satisfy the parameters even if it was not trained on specific training data containing the exact parameters, for example, not trained to generate an image for its exact argument or in that manner.

[0040] Using self-supervised and transfer learning, foundation models can apply information they have learned about one situation to another. For example, just as a human learns how to drive a particular car, a human can learn how to drive other types of vehicles, such as other cars, trucks, or buses, with less effort. Foundation models are also used to achieve proficiency in some new areas without needing to be trained entirely from scratch. Foundation models appear to possess innate creativity when performing tasks such as putting together a coherent argument or creating a completely original work of art. Foundation models are well-established in the techniques of natural language processing. One example of how foundation models can be beneficial is that in previous generations of AI techniques, if you wanted to build an artificial intelligence model that could summarize a set of texts, tens of thousands of labeled examples were required just for the summarization use case. With a pre-trained foundation model, the labeling data requirement is dramatically reduced. First, a foundation model is fine-tuned on a domain-specific unlabeled corpus to create a domain-specific foundation model. Then, the foundation model is trained for summarization using a much smaller amount of labeled data (e.g., 1,000 labeled examples). Domain-specific foundation models can be used for many tasks, in contrast to previous techniques where a model had to be built from scratch for each use case. Foundation models can also be applied to areas such as code analysis, generation, and repair in computer programming.

[0041] Several foundation models are used for sentiment analysis. Pre-trained foundation models can be trained to perform sentiment analysis in new languages ​​using, for example, just a few thousand sentences (reducing the number of annotations required to about 1 / 100th of previous models). Reducing labeling requirements will make implementation into various technical fields much easier. Systems that perform specific tasks within a single domain are being replaced by broader AI that learns more generally and functions across domains and challenges. Foundation models, trained on large unlabeled datasets and fine-tuned for diverse applications, are driving this change.

[0042] As mentioned above, LLMs are a type of foundation model trained on vast amounts of data, enabling them to understand and generate natural language and other types of content to perform a wide range of tasks. LLMs have been implemented at different levels to enhance their natural language understanding (NLU) and natural language processing (NLP) capabilities. This progress in LLMs has occurred in parallel with advancements in machine learning, machine learning models, algorithms, neural networks, and transformer models that provide architecture for these artificial intelligence systems.

[0043] LLM can be implemented to drive multiple use cases and applications while solving numerous tasks. This LLM concept is in stark contrast to the idea of ​​individually building and training domain-specific models for each of these use cases, which is difficult to implement from many perspectives (e.g., cost and infrastructure), hinders synergy, and can even lead to performance degradation.

[0044] LLM represents a significant breakthrough in NLP and artificial intelligence. LLM is accessible through interfaces such as various GPT and / or BERT models. Therefore, LLM is designed to understand and generate text like a human, in addition to other forms of content, based on the vast amount of data used to train the model. LLM has the ability to infer from context, generate consistent, contextually valid responses, translate into various languages, summarize text, answer questions, assist with creative writing, and / or code generation tasks. LLM is capable of performing some or all of these tasks thanks to its numerous (e.g., billions) parameters, which allow the model to capture complex patterns in language and perform a wide range of linguistic relational tasks. LLM is revolutionizing applications in various fields, from chatbots and virtual assistants to content generation, research support, and language translation.

[0045] LLMs operate by leveraging deep learning techniques and vast amounts of text data. These models are typically based on transformer architectures, such as generative pre-trained transformers, which excel at handling sequential data like text input. LLMs can also include multi-layer neural networks, each with parameters that can be fine-tuned during training, further enhanced by layers known as attention mechanisms, which play a role in focusing on specific parts of the dataset.

[0046] During the training process, these models learn to predict the next word in a sentence based on the context provided by the preceding word. The model does this by assigning probability scores to repetitions of words that have been tokenized (i.e., divided into smaller strings). These tokens are then converted into embeddings, which are numerical representations of this context.

[0047] To ensure accuracy, this process involves training the LLM on a large text corpus (e.g., within billions of pages), allowing it to learn grammar, semantics, and conceptual relationships through zero-shot and self-supervised learning. Once trained on this training data, the LLM can autonomously predict the next word based on the input it receives and generate text by relying on the patterns and knowledge it has acquired. The result is consistent, contextually valid language generation that can be useful for a wide range of NLU and content generation tasks.

[0048] Model performance can also be improved through other tactics such as prompt engineering, prompt tuning, fine-tuning, and reinforcement learning with human feedback (RLHF), which can eliminate bias, directed language, and virtually false answers known as "hallucination," which are often undesirable byproducts of training on a considerable amount of unstructured data. LLM extends conversational artificial intelligence in chatbots and virtual assistants to enhance conversations that mimic interactions with human agents, providing context-aware responses.

[0049] LLM also excels at content generation, automating the creation of articles, explanatory materials, and other writing tasks. LLM helps summarize and extract information from datasets, thereby accelerating knowledge discovery. LLM also plays a crucial role in language translation, breaking down language barriers by providing accurate and contextually appropriate translations. LLM can even be used to write code or "translate" between programming languages. Furthermore, LLM contributes to accessibility by assisting individuals with disabilities, including text-to-speech applications and content generation in accessible formats. In addition, LLM can be used to perform sentiment analysis, which involves analyzing text to determine user tone in order to understand user feedback at scale and assist in one or more relational tasks (e.g., brand reputation management).

[0050] Figure 6 is a flowchart illustrating a technique according to one embodiment of the present invention. Step 602 includes identifying development relationship information in at least one functional architecture associated with a given item of software. In at least one embodiment, identifying development relationship information in at least one functional architecture associated with a given item of software includes analyzing information about one or more elements and one or more relationships in at least one functional architecture. Additionally or alternatively, identifying development relationship information in at least one functional architecture associated with a given item of software may include processing one or more extensible markup language files associated with at least one functional architecture, and / or processing one or more image features associated with at least one functional architecture.

[0051] Step 604 includes generating at least one knowledge graph representing at least a portion of the development-related information. In one or more embodiments, generating at least one knowledge graph includes aligning two or more different descriptions of at least a portion of the development-related information.

[0052] Step 606 includes generating at least one prompt based at least partially on one or more parts of at least one knowledge graph. In at least one embodiment, generating at least one prompt includes generating one or more software development relation requirements, one or more instructions for generating one or more software feature descriptions, and one or more formatting instructions based at least partially on one or more parts of at least one knowledge graph.

[0053] Step 608 includes generating one or more software feature descriptions for at least a portion of a given item of software by processing at least one prompt using at least one generative machine learning model (e.g., at least one LLM). In one or more embodiments, generating one or more software feature descriptions for at least a portion of a given item of software includes generating a first software feature description, processing feedback relating to the first software feature description from at least one artificial intelligence agent, and generating a second software feature description by modifying at least a portion of the first software feature description at least partially based on one or more portions of the feedback.

[0054] Step 610 includes performing one or more automated actions based at least in part on one or more software feature descriptions. In at least one embodiment, performing one or more automated actions includes automatically initiating one or more software development tasks for a given item of software based at least in part on one or more software feature descriptions. Additionally or alternatively, performing one or more automated actions may include automatically training at least a portion of at least one LLM using feedback related to one or more software feature descriptions. Also in at least one embodiment, performing one or more automated actions includes automatically transmitting one or more software feature descriptions to at least one software development relation system and one or more software development relation users.

[0055] It should be understood that some embodiments described herein utilize one or more artificial intelligence models. The term “model,” as used herein, is intended to be interpreted broadly and should be understood to include, for example, a set of executable instructions for generating a computer implementation software description for one or more software development implementations. In addition, such a software description may be used to initiate one or more automated actions (e.g., automatically starting one or more software development tasks, automatically retraining the LLM that generated the software description, automatically sending the software description to one or more systems and / or users).

[0056] The technique shown in Figure 6 may also include providing a system, as described herein, which includes separate software modules, each of which is embodied on a tangible computer-readable recordable storage medium. All modules (or any subset thereof) may reside on the same medium, or, for example, each may reside on a different medium. The modules may include any or all of the components shown in the figure and / or described herein. In one embodiment of the present invention, the modules may run, for example, on a hardware processor. The method step may then be carried out using separate software modules of the system running on the hardware processor, as described above. Furthermore, the computer program product may include a tangible computer-readable recordable storage medium having code adapted to be executed to carry out at least one method step described herein, which includes providing a system having separate software modules.

[0057] Additionally, the technique shown in Figure 6 may be implemented via a computer program product that may include computer-readable program code stored on a computer-readable storage medium within the data processing system, which is downloaded from a remote data processing system via a network. Furthermore, in one embodiment of the present invention, the computer program product may include computer-readable program code stored on a computer-readable storage medium within the server data processing system, which is downloaded to a remote data processing system via a network for use on the computer-readable storage medium together with the remote system.

[0058] One embodiment of the present invention or an element thereof may be implemented in the form of a device comprising memory and at least one processor coupled to the memory, and may be configured to perform exemplary method steps.

[0059] Various aspects of this disclosure are illustrated by narrative text, flowcharts, block diagrams of computer systems, and / or block diagrams of mechanical logic included in embodiments of computer program products (CPPs). With respect to any flowchart, depending on the technology involved, operations may be performed in a different order than those shown in a given flowchart. For example, again, depending on the technology involved, two operations shown in consecutive blocks of a flowchart may be performed in reverse order, as a single integrated stage, simultaneously, or in a manner that at least partially overlaps in time.

[0060] Embodiments of a computer program product ("CPP Embodiment" or "CPP") are terms used in this disclosure to describe any set of one or more storage media (also called "Multiple Media") that collectively comprise a set of one or more storage devices containing machine-readable code corresponding to instructions and / or data for performing computer operations specified in a given CPP claim. A "Storage Device" is any tangible device capable of holding and storing instructions for use by a computer processor. Without limitation, computer-readable storage media may be electronic storage media, magnetic storage media, optical storage media, electromagnetic storage media, semiconductor storage media, mechanical storage media, or any preferred combination thereof. Some known types of storage devices that include these media include: diskettes, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), static random access memory (SRAM), compact disk read-only memory (CD-ROM), digital versatile disk (DVD), memory stick, floppy disk, mechanically encoded devices (such as punch cards or pits / lands formed on the main surface of a disk), or any suitable combination of the foregoing. When the term "computer-readable storage medium" is used in this disclosure, it shall not be construed as storage in the form of temporary signals themselves, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through waveguides, light pulses passing through optical fiber cables, electrical signals transmitted through wires, and / or other transmission media. As those skilled in the art will understand, data is moved at several intermittent points in the normal operation of a storage device, typically during access, defragmentation, or garbage collection; however, data is not temporary while it is stored, and therefore a storage device is not considered temporary.

[0061] The computing environment 700 includes an example of an environment for at least some of the computer code involved in performing the method of the present invention, for example, LLM-based software description generation code 726. In addition to the LLM-based software description generation code 726, the computing environment 700 includes, for example, a computer 701, a wide area network (WAN) 702, an end user device (EUD) 703, a remote server 704, a public cloud 705, and a private cloud 706. In this embodiment, the computer 701 includes a processor set 710 (including a processing circuit configuration 720 and a cache 721), a communication fabric 711, volatile memory 712, persistent storage 713 (including an operating system 722 and the LLM-based software description generation code 726 shown above), a peripheral device set 714 (including a user interface (UI) device set 723, storage 724, and an Internet of Things (IoT) sensor set 725), and a network module 715. The remote server 704 includes the remote database 730. The public cloud 705 includes the gateway 740, the cloud orchestration module 741, the host physical machine set 742, the virtual machine set 743, and the container set 744.

[0062] Computer 701 may take the form of a desktop computer, laptop computer, tablet computer, smartphone, smartwatch or other wearable computer, mainframe computer, quantum computer, or any other form of computer or mobile device currently known or to be developed in the future, capable of running programs, accessing networks, or querying databases such as the remote database 730. As is well understood in the field of computer technology, and depending on the technology, the execution of a computer implementation method may be distributed among multiple computers and / or multiple locations. On the other hand, in this presentation of the computing environment 700, the detailed discussion focuses on a single computer, specifically computer 701, in order to keep the presentation as simple as possible. Computer 701 may be located in the cloud, although it is not shown in the cloud in Figure 7. On the other hand, computer 701 is not required to be in the cloud, except in any extent that may be actively shown.

[0063] The processor set 710 includes one or more computer processors of any type currently known or to be developed in the future. The processing circuit configuration 720 may be distributed across multiple packages, e.g., multiple cooperative integrated circuit chips. The processing circuit configuration 720 may implement multiple processor threads and / or multiple processor cores. The cache 721 is located in the processor chip package and is memory used for data or code that should be available for rapid access by threads or cores running on the processor set 710. The cache memory is typically organized into multiple levels depending on its relative proximity to the processing circuit configuration. Alternatively, some or all of the cache for the processor set may be located "off-chip". In some computing environments, the processor set 710 may function with qubits and be designed to perform quantum computing.

[0064] Computer-readable program instructions are typically loaded into computer 701, causing the processor set 710 of computer 701 to execute a series of operational steps, thereby executing the computer implementation method, the instructions thus executed instantiating the method specified in the flowchart and / or narrative description of the computer implementation method contained herein (collectively referred to as the “Method of the Invention”). These computer-readable program instructions are stored in various types of computer-readable storage media, such as the cache 721 and other storage media discussed below. The program instructions and associated data are accessed by the processor set 710 to control and direct the execution of the Method of the Invention. In the computing environment 700, at least some of the instructions for executing the Method of the Invention may be stored in LLM-based software description generation code 726 in persistent storage 713.

[0065] The communication fabric 711 is a signal conduction path that enables various components of the computer 701 to communicate with one another. Typically, this fabric consists of switches and conductive paths, such as buses, bridges, physical input / output ports, and similar components. Other types of signal communication paths may be used, such as fiber optic communication paths and / or wireless communication paths.

[0066] Volatile memory 712 is any type of volatile memory currently known or to be developed in the future. Examples include dynamic RAM or static RAM. Typically, volatile memory 712 features random access, but this is not required unless explicitly stated. In computer 701, volatile memory 712 is located in a single package and is internal to computer 701, but alternatively or additionally, volatile memory may be distributed across multiple packages and / or located externally to computer 701.

[0067] The persistent storage 713 is any form of non-volatile storage for a computer, currently known or to be developed in the future. The non-volatility of this storage means that the stored data is maintained regardless of whether power is supplied to the computer 701 and / or directly to the persistent storage 713. The persistent storage 713 may be ROM, but typically at least a portion of the persistent storage allows for data writing, data erasure, and data rewriting. Some well-known forms of persistent storage include magnetic disks and solid-state storage devices. The operating system 722 may take several forms, such as various known proprietary operating systems or open-source Portable Operating System Interface (CSI) type operating systems using a kernel. The code contained in the LLM-based software description generation code 726 typically includes at least a portion of computer code involved in performing the method of the present invention.

[0068] The peripheral device set 714 includes a set of peripheral devices for the computer 701. Data communication connections between the computer 701's peripheral devices and other components may be implemented in various ways, such as Bluetooth® connections, Near-Field Communication (NFC) connections, connections made by cables (such as universal serial bus (USB) type cables), insert-type connections (e.g., secure digital (SD) cards), connections made via local area communication networks, and even connections made via wide area networks such as the Internet. In various embodiments, the UI device set 723 may include components such as a display screen, speakers, microphones, wearable devices (such as goggles and smartwatches), keyboards, mice, printers, touchpads, game controllers, and haptic devices. Storage 724 is external storage such as an external hard drive, or insertable storage such as an SD card. Storage 724 may be persistent and / or volatile. In some embodiments, storage 724 may take the form of a quantum computing memory device that stores data in the form of qubits. In embodiments where computer 701 is required to have a large amount of storage (for example, computer 701 locally stores and manages a large database), this storage may be provided by peripheral storage devices designed to store very large amounts of data, such as a storage area network (SAN) shared by multiple geographically distributed computers. The IoT sensor set 725 consists of sensors that can be used in Internet of Things applications. For example, one sensor may be a thermometer, and another sensor may be a motion detector.

[0069] The network module 715 is a collection of computer software, hardware, and firmware that enables computer 701 to communicate with other computers via the WAN 702. The network module 715 may include hardware such as a modem or Wi-Fi® signal transceiver, software for packetizing and / or depackaging data for transmission over a communication network, and / or web browser software for communicating data over the internet. In some embodiments, the network control and network forwarding functions of the network module 715 are performed on the same physical hardware device. In other embodiments (e.g., embodiments utilizing software-defined networking (SDN)), the control and forwarding functions of the network module 715 are performed on physically separate devices, such that the control function manages several different network hardware devices. Computer-readable program instructions for performing the methods of the present invention can typically be downloaded from an external computer or external storage device to computer 701 through a network adapter card or network interface included in the network module 715.

[0070] WAN702 is any wide area network (e.g., the Internet) that can transmit computer data over non-local distances using any currently known or future-developed technology for transmitting computer data. In some embodiments, WAN702 may be replaced and / or complemented by a local area network (LAN), such as a Wi-Fi network, designed to transmit data between devices located in a local area. WANs and / or LANs typically include computer hardware such as copper transmission cables, optical transmission fibers, wireless transmissions, routers, firewalls, switches, gateway computers, and edge servers.

[0071] The end-user device 703 is any computer system used and controlled by an end-user (e.g., a customer of the company operating computer 701), and may take any of the forms discussed above in relation to computer 701. Typically, EUD703 receives useful and valuable data from the operation of computer 701. For example, in a hypothetical case where computer 701 is designed to provide recommendations to the end-user, these recommendations would typically be communicated from the computer 701's network module 715 to EUD703 via WAN702. In this way, EUD703 can display or otherwise present the recommendations to the end-user. In some embodiments, EUD703 may be a client device such as a thin client, heavy client, mainframe computer, and desktop computer.

[0072] The remote server 704 is any computer system that provides at least some data and / or functions to computer 701. The remote server 704 may be controlled and used by the same entity that operates computer 701. The remote server 704 represents a machine that collects and stores useful and beneficial data for use by other computers, such as computer 701. For example, in a hypothetical case where computer 701 is designed and programmed to provide recommendations based on historical data, this historical data may be provided to computer 701 from a remote database 730 of the remote server 704.

[0073] Public Cloud 705 is any computer system available for use by multiple entities, providing on-demand availability of computer system resources and / or other computer functions, particularly data storage (cloud storage) and computing power, without direct active management by the user. Cloud computing typically leverages resource sharing to achieve consistency and economies of scale. Direct and active management of the computing resources of Public Cloud 705 is performed by the computer hardware and / or software of the Cloud Orchestration Module 741. The computing resources provided by Public Cloud 705 are typically implemented by virtual computing environments running on various computers that make up the computers of the host physical machine set 742, which is the universe of physical computers in Public Cloud 705 and / or available to it. Virtual computing environments (VCEs) typically take the form of virtual machines from the virtual machine set 743 and / or containers from the container set 744. It is understood that these VCEs may be stored as images and can be transferred either as images or after instantiation of the VCEs, among and between hosts of various physical machines. The cloud orchestration module 741 manages image transfer and storage, deploys new VCE instances, and manages active instanceization of VCE deployments. The gateway 740 is a collection of computer software, hardware, and firmware that enables the public cloud 705 to communicate through the WAN 702.

[0074] Some further explanations of VCE are provided below. A VCE can be stored as an "image". A new active instance of a VCE can be instantiated from an image. Two well-known types of VCE are virtual machines and containers. A container is a VCE that uses operating system-level virtualization. This refers to an operating system feature in which the kernel allows for the existence of multiple isolated user-space instances called containers. These isolated user-space instances typically behave like actual computers in terms of the programs running within them. Computer programs running on a normal operating system can utilize all the resources of that computer, including connected devices, files and folders, network shares, CPU power, and quantifiable hardware capabilities. However, programs running inside a container can only use the contents of the container and the devices allocated to the container; this feature is known as containerization.

[0075] Private Cloud 706 is similar to Public Cloud 705, except that its computing resources are available for use by a single enterprise only. While Private Cloud 706 is shown communicating with WAN 702, in other embodiments, the private cloud may be completely isolated from the internet and accessible only through a local / private network. A hybrid cloud is a combination of multiple clouds of different types (e.g., private, community, or public cloud types), often implemented by different vendors. Each of the multiple clouds remains a separate, discrete entity, but the larger hybrid cloud architecture is bound together by standardized or proprietary technologies that enable orchestration, management, and / or data / application portability between the multiple configuration clouds. In this embodiment, both Public Cloud 705 and Private Cloud 706 are part of a larger hybrid cloud.

[0076] In computing environment 700, computer 701 is shown as being connected to the Internet (see WAN 702). However, in many embodiments of the present invention, computer 701 is isolated from communications over a communication network and is not connected to the Internet, thereby operating as a standalone computer. In these embodiments, the network module 715 of computer 701 may not be necessary, or even undesirable, to ensure isolation and prevent external communications from entering computer 701. Standalone computer embodiments may be advantageous because they are typically more secure in at least some applications of the present invention. In other embodiments, computer 701 is connected to a secure WAN or secure LAN instead of WAN 702 and / or the Internet. In these networked (i.e., non-standalone) embodiments, system designers may want to implement appropriate security measures, currently known or to be developed in the future, to reduce the risk that incoming network communications may cause a security breach.

[0077] The technical terms used herein are solely for the purpose of describing specific embodiments and are not intended to limit the invention. Where used herein, singular “a,” “an,” and “the” are intended to include plural forms unless the context otherwise explicitly indicates. Where used herein, the terms “comprises” and / or “comprising” specify the presence of a defined function, stage, operation, element, and / or component, but do not preclude the presence or addition of other functions, stages, operations, elements, components, and / or groups thereof.

[0078] The descriptions of various embodiments of the present invention have been presented for illustrative purposes only and are not intended to be exhaustive or to limit the disclosed embodiments. Many modifications and variations will be apparent to those skilled in the art without departing from the scope and spirit of the described embodiments. The terminology used herein has been selected to best describe the principles of the embodiments, their practical applications, or technical improvements to the art found in the market, or to enable other persons skilled in the art to understand the embodiments disclosed herein.

Claims

1. A step of identifying development-related information within at least one functional architecture associated with a given item of software; A step of generating at least one knowledge graph representing at least a portion of the aforementioned development-related information; A step of generating at least one prompt based at least partially on one or more parts of the aforementioned at least one knowledge graph; A step of generating one or more software feature descriptions for at least a portion of the given item of the software by processing the at least one prompt using at least one generative machine learning model; and A step of performing one or more automated actions based at least partially on one or more of the aforementioned software function descriptions. A computer implementation method comprising the above.

2. The computer implementation method according to claim 1, wherein the step of identifying development relationship information in at least one functional architecture associated with a given item of software comprises the step of analyzing information relating to one or more elements and one or more relationships in the at least one functional architecture.

3. The computer implementation method according to claim 1, wherein the step of identifying development-related information in at least one functional architecture associated with a given item of software comprises the step of processing one or more extensible markup language files associated with the at least one functional architecture.

4. The computer implementation method according to claim 1, wherein the step of identifying development relation information in at least one functional architecture associated with a given item of software comprises the step of processing one or more image features associated with the at least one functional architecture.

5. The computer implementation method according to any one of claims 1 to 4, wherein the step of performing one or more automated actions includes a step of automatically initiating one or more software development tasks for the given item of software, at least in part, based on the one or more software function descriptions.

6. The computer implementation method according to any one of claims 1 to 4, wherein the step of generating at least one knowledge graph comprises the step of aligning two or more different descriptions of at least a portion of the development-related information.

7. The computer implementation method according to any one of claims 1 to 4, wherein the step of generating at least one prompt comprises the steps of generating one or more software development relation requirements, one or more instructions for generating one or more software function descriptions, and one or more formatting instructions, at least partially based on one or more portions of the at least one knowledge graph.

8. The computer implementation method according to any one of claims 1 to 4, wherein the step of generating one or more software function descriptions for at least a portion of a given item of software comprises: a step of generating a first software function description; a step of processing feedback from at least one artificial intelligence agent relating to the first software function description; and a step of generating a second software function description by modifying at least a portion of the first software function description at least partially based on one or more portions of the feedback.

9. The computer implementation method according to any one of claims 1 to 4, wherein the step of performing one or more automated actions comprises the step of automatically training at least a portion of the at least one generative machine learning model using feedback relating to the one or more software function descriptions.

10. The computer implementation method according to any one of claims 1 to 4, wherein the step of performing one or more automated actions includes the step of automatically transmitting the one or more software function descriptions to at least one software development related system and one or more software development related users.

11. To the computer: A procedure for identifying development-related information within at least one functional architecture associated with a given item of software; A procedure for generating at least one knowledge graph representing at least a portion of the aforementioned development-related information; A procedure for generating at least one prompt based at least partially on one or more parts of the aforementioned at least one knowledge graph; A procedure for generating one or more software feature descriptions for at least a portion of the given item of the software by processing the at least one prompt using at least one generative machine learning model; and A procedure to perform one or more automated actions based at least in part on one or more of the aforementioned software function descriptions. A computer program designed to execute something.

12. The computer program according to claim 11, wherein the procedure for identifying development relationship information in at least one functional architecture associated with a given item of software comprises a procedure for analyzing information about one or more elements and one or more relationships in the at least one functional architecture.

13. The computer program according to claim 11, wherein the step of identifying development-related information in at least one functional architecture associated with a given item of software comprises the step of processing one or more extensible markup language files associated with the at least one functional architecture.

14. The computer program according to claim 11, wherein the step of identifying development relation information in at least one functional architecture associated with a given item of software comprises a step of processing one or more image features associated with the at least one functional architecture.

15. A computer program according to any one of claims 11 to 14, wherein the procedure for performing one or more automated actions includes a procedure for automatically initiating one or more software development tasks for the given item of software, at least in part, based on the one or more software function descriptions.

16. Processor set; One or more computer-readable storage media; and Program instructions stored in one or more computer-readable storage media The program instructions are: A procedure for identifying development-related information within at least one functional architecture associated with a given item of software; A procedure for generating at least one knowledge graph representing at least a portion of the aforementioned development-related information; A procedure for generating at least one prompt based at least partially on one or more parts of the aforementioned at least one knowledge graph; A procedure for generating one or more software feature descriptions for at least a portion of the given item of the software by processing the at least one prompt using at least one generative machine learning model; and A procedure to perform one or more automated actions based at least in part on one or more of the aforementioned software function descriptions. A computer system that causes the processor set to perform an operation having the following characteristics.

17. The computer system according to claim 16, wherein the procedure for identifying development relationship information in at least one functional architecture associated with a given item of software comprises a procedure for analyzing information about one or more elements and one or more relationships in the at least one functional architecture.

18. The computer system according to claim 16, wherein the procedure for identifying development-related information in at least one functional architecture associated with a given item of software comprises the procedure for processing one or more extensible markup language files associated with the at least one functional architecture.

19. The computer system according to claim 16, wherein the procedure for identifying development relation information in at least one functional architecture associated with a given item of software comprises a procedure for processing one or more image features associated with the at least one functional architecture.

20. A computer system according to any one of claims 16 to 19, wherein a procedure for performing one or more automated actions includes a procedure for automatically initiating one or more software development tasks for a given item of software, at least in part, based on the one or more software function descriptions.

Images