DETAILED ACTION
The Office Action is in response to claims filed
Claims 1-20 are pending.
Notice of Pre-AIA or AIA Status
The present application, filed on or after March 16, 2013, is being examined under the first inventor to file provisions of the AIA .
Claim Rejections - 35 USC § 103
In the event the determination of the status of the application as subject to AIA 35 U.S.C. 102 and 103 (or as subject to pre-AIA 35 U.S.C. 102 and 103) is incorrect, any correction of the statutory basis (i.e., changing from AIA to pre-AIA ) for the rejection will not be considered a new ground of rejection if the prior art relied upon, and the rationale supporting the rejection, would be the same under either status.
The following is a quotation of 35 U.S.C. 103 which forms the basis for all obviousness rejections set forth in this Office action:
A patent for a claimed invention may not be obtained, notwithstanding that the claimed invention is not identically disclosed as set forth in section 102, if the differences between the claimed invention and the prior art are such that the claimed invention as a whole would have been obvious before the effective filing date of the claimed invention to a person having ordinary skill in the art to which the claimed invention pertains. Patentability shall not be negated by the manner in which the invention was made.
The factual inquiries for establishing a background for determining obviousness under 35 U.S.C. 103 are summarized as follows:
1. Determining the scope and contents of the prior art.
2. Ascertaining the differences between the prior art and the claims at issue.
3. Resolving the level of ordinary skill in the pertinent art.
4. Considering objective evidence present in the application indicating obviousness or nonobviousness.
Claims 1, 3, 8, 10, 15, and 17 are rejected under 35 U.S.C. 103 as being unpatentable over US 11809841 B1 hereinafter “Zhang” in view of US 20250190868 A1 hereinafter “Heinonen”.
With regards to claim 1, Zhang teaches
A non-transitory, computer-readable storage medium comprising instructions recorded thereon, (Zhang Column 26 Lines 38-50, “System memory 1020 may store instructions and data accessible by processor(s) 1010. In various embodiments, system memory 1020 may be implemented using any suitable memory technology, such as random-access memory (RAM), static RAM (SRAM), synchronous dynamic RAM (SDRAM), nonvolatile/Flash-type memory, or any other type of memory. In the illustrated embodiment, program instructions and data implementing one or more desired functions, such as those methods, techniques, and data described above are shown stored within system memory 1020 as service code 1025 (e.g., executable to implement, in whole or in part, the modernization services 102) and data 1026.”) wherein the instructions, when executed by at least one processor of a system, cause the system to: (Zhang Column 26 Lines 26-37, “In various embodiments, computer system 1000 may be a uniprocessor system including one processor 1010, or a multiprocessor system including several processors 1010 (e.g., two, four, eight, or another suitable number). Processors 1010 may be any suitable processors capable of executing instructions.”)
retrieve, from a first database, a code sample (Zhang Column 6 Lines 53-64, “The discovery services 122, for example, include various services, applications, software agents, and other tools (e.g., including downloadable modernization agents 130) used to identify software applications in users' computing environments, to collect profile information for identified software applications, and to perform other analysis and modernization processes. The assessment services 124 enable users and applications to obtain various types of software modernization assessments and recommendations based on obtained application artifacts (e.g., source code, bytecode, intermediate language files, etc.) collected for users' applications identified by the discovery services 122 and associated tools.”) and a data map, wherein the data map includes indications of relationships between transformed and untransformed data within a data pipeline associated with a data transformation environment (Zhang Column 7 Lines 13-28, “in some embodiments, a modernization agent 130 includes one or more application analyzers 110 configured to statically and dynamically analyze application artifacts (e.g., application artifacts 114 including source code 116, bytecode, intermediate code files, or combinations thereof) obtained for software applications undergoing analysis (e.g., any of software applications 134A-134Z running on servers 136A-136N or computing devices 138). In some embodiments, based on the performed application analyses, an application analyzer 110 generates application analysis results 140 including, e.g., graph-based models of dependency relationships among application components, information identifying detected anti-patterns, estimated refactoring costs, modernization tool recommendations, and the like.”); [Examiner’s Note: One of ordinary skill in the art would understand that a software application is a system that can transform data inputs (untransformed data) for generating corresponding outputs (transformed data).]
provide the code sample (Zhang Column 9 Lines 35-44, “In some embodiments, the application analysis results 140 include various modernization recommendations and other information obtained about one or more of the software applications analyzed by the agent 130. For example, the application modernization assessment report may include information from the obtained application artifacts 114 and other profile data, information about identified anti-patterns or other modernization-related issues, information about recommendation modernization strategies and modernization tools that can be used, and the like.”) to a code validation model to generate a code validation report, wherein the code validation report indicates a textual summary of a validation status of the code sample, wherein the textual summary includes instructions for modifying the code sample to be consistent with the data map; (Zhang Columns 9-10 Lines 66-67 and 1-32, “FIG. 2 illustrates an example graphical interface displaying an assessment report including interface elements that can be selected to initiate automated refactoring processes to mitigate identified anti-patterns and other software modernization-related issues according to some embodiments. As shown, the application report interface 200 includes a modernization report 202 displaying information about an analyzed application, e.g., by one or more application analyzers 110 of a modernization agent 130. In the example FIG. 2, the modernization report 202 includes application profile information (e.g., an application name, a location of source code associated with the application, an indication of when the application was last analyzed, etc.). The example modernization report 202 further includes a list of identified design and cloud anti-patterns, where each item indicates a type of anti-pattern and a location in the source code where the anti-pattern was identified [wherein the code validation report indicates a textual summary of a validation status of the code sample]. In some embodiments, an application report interface 200 includes refactor buttons 204 that can be selected by a user to initiate the automatic refactoring of the associated anti-patterns. For example, selection of the refactor button 204 associated with the “local filesystem access” may invoke a refactoring engine 128 to perform refactoring actions based on information contained in a refactoring template or in other input [wherein the textual summary includes instructions for modifying the code sample to be consistent with the data map]. In other embodiments, users can initiate the automatic refactoring of source code to address identified anti-patterns using other interfaces such as a CLI, API, an integrated development environment (IDE) interface, etc. In yet other embodiments, users can elect to manually modify source code to address one or more identified anti-patterns, where a modernization plug-in or other tool can be used to provide refactoring recommendations based on ML refactoring models, as described in more detail hereinafter [to a code validation model to generate a code validation report].”) [Examiner’s Note: other input can include the described analysis to determine the optimal relationship between software pipeline components which also dictate the contents of a refactoring template.]
provide the code sample and the textual summary of the validation status (Zhang Column 10 Lines 36-48, “As indicated above, the refactoring of a software application to address one or more identified anti-patterns or other modernization-related issues may be initiated by a user responsive to viewing application analysis results 140 or other information or, in some embodiments, automatically based on identified anti-patterns or other modernization-related issues. In some embodiments, the refactoring engine 128 performs the refactoring based at least in part on one or more refactoring template(s) 112 (e.g., including a structured or semi-structured data representation of refactoring rules, logic expressed in an augmented programming language or standard programming language, etc.), ML model(s) 146, or other input data.”) to a code generation model to update the code sample based on the instructions for modifying the code sample; (Zhang Column 12 Lines 33-48, “In some embodiments, the refactoring templates 112 can include augmented programming logic expressed in an augmented programming language. Augmented programming is an approach that allows software developers to write declarative business logic that can be translated by a tool (e.g., a refactoring engine 128) into programming code. The declarative abstracted logic is typically written in a domain specific language. The abstracted logic layer increasingly incorporates machine learning (ML) to drive algorithmic source code generation. In some embodiments, the refactoring templates 112 can include logic expressed in a declarative domain specific language to describe actions to be performed for each design or cloud anti-patterns. For example, users may also be able to specify custom refactoring actions, e.g., defined using custom source code, augmented programming language code, or the like [provide the code sample…to a code generation model to update the code sample based on the instructions for modifying the code sample].”) [Examiner’s Note: Analysis results display a summary of modernization anti-patterns thereby indicating a validation status and mapped to a refactoring rule/template as input into the model. Custom refactoring actions including source code can be input into the model for code refactoring as well.]
Zhang does not teach: provide the updated code sample to the data transformation environment to generate an output associated with the updated code sample;
provide the output to an output validation model to generate an output validation status associated with the output; and
provide the output validation status and the updated code sample to the code validation model to train the code generation model to generate code validation reports based on input code samples.
However, in an analogous art Heinonen teaches provide the updated code sample to the data transformation environment to generate an output associated with the updated code sample;
provide the output to an output validation model to generate an output validation status associated with the output; (Heinonen [0038-39], “Using a first AI model, configured to process at least one of the one or more input data sets in combination with the one or more instructions, to generate first output data refers to employing an artificial intelligence model specifically designed to handle and analyze relevant input data along with provided operational instructions. [provide the output] … Applying a machine learning model to the first output data to calculate the one or more performance metrics configured to assess the one or more aspects of interest related to the optimization refers to the use of a trained machine learning model to analyze and evaluate the initial outputs generated by the first AI model. The machine learning model is trained to take the first output data as input, which may include processed results such as predictions, recommendations, or other generated information. It calculates performance metrics, which are measurable indicators designed to evaluate key aspects such as accuracy, efficiency, or relevance of the first output data. These metrics are configured to quantify the aspects of interest related to the optimization goal, such as achieving higher customer engagement, improving decision accuracy, or maximizing revenue [to an output validation model to generate an output validation status associated with the output]. This ensures that the optimization process is guided and refined based on objective, quantifiable evaluations of the system's performance.”) and
provide the output validation status and the updated code sample to the code validation model to train the code generation model to generate code validation reports based on input code samples (Heinonen [0101], “The method may further comprise conditioning at least one of the first AI model or the second AI model based on at least one of: the one or more performance metrics, at least one of the one or more input data sets, or at least one of the first output data or the second output data. Conditioning on performance metrics allows the AI models to dynamically adapt based on feedback about their prior outputs' effectiveness. For example, if the performance metric reflects a poor result, the model can adjust its behavior or parameters to improve outcomes. By incorporating input data and performance metrics, the AI models can fine-tune their operations to better align with the optimization goal, improving the accuracy and relevance of their predictions. By conditioning on input data, the AI models can become context-aware, tailoring their outputs to the specific characteristics of the provided data. For example, in customer engagement, the AI models can generate messages that are more personalized based on user preferences or historical data. Conditioning on output data enables the creation of a feedback loop where the model learns from its past decisions, progressively refining its output for future iterations.”). [Examiner’s Note: An input data set can comprise/include updated code and validation text for context aware fine-tuning/training.]
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to have incorporated the teachings of Heinonen into the teachings of Zhang. This combination of teachings would have resulted in a system capable of analyzing a code sample to generate refactored code using a machine learning model, as in Zhang, with a trained AI model that can generate outputs that are used for iterative verification and fine-tuning, as in Heinonen. One of ordinary skill in the art would have been motivated to combine these teachings for the purpose of optimizing goals using AI models and machine learning techniques to iteratively refine processes, improve alignment with predefined criteria for success, and enable dynamically improved outcomes over multiple iterations (Heinonen [0031]).
With regards to claim 3, the rejection of claim 1 is incorporated.
Zhang further teaches wherein the instructions for generating the code validation report cause the system to:
provide the code sample to the code validation model (Zhang Columns 12-13 Lines 66-67 and 1-13, “In some embodiments, historical anti-pattern refactoring information similarly can be used to obtain a code snippet associated with an anti-pattern, translate the code snippet into an AST or graph model representation, obtain a set of syntactic vectors based on the AST or graph model with attention weights, and finally obtain a single vector or embedding representing the anti-pattern code snippet. This vector representation of the code snippet can be used as an anti-pattern embedding for training a deep learning model to recognize anti-patterns or refactoring recommendations when provided with embeddings new code snippets. The trained model can then be used for automatically identifying anti-pattern refactoring methods, where the model can recommend operations to mitigate particular types of identified anti-patterns.”) to generate the textual summary, wherein the textual summary includes an indication of a deficiency in the code sample; (Zhang Column 21 Lines 30-37, “In some embodiments, the operations further include causing display of a graphical interface including a modernization report including an indication of the anti-pattern, wherein the indication of the anti-pattern is associated with an interface element that can be selected to request refactoring of the source code to mitigate the anti-pattern; and receiving input requesting to refactor the source code to mitigate the anti-pattern via the interface element.”) and
generating the code validation report including the indication of the deficiency in the code sample. (Zhang Column 10 Lines 5-20, “As shown, the application report interface 200 includes a modernization report 202 displaying information about an analyzed application, e.g., by one or more application analyzers 110 of a modernization agent 130. In the example FIG. 2, the modernization report 202 includes application profile information (e.g., an application name, a location of source code associated with the application, an indication of when the application was last analyzed, etc.). The example modernization report 202 further includes a list of identified design and cloud anti-patterns, where each item indicates a type of anti-pattern and a location in the source code where the anti-pattern was identified [generating the code validation report including the indication of the deficiency in the code sample]. In some embodiments, an application report interface 200 includes refactor buttons 204 that can be selected by a user to initiate the automatic refactoring of the associated anti-patterns.”)
Claims 8 and 10 are directed to a system corresponding to the non-transitory, computer-readable medium limitations as disclosed in claims 1 and 3. Thus, claims 8 and 10 are rejected for the same reasons set forth in claims 1 and 3.
Claims 15 and 17 are directed to a method corresponding to the non-transitory computer-readable medium limitations as disclosed in claims 1 and 3. Thus, claim 15 and 17 are rejected for the same reasons set forth in claims 1 and 3.
Claims 2, 9, and 16 are rejected under 35 U.S.C. 103 as being unpatentable over Zhang in view of Heinonen as applied to claims 1, 8, and 15 above, and further in view of US 20140310233 A1 hereinafter "Catalano".
With regards to claim 2, the rejection of claim 1 is incorporated.
The combination of Zhang and Heinonen does not teach: wherein the instructions for retrieving the data map cause the system to: retrieve, from a database associated with the data transformation environment, a set of criteria, wherein each criterion of the set of criteria indicates a first target relationship between a first value associated with a first field of the transformed data and a second value associated with a second field of the untransformed data; and
generate the data map including a representation of the first target relationship.
However, in an analogous art Catalano teaches wherein the instructions for retrieving the data map cause the system to: retrieve, from a database associated with the data transformation environment, a set of criteria, wherein each criterion of the set of criteria indicates a first target relationship between a first value associated with a first field of the transformed data and a second value associated with a second field of the untransformed data; (Catalano [0026-27], “In one embodiment, the tracer added to a record 210 is in the form of a tracer code. This tracer code corresponds to a transformation rule that has been used to process the data record 210. The tracers added to data record 210 are examined by validation process 109 to confirm that the transformation process is proceeding, or has been completed, correctly (e.g., as determined by comparison to predefined standards or other performance criteria). FIG. 3 shows an exemplary set of transformation rules 300 used in the transformation process described above, according to one embodiment. Transformation rules 300 may generally include business, field-mapping, data quality, and record filtration rules 302. Each of these rules 302 is given an identification such as "Rule A", "Rule B", etc. as indicated in list 304. In one embodiment, the identification used for each rule (e.g., Rule A) corresponds to the tracer code (e.g., "A") added to data record 210 as described above.”) [Examiner’s Note: The transformation rules indicates a transformation process that can map between any inputs and outputs in a transformation.] and
generate the data map including a representation of the first target relationship.(Catalano [0033-34], “ In one embodiment, a method includes: receiving a plurality of data records; processing, by at least one processor (e.g., a computing device executing transformation engine 111), the data records using a plurality of transformation rules, wherein each of the transformation rules corresponds to a respective one of a plurality of tracers; and adding the tracers to the data records as needed to indicate those of the transformation rules used to process each data record. After processing the data records using the transformation rules, the data records are provided to a target system, and validation is done (e.g., using validation process 109), using the tracers added to the data records, to confirm that the processing has been, or is being, properly performed … The plurality of data records includes a first data record (e.g., data record 210), the plurality of transformation rules (e.g., transformation rules 300) includes a first rule (e.g., Rule A), and a first tracer (e.g., "A") is added to the first data record after processing with the first rule.”)
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to have incorporated the teachings of Catalano into the teachings of Zhang in view of Heinonen. This combination of teachings would have resulted in a system capable of analyzing a code sample to generate refactored code using a machine learning model, as in Zhang, with a trained AI model that can generate outputs that are used for iterative verification and fine-tuning, as in Heinonen, and generating a data map to represent the relationships/rules between data transformations of a data record, as in Catalano. One of ordinary skill in the art would have been motivated to combine these teachings for the purpose of implementing a transformation engine that can define required features and further rules for confirmation (Catalano [0020-21]).
Claim 9 directed to a system corresponding to the non-transitory, computer-readable medium limitations as disclosed in claim 2. Thus, claim 9 is rejected for the same reasons set forth in claim 2.
Claim 16 is directed to a method corresponding to the non-transitory computer-readable medium limitations as disclosed in claim 2. Thus, claim 16 is rejected for the same reasons set forth in claim 2.
Claims 4, 11, and 18 are rejected under 35 U.S.C. 103 as being unpatentable over Zhang in view of Heinonen as applied to claims 3, 10, and 17 above, and further in view of US 12323449 B1 hereinafter "Graves".
With regards to claim 4, the rejection of claim 1 is incorporated.
Zhang further teaches wherein the instructions for updating the code sample cause the system to:
determine that the instructions for modifying the code sample include an indication of an algorithm resolving the deficiency; (Zhang Column 19 Lines 23-42, “For example, in some embodiments, at circle “3,” using an input source code segment, or vectorized segment derived from the source code segment, as input, the model training and execution system 410 executes a model 146 resulting in refactoring predictions 414 indicating a predicted refactoring actions associated with the source code segment. In some embodiments, the refactoring predictions 414 can be provided to a user, e.g., as part of a refactoring preview, or automatically performed by a refactoring engine 128 to modify the associated source code [the instructions for modifying the code sample]. In some embodiments, at least one refactoring suggestion from the one or more refactoring recommendations is displayed in association with the portion of source code (e.g., as a code auto-complete suggestion displayed in a source code editor 416. In some embodiments, selection of a refactoring recommendation causes the source code to be modified in accordance with the selected refactoring recommendation (e.g., to modifying the source code text, replace source code components with other source code components, create new source code components, etc [include an indication of an algorithm resolving the deficiency].).”)
The combination of Zhang and Heinonen teaches the indication of the algorithm and the code sample but does not teach: provide the indication of the algorithm and the code sample to the code generation model to update the code sample to include a code portion associated with the algorithm.
However, in an analogous art Graves teaches to provide the indication of the algorithm and the code sample to the code generation model (Graves Column 116 Lines 41-50, “ As another example, some software that interfaces with the generative AI model may dynamically generate prompts to the generative AI model using predefined prompt templates in conjunction with user inputs to menus, selectable elements, or other user interface input fields. As a further example, a user may provide, into a user interface, a portion of code that the user wishes to have the generative AI model optimize, remove some known issues, or otherwise generate some derivative code.”) to update the code sample to include a code portion associated with the algorithm. (Graves Column 117 Lines 31-38, “ If the code fails to satisfy the one or more conditions, the method of FIG. 19 advances to updating 1908 the code by receiving, from the generative AI model, updated code based on a previously performed code analysis. Put differently, in response to the code failing to satisfy the one or more conditions, updated code may then be requested from the generative AI model based on a previously performed code analysis.”)
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to have incorporated the teachings of Graves into the teachings of Zhang in view of Heinonen. This combination of teachings would have resulted in a system capable of analyzing a code sample to generate refactored code using a machine learning model, as in Zhang, with a trained AI model that can generate outputs that are used for iterative verification and fine-tuning, as in Heinonen, and updating the software according to the instructions to remediate identified vulnerabilities, as in Graves. One of ordinary skill in the art would have been motivated to combine these teachings for the purpose of classifying workloads with policies and controls to initiate code review, defect detections, and automated build processes (Graves Column 62 Lines 35-58).
Claim 11 directed to a system corresponding to the non-transitory, computer-readable medium limitations as disclosed in claim 4. Thus, claim 11 is rejected for the same reasons set forth in claim 4.
Claim 18 is directed to a method corresponding to the non-transitory computer-readable medium limitations as disclosed in claim 4. Thus, claim 18 is rejected for the same reasons set forth in claim 4.
Claims 5, 12, and 19 are rejected under 35 U.S.C. 103 as being unpatentable over Zhang in view of Heinonen as applied to claim1, 8, and 15 above, in view of US 12541545 B1 hereinafter “Thanvantri” and further in view of US 20250328652 A1 hereinafter “Vaezi”.
With regards to claim 5, the rejection of claim 1 is incorporated.
The combination of Zhang and Heinonen teaches providing the updated code sample but does not teach: wherein the instructions for providing the output to the output validation model cause the system to:
[provide the updated code sample] to a data generation model to generate a test dataset,
wherein the test dataset includes values associated with one or more deficiencies;
However, in an analogous art Thanvantri teaches wherein the instructions for providing the output to the output validation model cause the system to:
provide the updated code sample to a data generation model to generate a test dataset, (Thanvantri Column 10 Lines 37-48, “The benchmarking dataset generation engine 150 may implement and/or manage various artificial intelligence (AI) and machine learning (ML) agents to assist in various operational tasks for the EDMP of the system 100. The AI/ML agents and their operation associated with the benchmarking dataset generation engine 150, and associated software elements, are described in more detail with reference to an artificial intelligence architecture 500 as depicted in FIG. 5 [to a data generation model to generate a test dataset]. The benchmarking dataset generation engine 150, and associated hardware elements, are described in more detail with reference to a computing architecture 1900 as depicted in FIG. 19.”)
wherein the test dataset includes values associated with one or more deficiencies; (Thanvantri Column 33 Lines 39-45, “Alternatively, or in addition, the benchmarking dataset 228 may be model and/or electronic document agnostic, i.e., it may be used to evaluate any type of model and/or any type of electronic document. Further, the benchmarking dataset 228 may also include the rejected label(s) 226, which may indicate which labels are not to be used to label certain portions of electronic documents.”)
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to have incorporated the teachings of Thanvantri into the teachings of Zhang in view of Heinonen. This combination of teachings would have resulted in a system capable of analyzing a code sample to generate refactored code using a machine learning model, as in Zhang, with a trained AI model that can generate outputs that are used for iterative verification and fine-tuning, as in Heinonen, and generating a benchmarking dataset as a result of output verification, as in Thanvantri. One of ordinary skill in the art would have been motivated to combine these teachings for the purpose of generating a benchmarking dataset that can be used to analyze or assess effectiveness of LLMs (Thanvantri Column 2 Lines 60-65).
The combination of Zhang, Heinonen, and Thanvantri does not teaches to provide the updated code sample and the test dataset but does not teach: provide the updated code sample and the test dataset to the data transformation environment to generate the output associated with the updated code sample;
provide the output to the output validation model to generate the output validation status associated with the output and the test dataset.
However, in an analogous art Vaezi teaches provide the updated code sample and the test dataset to the data transformation environment to generate the output associated with the updated code sample; (Vaezi [0061], “ At operation 402, process 400 (e.g., using one or more components described above) enables the system to receive a user input for creating a rebuild code set corresponding to a code sample. For example, the system may receive a first user input for creating a first rebuild code set corresponding to a first code sample. In some embodiments, the first rebuild code set includes one or more instructions for automatically rebuilding the first code sample following one or more modifications … The rebuild code set may include information relating to a storage location or a file path to source code or scripts (e.g., a code sample) for operation and compilation of the container (e.g., population of the database and associated functions) or application (e.g., a web application associated with a CI/CD development pipeline). By receiving information relating to rebuilding an application or container, the system enables recompilation of software components where any code samples are modified or updated, thereby improving the flexibility of the system for responding to detected vulnerabilities or attacks.”)
provide the output to the output validation model to generate the output validation status associated with the output and the test dataset. (Vaezi [0051], “Cloud components 310 may include model 302, which may be a machine learning model, artificial intelligence model, etc. (which may be referred to collectively as “models” herein). Model 302 may take inputs 304 and provide outputs 306. The inputs may include multiple datasets, such as a training dataset and a test dataset. Each of the plurality of datasets (e.g., inputs 304) may include data subsets related to user data, predicted forecasts and/or errors, and/or actual forecasts and/or errors. In some embodiments, outputs 306 may be fed back to model 302 as input to train model 302 (e.g., alone or in conjunction with user indications of the accuracy of outputs [provide the output to the output validation model] 306, labels associated with the inputs, or with other reference feedback information). For example, the system may receive a first labeled feature input, wherein the first labeled feature input is labeled with a known prediction for the first labeled feature input. The system may then train the first machine learning model to classify the first labeled feature input with the known prediction (e.g., a likelihood of detection of a given vulnerability, or a prediction for a modified code sample for addressing the detected vulnerability) [to generate the output validation status associated with the output and the test dataset].”)
Therefore, it would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to have incorporated the teachings of Vaezi into the teachings of Zhang in view of Heinonen and further in view of Thanvantri. This combination of teachings would have resulted in a system capable of analyzing a code sample to generate refactored code using a machine learning model, as in Zhang, with a trained AI model that can generate outputs that are used for iterative verification and fine-tuning, as in Heinonen, and generating a benchmarking dataset as a result of output verification, as in Thanvantri, using the benchmarking dataset to generate an output that can be further verified, as in Vaezi. One of ordinary skill in the art would have been motivated to combine these teachings for the purpose of a code sample that can be tested and deployed to end users continually with continual updates, modifiecations, and vulnerability remediations (Vaezi [0028]).
Claim 12 directed to a system corresponding to the non-transitory, computer-readable medium limitations as disclosed in claim 5. Thus, claim 12 is rejected for the same reasons set forth in claim 5.
Claim 19 is directed to a method corresponding to the non-transitory computer-readable medium limitations as disclosed in claim 5. Thus, claim 19 is rejected for the same reasons set forth in claim 5.
Allowable Subject Matter
Claims 6-7, 13-14, and are objected to as being dependent upon a rejected base claim, but would be allowable if rewritten in independent form including all of the limitations of the base claim and any intervening claims.
Conclusion
Any inquiry concerning this communication or earlier communications from the examiner should be directed to TRAVIS VIET TRAN whose telephone number is (571)272-3720. The examiner can normally be reached Monday-Friday 8:30AM-5PM.
Examiner interviews are available via telephone, in-person, and video conferencing using a USPTO supplied web-based collaboration tool. To schedule an interview, applicant is encouraged to use the USPTO Automated Interview Request (AIR) at http://www.uspto.gov/interviewpractice.
If attempts to reach the examiner by telephone are unsuccessful, the examiner’s supervisor, Wei Mui can be reached at 571-272-3708. The fax phone number for the organization where this application or proceeding is assigned is 571-273-8300.
Information regarding the status of published or unpublished applications may be obtained from Patent Center. Unpublished application information in Patent Center is available to registered users. To file and manage patent submissions in Patent Center, visit: https://patentcenter.uspto.gov. Visit https://www.uspto.gov/patents/apply/patent-center for more information about Patent Center and https://www.uspto.gov/patents/docx for information about filing in DOCX format. For additional questions, contact the Electronic Business Center (EBC) at 866-217-9197 (toll-free). If you would like assistance from a USPTO Customer Service Representative, call 800-786-9199 (IN USA OR CANADA) or 571-272-1000.
/T.V.T./Examiner, Art Unit 2191 /WEI Y MUI/Supervisory Patent Examiner, Art Unit 2191
Prosecution Insights