DETAILED ACTION
The Office Action is in response to claims filed 08/07/2024.
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 § 102
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 the appropriate paragraphs of 35 U.S.C. 102 that form the basis for the rejections under this section made in this Office action:
A person shall be entitled to a patent unless –
(a)(1) the claimed invention was patented, described in a printed publication, or in public use, on sale, or otherwise available to the public before the effective filing date of the claimed invention.
(a)(2) the claimed invention was described in a patent issued under section 151, or in an application for patent published or deemed published under section 122(b), in which the patent or application, as the case may be, names another inventor and was effectively filed before the effective filing date of the claimed invention.
Claims 1, 6, 11, 13-16, and 20 are rejected under 35 U.S.C. 102(a)(1) as being anticipated by US 20170337040 A1 hereinafter "Salvi".
With regards to claim 1, Salvi teaches
An apparatus, comprising:
a communications interface;
a memory storing instructions; and
at least one processor coupled to the communications interface and to the memory, the at least one processor being configured to execute the instructions to: (Salvi FIG. 3)
transmit, to a device via the communications interface, first data characterizing a plurality of features (Salvi [0035], “During runtime, system 100 can generate the data model tree runtime table 130 to represent the structure of the data model of the application based on the information stored in the extendable data objects table 106 and the extendable data objects relationships table 108. In one embodiment, the system 100 can then dynamically generate queries in the backend system to perform the operations selected by the user on the objects of the application stored in the extendable data objects table 106 or on the relationships between the objects stored in the extendable data objects relationships table 108 [first data characterizing a plurality of features]. … In at least certain embodiments, the extendable data objects table 106 and the extendable data objects relationships table 108 may be implemented in the memory of the database server as “in-memory” data structures. [transmit, to a device via the communications interface]”), the first data causing an application program executed by the device to present interface elements associated with the features within one or more portions of a digital interface; (Salvi [0072], “The create user interface page 600 can be provided to users in the graphical display of the user interface to enable users to design graphical user interfaces for applications they develop using the extended data model framework … The create user interface page 600 also displays a number of objects for the user interface (Object_1 . . . Object_N). Each object may include a number of attributes (e.g., Attribute_1, Attribute_2, . . . , Attribute_N) to be presented in the user interface for applications under development using the extendable data model framework of the embodiments described in this disclosure [to present interface elements associated with the features within one or more portions of a digital interface].”)
receive second data that identifies at least a subset of the features from the device via the communications interface, and based on the second data, generate, for each of the subset of the features, elements of executable code associated with a calculation of a corresponding feature value; (Salvi [0079], “According to certain embodiments, users can develop and customize their applications in a graphical display at the client's system based on the extendable data model framework without writing a single line of code for the application. The backend system (e.g., server computer) can be configured to generate queries for the applications to be developed to modify the data model of the application based on the user inputs to the user interface [generate, for each of the subset of the features, elements of executable code associated with a calculation of a corresponding feature value]. In response to the user input, process 700 continues by generating a query to the extendable data object data structure and/or the extendable data object relationships data structure associated with the application stored in memory of the computer system to retrieve one or more data objects of the application (operation 702).”) [Examiner’s Note: After the interface is generated, the user can provide input (second data) in process 700 in order to generate a query/elements of executable code]
and transmit third data that includes the elements of executable code to the device via the communications interface, the third data causing the executed application program to present the elements of executable code within one or more additional portions of the digital interface. (Salvi [0080-81], “Process 700 continues by creating or modifying the data objects (and/or relationships between the data objects) of the application based on the user input (operation 703), storing the created or modified data objects (and/or relationships between the data objects) of the application back into the appropriate data objects in the memory of the computer system (operation 704), and communicating modifications to the application with the client system over the network(s) (operation 705). In one embodiment, the queries can be generated dynamically at runtime in the backend system to perform the operations on the data objects of the application stored in the extendable data objects data structure and/or on the relationships between the objects stored in the extendable data objects relationships data structure … The updates to the application can then be communicated back to the client and displayed in the user interface at the client system.”)
With regards to claim 6, the rejection of claim 1 is incorporated.
Salvi further teaches wherein the at least one processor is further configured to execute the instructions to generate the elements of executable code in accordance with at least one of a Python format or a structured query language (SQL) format. (Salvi [0027], “ Users can modify objects, relationships between objects, and reference existing objects, primitive types, and definitions, etc. The backend system can handle the necessary structured query language (“SQL”) changes and generate queries (e.g., on the fly) to make the appropriate changes to the data structures for the application. If, for example, a user queries a car object for a company car application that has been developed based on the extendable data model framework, the system can access the data model for the car, query a database for data objects of the car data model, and automatically know what the car data model is, and how is it related to other objects. Then the system can build or update the appropriate queries to modify the data model of the company car application. It should be noted that query languages other than SQL are possible. The embodiments are not limited to any particular query language.”)
With regards to claim 11, the rejection of claim 1 is incorporated.
Salvi further teaches wherein the execute application program causes the device to execute the elements of executable code and generate a feature table that includes feature values associated with the subset of the available features. (Salvi [0064], “When a user creates a new application or modifies an existing application, the structure of those changes is stored in the extendable data objects table 106 and the extendable data objects relationships table 108 [and generate a feature table that includes feature values associated with the subset of the available features]. In response to user input at the user interface 102, the query generator 114 may generate queries to the extendable data model framework 104 stored in memory 122. In other embodiments, the query generator 114 can also query the database 125 for some or all of this information. In one embodiment, the queries may be generated by the query generator 114 dynamically when user input is received at the user interface 102 and provided to the server computer 105. In one embodiment, the server 105 can store and maintain the structure of the applications developed using the extendable data model framework 104 [causes the device to execute the elements of executable code].”) [Examiner’s Note: A extendable model framework helps develop the query code which is executed by the server in order to update and thereby generate a feature/objects table]
Claim 13 is directed to a method corresponding to the apparatus claim as disclosed in claim 1. Thus claim 13 is rejected for the same reasons set forth in claim 1.
With regards to claim 14
A device, comprising:
a communications interface;
a memory storing instructions; and at least one processor coupled to the communications interface and to the memory, the at least one processor being configured to execute the instructions to:
receive, via the communication interface, first data characterizing a plurality of features, (Salvi [0078], “In the illustrated embodiment, process 700 begins at operation 701 by receiving user input from a user interface of a client system in communication with the computer system over one or more networks. The user input may be configured to create or modify an application based on an extendable data model framework that enables users to develop applications in the user interface of the client system. In one embodiment, the extendable data model framework comprises an extendable data object data structure to store data objects of the application and an extendable data object relationships data structure to store relationships between the data objects of the application.”) and perform operations that present interface elements associated with the features within one or more portions of a digital interface; (Salvi [0024], “Embodiments provide an extendable data model framework and a user interface that allow users to create or modify data models for applications, create new fields, business logic, business validations, as well as creating and/or modifying the user interface itself. That is, the user interface can be provided to a client system to facilitate ease of development of the application and for development of the user interface of the application. The extendable data model framework, in at least certain embodiments, provides a configurable solution that facilitates customization and consistency that enables users to create their own custom entities that can be automatically propagated into the user interface.”)
obtain second data indicative of a selection of at least a subset of the features, (Salvi [0066], “The landing page 400 comprises a plurality of graphical elements for users to select to create and access applications 401 within the extendable data model framework. In the illustrated embodiment, landing page 400 includes a create application button 436 for users to select to create a new application to be build using the extendable data model framework. The landing page 400 further includes a search field 437 for users to enter search terms to search for applications, objects, or any other data structures accessible through the system. The landing page 40 further includes a listing of applications 401 (i.e., application_1, application_2, . . . application_N) that may be presented to the user upon startup or after a search has been performed.”) and transmit at least a portion of the second data to a computing system via the communications interface, (Salvi [0080], “Process 700 continues by creating or modifying the data objects (and/or relationships between the data objects) of the application based on the user input (operation 703), storing the created or modified data objects (and/or relationships between the data objects) of the application back into the appropriate data objects in the memory of the computer system (operation 704), and communicating modifications to the application with the client system over the network(s) (operation 705). ”) the computing system being configured to generate, based on the portion of the second data, elements of executable code associated with a calculation of a corresponding feature value for each of the subset of the features; (Salvi [0079], “According to certain embodiments, users can develop and customize their applications in a graphical display at the client's system based on the extendable data model framework without writing a single line of code for the application. The backend system (e.g., server computer) can be configured to generate queries for the applications to be developed to modify the data model of the application based on the user inputs to the user interface [generate, for each of the subset of the features, elements of executable code associated with a calculation of a corresponding feature value]. In response to the user input, process 700 continues by generating a query to the extendable data object data structure and/or the extendable data object relationships data structure associated with the application stored in memory of the computer system to retrieve one or more data objects of the application (operation 702).”) [Examiner’s Note: After the interface is generated, the user can provide input (second data) in process 700 in order to generate a query/elements of executable code] and
receive third data that includes the elements of executable code to the computing system via the communications interface, (Salvi [0060], “The database manager 124 may be configured as a general-purpose database management system (“DBMS”) that communicates with the one or more databases 125 for the purposes of storing and retrieving data to or from the databases 125. A DBMS may be configured as a computer software application that interacts with the database 125 and other applications or users to capture and analyze data. For example, a DBMS may be designed to allow for definition, creation, querying, update, and administration of databases 125. The database manager 124 may comprise an integrated set of computer hardware and software programs that allow client systems 101 to interact with the databases 125 to provide access to data. In addition, the database manager 124 may provide various functions that allow entry, storage, and retrieval of large quantities of information, and provide a mechanism to manage how the information is organized in the databases 125.”) and perform operations that present the elements of executable code within one or more additional portions of the digital interface. (Salvi [0073], “The create user interface page 600 also displays a number of objects for the user interface (Object_1 . . . Object_N). Each object may include a number of attributes (e.g., Attribute_1, Attribute_2, . . . , Attribute_N) to be presented in the user interface for applications under development using the extendable data model framework of the embodiments described in this disclosure.”) [Examiner’s Note: A database communicates with any device with the queried language. Therefore, one of ordinary skill in the art would understand that a database can receive the 3rd data (generated code) and eventually update the user interface accordingly.]
With regards to claim 16,
Salvi further teaches an input device coupled to the at least one processor, wherein the at least one processor is further configured to execute the instructions to: receive, via the input device, elements of input data associated with the selection of at least the subset of the features; (Salvi [0066], “The landing page 400 comprises a plurality of graphical elements for users to select to create and access applications 401 within the extendable data model framework. In the illustrated embodiment, landing page 400 includes a create application button 436 for users to select to create a new application to be build using the extendable data model framework. The landing page 400 further includes a search field 437 for users to enter search terms to search for applications, objects, or any other data structures accessible through the system. The landing page 40 further includes a listing of applications 401 (i.e., application_1, application_2, . . . application_N) that may be presented to the user upon startup or after a search has been performed.”) and generate the second data based on the elements of input data. (Salvi [0079], “According to certain embodiments, users can develop and customize their applications in a graphical display at the client's system based on the extendable data model framework without writing a single line of code for the application [based on the elements of input data]. The backend system (e.g., server computer) can be configured to generate queries for the applications to be developed to modify the data model of the application based on the user inputs to the user interface [generate the second data]. In response to the user input, process 700 continues by generating a query to the extendable data object data structure and/or the extendable data object relationships data structure associated with the application stored in memory of the computer system to retrieve one or more data objects of the application (operation 702).”) [Examiner’s Note: After the interface is generated, the user can provide input (second data) in process 700 in order to generate a query/elements of executable code]
Claims 15 and 20 are directed to a device corresponding to the apparatus limitations as disclosed in claims 11 and 6 respectively. Thus, claims 15 and 20 are rejected for the same reasons set forth in claims 11 and 6.
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 2, 8, 17, and 19 are rejected under 35 U.S.C. 103 as being unpatentable over Salvi in view of US 20240402999 A1 hereinafter “Chen”.
With regards to claim 2, the rejection of claim 1 is incorporated.
Salvi does not teach: the second data comprises feature identifiers associated with the subset of the features; and the at least one processor is further configured to execute the instructions to: obtain feature data records associated with the feature identifiers; and
generate the elements of executable code associated with each of the subset of the features based on a corresponding ones of the feature data records.
However, Chen teaches the second data comprises feature identifiers associated with the subset of the features; (Chen [0138], “System 800 may include featurization engine 820. Featurization engine 820 may include feature annotating & labeling engine 812 (e.g., configured to annotate or label features from a model or data [the second data comprises feature identifiers], which may be extracted by feature extraction engine 814), feature extraction engine 814 (e.g., configured to extract one or more features from a model or data), and/or feature scaling and selection engine 816 [associated with the subset of the features]. Feature scaling and selection engine 816 may be configured to determine, select, limit, constrain, concatenate, or define features (e.g., AI features) for use with AI models.”) and the at least one processor is further configured to execute the instructions to: obtain feature data records associated with the feature identifiers; (Chen [0138], “System 800 may include data input engine 810 that can further include data retrieval engine 804 and data transform engine 806. Data retrieval engine 804 may be configured to access, access, interpret, request, or receive data, which may be adjusted, reformatted, or changed (e.g., to be interpretable by other engine, such as data input engine 810). For example, data retrieval engine 804 may request data from a remote source using an API. Data input engine 810 may be configured to access, interpret, request, format, re-format, or receive input data from data source(s) 802. ”) [Examiner’s Note: The definition of selection encompasses the idea that the user is selecting a subset of features which is accomplished with the label and annotation of these features.] and
generate the elements of executable code (Chen [0046], “For example, embodiments of the present disclosure increase the efficiency and accuracy of methods for synthesizing computer programming code and standalone computer code functions, as well as building entire computer programs, from input containing natural language text. For instance, a machine learning model consistent with disclosed embodiments may output computer code in response to a user input describing a problem to be solved in natural language. As a result, the user may not be required to have any programming knowledge or experience in order to create executable computer code which provides a solution to the problem. In some embodiments, the machine learning model may be trained using incredibly large datasets of code and/or natural language, which may be sourced from disparate places, enabling the model to learn to generate, and generate, functionally accurate code in response to natural language input.”) associated with each of the subset of the features based on a corresponding ones of the feature data records. (Chen [0065], “Fine-tuning may allow the machine learning model to leverage the knowledge and learned representations from a larger, pre-existing model and refine them for a specific task at hand, e.g., using a smaller, task-specific dataset, producing more accurate output (e.g., output more closely corresponding to a desired output). During fine-tuning, a trained machine learning model's parameters may be adjusted or updated using a dataset that is representative of a target task [corresponding ones of the feature data records]. The objective of fine-tuning may be to adjust or update a machine learning model's learned features and weights to better align with the patterns and characteristics of a target task, which may lead to further improved performance and/or generalization [associated with each of the subset of the features].”)
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 Chen into the teachings of Salvi. This combination of teachings would have resulted in an interactive and customized user interface implementing a system to automatically generate query software, as in Salvi, and using datasets in accordance with desired features to generate the software with an artificial intelligence model, as in Chen. One of ordinary skill in the art would have been motivated to combine these teachings for the purpose of providing code suggestions, auto-filling computer code, optimizing software, and generating interface frameworks customized to user preferences (Chen [0047]).
With regards to claim 8, the rejection of claim 1 is incorporated.
Salvi does not teach wherein: the elements of executable code comprise one or more initial elements of executable code; and
the at least one processor is further configured to execute the instructions to:
based on an application of a trained, large-language process to the one or more initial elements of executable code, generate one of more additional elements of executable code; and
perform operations that concatenate the initial and additional elements of executable code, and that generate the third data based on the concatenation of the initial and additional elements of executable code.
However, in an analogous art Chen teaches wherein: the elements of executable code comprise one or more initial elements of executable code; (Chen [0086], “In some embodiments, a method may also comprise receiving one or more computer code samples. Receiving, as used herein, may refer to requesting, accessing, obtaining, acquiring, accepting, identifying, selecting, highlighting, and/or collecting. For example, one or more computer code samples may be received when a user highlights (or otherwise selects) at least a portion of computer code, such as by providing an input to a user interface for assessing, executing, and/or modifying code. As another example, one or more computer code samples may be received when a user inputs at least a portion of computer code into a prompt field. In some embodiments, a user may input at least a portion of computer code and natural language text into a prompt field.”) [Examiner’s Note: Chen describes using natural language to generate code from an AI model. By receiving code samples as input to generate natural language as a prompt for further code generation Chen teaches upon initial code to generate an updated version therein.] and
the at least one processor is further configured to execute the instructions to:
based on an application of a trained, large-language process to the one or more initial elements of executable code, generate one of more additional elements of executable code; (Chen [0061], “It is appreciated that the technical embodiments for generating computer code based on natural language input, as discussed herein, implement a solution rooted in computer technology rather than simply following rules. Further, it is appreciated that such technical embodiments contribute to solving the complex problem of automating computer code generation by training an artificial intelligence model using a vast amount of data and utilizing the artificial intelligence model to generate accurate predictions of computer code.”) and
perform operations that concatenate the initial and additional elements of executable code, and that generate the third data based on the concatenation of the initial and additional elements of executable code. (Chen [0052], “A computer code sample, as used herein, may refer to any combination of a phrase, function, procedure, script, string, or concatenation of computer programming code. A candidate result, as used herein, may refer to a potential or possible outcome which may or may not equate to the desired result indicated by the natural language input (e.g., a candidate result, or candidate solution, may not necessarily solve the problem at hand). In some embodiments, a higher number of computer code samples provided by a trained machine learning model may result in more accurate candidate results based on the input docstring. For example, a machine learning model that outputs one computer code sample in response to an input docstring provides one candidate result and no other potential computer code samples which may provide other candidate results; however, a machine learning model that outputs 100 computer code samples in response to an input docstring provides 100 respective candidate results, any one of which may provide a desired result.”)
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 Chen into the teachings of Salvi. This combination of teachings would have resulted in an interactive and customized user interface implementing a system to automatically generate query software, as in Salvi, and using datasets in accordance with desired features to generate the software with an artificial intelligence model, as in Chen. One of ordinary skill in the art would have been motivated to combine these teachings for the purpose of providing code suggestions, auto-filling computer code, optimizing software, and generating interface frameworks customized to user preferences (Chen [0047]).
With regards to claim 17, the rejection of claim 16 is incorporated.
Salvi does not teach: wherein: the elements of input data comprise feature identifiers associated with the subset of the features; and the second data comprises the feature identifiers; and
the computing system is further configured to:
obtain feature data records associated with the feature identifiers from a data repository;
and generate the elements of executable code associated with each of the subset of the features based on a corresponding ones of the feature data records.
However, in an analogous art Chen teaches wherein: the elements of input data comprise feature identifiers associated with the subset of the features; and the second data comprises the feature identifiers; (Chen [0138], “System 800 may include featurization engine 820. Featurization engine 820 may include feature annotating & labeling engine 812 (e.g., configured to annotate or label features from a model or data [the second data comprises feature identifiers], which may be extracted by feature extraction engine 814), feature extraction engine 814 (e.g., configured to extract one or more features from a model or data), and/or feature scaling and selection engine 816 [associated with the subset of the features]. Feature scaling and selection engine 816 may be configured to determine, select, limit, constrain, concatenate, or define features (e.g., AI features) for use with AI models.”) and
the computing system is further configured to:
obtain feature data records associated with the feature identifiers (Chen [0138], “System 800 may include data input engine 810 that can further include data retrieval engine 804 and data transform engine 806. Data retrieval engine 804 may be configured to access, access, interpret, request, or receive data, which may be adjusted, reformatted, or changed (e.g., to be interpretable by other engine, such as data input engine 810). For example, data retrieval engine 804 may request data from a remote source using an API. Data input engine 810 may be configured to access, interpret, request, format, re-format, or receive input data from data source(s) 802. ”) [Examiner’s Note: The definition of selection encompasses the idea that the user is selecting a subset of features which is accomplished with the label and annotation of these features.] from a data repository; (Chen [0053], “A software repository (also referred to as a package repository or a software source), as used herein, may refer to a centralized location comprising a collection of software components that are organized and managed to facilitate software development, distribution, and updates, and where software packages, libraries, and related files are stored and made available for distribution and installation.”) and generate the elements of executable code (Chen [0046], “For example, embodiments of the present disclosure increase the efficiency and accuracy of methods for synthesizing computer programming code and standalone computer code functions, as well as building entire computer programs, from input containing natural language text. For instance, a machine learning model consistent with disclosed embodiments may output computer code in response to a user input describing a problem to be solved in natural language. As a result, the user may not be required to have any programming knowledge or experience in order to create executable computer code which provides a solution to the problem. In some embodiments, the machine learning model may be trained using incredibly large datasets of code and/or natural language, which may be sourced from disparate places, enabling the model to learn to generate, and generate, functionally accurate code in response to natural language input.”) associated with each of the subset of the features based on a corresponding ones of the feature data records. (Chen [0065], “Fine-tuning may allow the machine learning model to leverage the knowledge and learned representations from a larger, pre-existing model and refine them for a specific task at hand, e.g., using a smaller, task-specific dataset, producing more accurate output (e.g., output more closely corresponding to a desired output). During fine-tuning, a trained machine learning model's parameters may be adjusted or updated using a dataset that is representative of a target task [corresponding ones of the feature data records]. The objective of fine-tuning may be to adjust or update a machine learning model's learned features and weights to better align with the patterns and characteristics of a target task, which may lead to further improved performance and/or generalization [associated with each of the subset of the features].”)
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 Chen into the teachings of Salvi. This combination of teachings would have resulted in an interactive and customized user interface implementing a system to automatically generate query software, as in Salvi, and using datasets in accordance with desired features to generate the software with an artificial intelligence model, as in Chen. One of ordinary skill in the art would have been motivated to combine these teachings for the purpose of providing code suggestions, auto-filling computer code, optimizing software, and generating interface frameworks customized to user preferences (Chen [0047]).
Claim 19 is directed to a device corresponding to the apparatus limitations as disclosed in claim 8. Thus, claim 19 is rejected for the same reasons set forth in claim 8.
Claim 3 is rejected under 35 U.S.C. 103 as being unpatentable over Salvi in view of Chen, as applied to claim 2, and further in view of US 12368745 B1 hereinafter “Guo”.
With regards to claim 3, the rejection of claim 2 is incorporated.
The combination of Salvi and Chen teaches the corresponding one of the feature data records being associated with a corresponding one of the subset of the features but does not teach: wherein the at least one processor is further configured to execute the instructions to:
obtain an identifier of a mapped data table from a corresponding one of the feature data records, [the corresponding one of the feature data records being associated with a corresponding one of the subset of the features;] and
generate the elements of executable code associated with the corresponding one of the subset of the features based on the identifier.
However, in an analogous art Guo teaches wherein the at least one processor is further configured to execute the instructions to:
obtain an identifier of a mapped data table from a corresponding one of the feature data records […](Guo Columns 72-73 Lines 66-67 and 1-18, “ For example, in some embodiments, the first query or associated data may be parsed to detect references to particular tables [obtain an identifier of a mapped data table]. In some embodiments, generating 506 the one or more second queries may include identifying, from the first query, one or more column filters. The identified column filters for a particular table may then be included in the generated 506 second query directed to that particular table. As an example, if the first query includes a column filter for a particular column value on table A (e.g., select all records in table A with a value equal to X), that column filter will then be included in the generated 506 second query directed to table A. In other words, in some embodiments, the first query may be used to determine which tables the large language model selected for access and any filters applied to those tables. The second queries may then be generated to select data from those tables using the applied filters. Thus, other operations such as JOINS or other transformations across data sets (e.g., across tables) found in the first query are effectively excluded by virtue of each table being accessed using a separate second query.”) and
generate the elements of executable code associated with the corresponding one of the subset of the features based on the identifier. (Guo Column 72 Lines 8-27, “Each user interface element may present some data (e.g., as a table) or render a visualization based on some data (e.g., graphs, polygraphs, or other visualizations as can be appreciated). In some embodiments, each user interface element may correspond to a particular table of the plurality of tables. Thus, when a particular user interface element is presented or rendered, some amount of data from the corresponding table is loaded (e.g., via a query) and presented or visualized in the particular user interface element. Each table may therefore store different types of data related to the anomaly detection framework and/or the corresponding cloud deployment. As an example, a first table may store information indicating application connections to remote hosts, a second table may store information indicating applications with particular vulnerabilities, a third table may store permissions and privileges for application and data storage, and the like. Each of these tables may have a corresponding user interface element that, when accessed by a user, presents or visualizes data from their respective tables.”)
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 Guo into the teachings of Salvi in view of Chen. This combination of teachings would have resulted in an interactive and customized user interface implementing a system to automatically generate query software, as in Salvi, and using datasets in accordance with desired features to generate the software with an artificial intelligence model, as in Chen, and filtering between datasets in order to determine features corresponding to optimal code generation, as in Guo. One of ordinary skill in the art would have been motivated to combine these teachings for the purpose of automatically generating SQL queries in accordance to user interactions and displaying visualizations for interactions as required (Guo Column 53 Lines 28-46).
Claim 4 is rejected under 35 U.S.C. 103 as being unpatentable over Salvi in view of Guo.
With regards to claim 4, the rejection of claim 1 is incorporated.
Salvi does not teach: wherein the at least one processor is further configured to execute the instructions to generate, based on the second data, first elements of executable code and second elements of executable code, the first elements of executable code being associated with an extraction of a corresponding, first feature value from a mapped data table, and the second elements of executable code being associated with a calculation of a corresponding, second feature value based on an application of one or more database operations to corresponding mapped data tables.
However, in an analogous art Guo teaches wherein the at least one processor is further configured to execute the instructions to generate, based on the second data, first elements of executable code and second elements of executable code, the first elements of executable code being associated with an extraction of a corresponding, first feature value from a mapped data table, (Guo Column 74 Lines 24-61, “The data relevant to the user may be spread across multiple user interface elements, requiring the user to navigate between these user interface elements, manually enter the various filters, and potentially navigate between multiple browser tabs to view the relevant data concurrently or contemporaneously. Instead, the user may provide a natural language input of “show me all EC2 instances with critical vulnerabilities and talking to an Amazon S3 service in CloudTrail and also having an outgoing connection to a public IP address.” Rather than navigating between multiple user interface elements or browser tabs and manually entering various filters, each of the multiple tables relevant to the user may be queried using generated second queries. The user interface elements for each of these tables may then be presented in-line to the user allowing them to navigate the relevant data within a same user interface screen … Accordingly, these features are used to generate individual queries to individual tables (e.g., the second queries described above). The results of these individual queries may then be presented to a user via their respective user interface elements, ensuring that the user is presented with the data most relevant to their natural language input query.”) and the second elements of executable code being associated with a calculation of a corresponding, second feature value based on an application of one or more database operations to corresponding mapped data tables. (Guo Column 26 Lines 42-55, “Query service 166 is a microservice that may manage all database access for web app 120. Query service 166 abstracts out data obtained from data store 30 and provides a JSON-based REST API service to web app 120. Query service 166 may generate SQL queries for the REST APIs that it receives at run time. Query service 166 can be implemented using any appropriate programming language, such as Java or C and SQL/JDBC libraries, or an SQL framework such as jOOQ. Query service 166 can internally make use of a variety of types of databases, including a relational database engine 168 (e.g., AWS Aurora) and/or data store 30 to manage data for clients. Examples of tables that query service 166 manages are OLTP tables and data warehousing tables.”)
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 Guo into the teachings of Salvi. This combination of teachings would have resulted in an interactive and customized user interface implementing a system to automatically generate query software, as in Salvi, and filtering between datasets in order to determine features corresponding to optimal code generation, as in Guo. One of ordinary skill in the art would have been motivated to combine these teachings for the purpose of automatically generating SQL queries in accordance to user interactions and displaying visualizations for interactions as required (Guo Column 53 Lines 28-46).
Claims 5 and 18 are rejected under 35 U.S.C. 103 as being unpatentable over Salvi in view of US 20170351511 A1 hereinafter “Bar-Or”.
With regards to claim 5, the rejection of claim 1 is incorporated.
Salvi does not teach the at least one processor is further configured to generate elements of metadata that characterize the generation of the elements of executable code, the elements of metadata comprising a feature identifier of each of the subset of the features, a feature category associated with each of the subset of the features, and elements of textual data that describe each of the subset of the features;
the third data comprises the elements of executable code and the elements of the metadata; and
the third data causes the executed application program to present the elements of metadata within one or more further portions of the digital interface.
However, in an analogous art Bar-Or teaches the at least one processor is further configured to generate elements of metadata that characterize the generation of the elements of executable code, (Bar-Or [0089], “The more use cases that are executed using Signal Hub 60, the less time it takes to actually implement them over time because the answers to a problem may already exist inside Signal Hub 60 after a few rounds of signal creation and use case implementation. Signals are hierarchical, such that within Signal Hub 60, a signal array might include simple signals that can be used by themselves to predict behavior (e.g., customer behavior powering a recommendation) and/or can be used as inputs into more sophisticated predictive models. These models, in turn, could generate second-order, highly refined signals, which could serve as inputs to business-process decision points.”) the elements of metadata comprising a feature identifier of each of the subset of the features (Bar-Or [0127], “The Signal Hub platform 600 also displays all the data sources that are fed into the signals of the category chosen … A user can then choose one or more of these data sources to further filter the signals (and/or to navigate to those data sources for additional information).”), a feature category associated with each of the subset of the features, and elements of textual data that describe each of the subset of the features; (Bar-Or [0126], “As shown, the Signal Hub platform 600 includes a side menu 602 which allows a user to filter signals, such as by entering a search description into a search bar, or by browsing through various categories (e.g., business attribute, window, subject, object, relationship, category, etc.). The Signal Hub platform 600 further includes a main view portion 604. The main view portion 604 diagrammatically displays data sources 606 (e.g., business inputs), descriptive signals 608 (e.g., grouped and organized by metadata), and predictive signals 610. The descriptive signals 608 include a wheel of tabs indicating categories to browse in searching for a particular signal.”) [Examiner’s Note: A signal describes a feature that can be categorized and selected according their descriptive identifiers. A user interface will show a plurality of signal identifiers/descriptions in which the user can select a subset according to a category.]
the third data comprises the elements of executable code and the elements of the metadata; (Bar-Or [0076], “Signal Hub provides a layer of maintained and refreshed intelligence (e.g., Signals) on top of the raw data that serves as a repository for scientists (e.g., data scientists) and developers (e.g., application developers) to execute analytics. This prevents users from having to go back to the raw data for each new use case, and can instead benefit from existing signals stored in Signal Hub. Signal Hub continually extracts, stores, refreshes, and delivers the signals needed for specific applications, such that application developers and data scientists can work directly with signals rather than raw data … Signal Hub can also have a data flow engine that is flexible to allow processing of different computing environments, languages, and frameworks. A multi target system data flow compiler can generate code to deploy on different target data flow engines utilizing different computer environments, languages, and frameworks.”) and
the third data causes the executed application program to present the elements of metadata within one or more further portions of the digital interface. (Bar-Or [0121], “This visualization could be automatically generated from YAML code (e.g., the code that reads and does initial linking and joining of data). As shown, analytic code development window 504 allows a user to view relations and interactions between various data elements. The data model organizes data elements into fact and dimension tables and standardizes how the data elements relate to one another. This could be automatically generated in Signal Hub after loading the data. FIG. 17A is a screenshot illustrating creation of reusable analytic code using the Workbench 500 generated by the system. As shown, the analytic code development window 504 includes many lines of code that incorporate and utilize the raw data previously selected and prepared. The Signal API could be scalable and easy to use (e.g., for loop signals, peer comparison signals, etc.). Further, Signal Hub could provide signal management by using @tag and @doc to specify signal metadata and description, which can be automatically extracted and displayed in the Knowledge Center. FIG. 17B is a screenshot illustrating the graphical user interface of Signal API in Workbench.”)
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 Bar-Or into the teachings of Salvi. This combination of teachings would have resulted in an interactive and customized user interface implementing a system to automatically generate query software, as in Salvi, using metadata to classify features and generating software for display, as in Bar-Or. One of ordinary skill in the art would have been motivated to combine these teachings for the purpose of organizing signals into sets according to business domains in order to provide increased productivity by offering software solutions and deployment thereof (Bar-Or [0086-87]).
Claim 18 is directed to a device corresponding to the apparatus limitations as disclosed in claim 5. Thus claim 18 is rejected for the same reasons set forth in claim 5.
Claim 7 is rejected under 35 U.S.C. 103 as being unpatentable over Salvi in view of US 20240370231 A1 hereinafter “Zhao”.
With regards to claim 7, the rejection of claim 1 is incorporated.
Salvi does not teach: wherein: the first data comprises a feature category associated with each of the subset of features and a feature identifier associated with each of the subset of features;
the executed application program causes the device to present interface elements representative of each of the feature identifiers and the corresponding feature categories within the one or more portions of the digital interface.
However, in an analogous art Zhao teaches wherein: the first data comprises a feature category associated with each of the subset of features (Zhao [0044], “The selection panel 410 may be an area or portion of the GUI 400 in which a user may interact with a set of function categories 415. A function category may be associated with a particular category or class of programming functionality or functions. For example, as illustrated in FIG. 4, the set of function categories 415 includes a listing of function categories, such as, e.g., a general category, a logic category, a math category, a string category, a data category, a binary category, an input/output category, a timer category, a scaler category, a counter category, a customized category (e.g., a Bottle Fill category, as illustrated in FIG. 4), a variables category, a message (Msg) category, a sockets category, a library category, and a demo category. In some configurations, the selection panel 410 may include additional, different, or fewer function categories than illustrated in FIG. 4 in various configurations.”) and a feature identifier associated with each of the subset of features; (Zhao [0050], “The graphical representation may include one or more user interface elements or components, such as, e.g., an input control component, a navigational component, an informational component, etc. For instance, the graphical representation may include an identifier of the function (e.g., a function name, such as, e.g., “DELETEALL”), a category identifier of the function (e.g., a category name, such as, e.g., sockets), additional information associated with the function (e.g., a common use case for the function, a function description, an implementation suggestion or recommendation, a listing of associated parameters, a set of implementation instructions, etc.), and the like.”)
the executed application program causes the device to present interface elements representative of each of the feature identifiers and the corresponding feature categories within the one or more portions of the digital interface. (Zhao [0049-50], “Returning to FIG. 3, the electronic processor 200 may generate a graphical representation of the function (at block 315). In some configurations, the electronic processor 200 generates the graphical representation within (or for display within) the GUI (e.g., the GUI 400). The graphical representation may be a visual representation or depiction of a function (e.g., a visual function instance). As one example, a graphical representation may be a block (or other shape) that may be manipulated and configured within the workspace 405, where the block represents a particular code function. Accordingly, in some configurations, the graphical representation may be referred to as an instruction block, a code block, a function block, etc … In some configurations, the graphical representation includes one or more interactive components (e.g., interactive GUI components or elements). An interactive component may include an input control, such as, e.g., a checkbox, a radio button, a dropdown list, a list box, a button, a toggle, a text field, a date field, etc. In some configurations, an interactive component may receive a parameter for configuring a function (also referred to herein as a configuration parameter). A parameter may refer to a parameter type, a parameter value, etc. As one example, in some configurations, a user may interact with an interactive component to select a parameter type (e.g., a time parameter, an input pin parameter, etc.). As another example, in some configurations, a user may interact with an interactive component to select a parameter value (e.g., a value for a parameter type, such as “5” or “PIN_7”).”)
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 Zhao into the teachings of Salvi. This combination of teachings would have resulted in an interactive and customized user interface implementing a system to automatically generate query software, as in Salvi, wherein the user interface is a means for visual programming with graphical representations to generate code, as in Zhao. One of ordinary skill in the art would have been motivated to combine these teachings for the purpose of editing and building software with graphical representations of software to generate a final code file (Zhao [0065]).
Claim 9 is rejected under 35 U.S.C. 103 as being unpatentable over Salvi in view of Chen and further in view of US 12511282 B1 hereinafter “Ojha”
With regards to claim 9, the rejection of claim 8 is incorporated.
The combination of Salvi and Chen does not teach wherein the trained, large-language process comprises a pre-trained generative transformer, and the one of more additional elements of executable code comprise elements of generative code.
However, in an analogous art Ojha teaches wherein the trained, large-language process comprises a pre-trained generative transformer, and the one of more additional elements of executable code comprise elements of generative code. (Ojha Column 9 Lines 42-65, “ The model 140 can generate accurate SQL or other output, perhaps with multiple steps and prompts to users for confirmation [and the one of more additional elements of executable code comprise elements of generative code]. Rather than engineers writing code to perform SQL generation, engineers can write workflows for LLMs to guide end users through the process of performing certain tasks. Using the LLM, potentially with multiple steps, the system can take the user question and schema into a well-refined input set that the LLM or another model can use to complete a user's task … The arrangement also allows for much faster updating of the data analytics system, including the ability to make different functions modular through different machine learning models and workflows that rely on models. Trained models can incrementally and selectively replace hard-coded deterministic modules in the system 110 over time, as appropriate amounts of training examples are generated and quality of model output is verified [wherein the trained, large-language process comprises a pre-trained generative transformer].”)
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 Ojha into the teachings of Salvi in view of Chen. This combination of teachings would have resulted in an interactive and customized user interface implementing a system to automatically generate query software, as in Salvi, and using datasets in accordance with desired features to generate the software with an artificial intelligence model, as in Chen, with the artificial intelligence model trained to generate, update, or replace with modified software, as in Ojha. One of ordinary skill in the art would have been motivated to combine these teachings for the purpose of using information about the user, interface context, and data source characteristics to generate SQL statements with an AI/ML model trained accordingly (Ojha Column 4 Lines 46-67).
Claim 12 is rejected under 35 U.S.C. 103 as being unpatentable over Salvi in view of US 12511282 B1 hereinafter “Ojha”
With regards to claim 12, the rejection of claim 1 is incorporated.
Salvi does not teach: wherein the plurality of features is available to one or more machine-learning or artificial-intelligence processes.
However, in an analogous art Ojha teaches wherein the plurality of features is available to one or more machine-learning or artificial-intelligence processes. (Ojha Column 6 Lines 17-47, “In addition to the training examples 220, 230, the AI/ML model 140 can be trained using the user input or user feedback that is provided through use of the system. For example, in the example of FIG. 1, if the user 122 edits the generated SQL statement 142 when shown in the interface 130b, the edits and resulting edited SQL statement can be recorded and used to further train the AI/ML model 140. As a result, as users continue to use the features the model 140 supports, their positive and negative feedback can reinforce positive characteristics of generated results and inhibit errors or undesirable characteristics of generated results. Both types of training examples 220, 230 can be stored in or with the AI/ML model 140, to provide a context and data set from which the LLM 200 can draw to generate SQL statements for new user inputs. In some implementations, the context provided by the training examples 210 represents a wrapper or additional component of the AI/ML model 140. In other implementations, the LLM 200 can be further trained or refined using the training examples 210, to result in a modified LLM 200 that incorporates the information from the training examples 210. In some implementations, the AI/ML model 140 can be updated or informed by information that is specific for a user, group of users, or organization. For example, a particular company or department within a company may have a particular data catalog 260 or repository of metadata 270 that indicates commonly used terminology and object definitions. Having this information for the AI/ML model 140 to learn from or to reference during generation can greatly improve the versatility of the AI/ML model 140 to handle the wide range of user requests that may be provided. ”)
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 Ojha into the teachings of Salvi. This combination of teachings would have resulted in an interactive and customized user interface implementing a system to automatically generate query software, as in Salvi, with an artificial intelligence model trained to generate, update, or replace with modified software, as in Ojha. One of ordinary skill in the art would have been motivated to combine these teachings for the purpose of using information about the user, interface context, and data source characteristics to generate SQL statements with an AI/ML model trained accordingly (Ojha Column 4 Lines 46-67).
Claim 10 is rejected under 35 U.S.C. 103 as being unpatentable over Salvi in view of US 12346333 B1 hereinafter “Aversano” and further in view of Ojha.
With regards to claim 10, the rejection of claim 1 is incorporated.
Salvi does not teach: wherein the at least one processor is further configured to execute the instructions to: receive a structured or unstructured textual query from the device via the communications interface;
identify a feature identifier based on an application of a natural-language processing operation to portions of the structured or unstructured textual query; and
transmit a response to the structured or unstructured textual query that includes the feature identifier to the device via the communications interface, the response causing the executed application program to present at least one additional interface element associated with the feature identifier within the one or more portions of the digital interface.
However, in an analogous art Aversano teaches wherein the at least one processor is further configured to execute the instructions to: receive a structured or unstructured textual query from the device via the communications interface; (Aversano Column 5 Lines 44-53, “The web application 110 communicates with a web service 114 via a representational state transfer (REST) application programming interface (API) 116. The web service 114 may be one of a cluster of web services 118 serving the programming development environment 100. In response to requests received by the web application 110 to access (e.g., retrieve or update) user data stored in a user database 120, the web service 118 requests access to the user data through the REST API 116. The user database 120 may be a structured query language (SQL) database or other such relational database. Other types of databases may be used to store user data, such as object-oriented databases (OODB), object-relational databases (ORD), or the like.”)
identify a feature identifier based on an application of a natural-language processing operation to portions of the structured or unstructured textual query; (Aversano Columns 5-6 Lines 61-67 and 1-6, “Upon receiving a request to access a data element in the user database 120 through the REST API 116, the web service 114 automatically generates one or more database queries, such as SQL queries, based on data elements requested and additional search criteria. See, for example, FIG. 1A. For example, the web service 114 retrieves metadata structure(s) that correspond to the requested data element from a metadata database 122. As described in more detail below, the metadata structure is parsed to create a hierarchy of objects, where each object belongs to a code element, such as a SQL statement or query, that defines the object's structure and behavior for retrieving or updating the data element from the user database 120”)
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 Aversano into the teachings of Salvi. This combination of teachings would have resulted in an interactive and customized user interface implementing a system to automatically generate query software, as in Salvi, and receiving data through the communication interface via query languages to generate software accordingly, as in Aversano. One of ordinary skill in the art would have been motivated to combine these teachings for the purpose of using an intuitive user interface in order to convert metadata and generate underlying software in order to implement the intended application (Aversano Column 4 Lines 13-24).
The combination of Salvi and Aversano teaches the structured or unstructured textual query that includes the feature identifier but does not teach: transmit a response [to the structured or unstructured textual query that includes the feature identifier] to the device via the communications interface, the response causing the executed application program to present at least one additional interface element associated with the feature identifier within the one or more portions of the digital interface.
However, in an analogous art Ojha teaches transmit a response […] to the device via the communications interface, the response causing the executed application program to present at least one additional interface element associated with the feature identifier within the one or more portions of the digital interface. (Ojha Column 25 Lines 8-36, “The computer system 110 uses information about the user 922, the context of the interface 930a in which the text 932 is entered, and characteristics of the data source (e.g., Example DB) to generate an interactive document using a AI/ML model 940. The AI/ML model 940 can include a large language model (LLM) that has been trained on a large number of text examples. The AI/ML model 940 has been further trained with examples of interactive documents and corresponding data, such as text descriptions, natural language requests, database schema information, object models, application context, data, and so on. As a result, the AI/ML model 940 has been trained to identify, from the inputs it receives, likely document content and interactive elements, including relevant portions of data sources, that would be used in different situations. In addition, the AI/ML model 940 can have a training state that represents characteristics of interactive documents, such as layout, formatting, visualization types (e.g., the charts or graphs used in different situations or for different types of data), color schemes, fonts, element sizing, document length, and so on. The AI/ML model 940 has also learned to provide document content, such as visualizations, interactive elements (e.g., filter controls, sharing controls, controls for sorting or searching through data, etc.), and connections with underlying data sources (e.g., which tables, columns, attributes, metrics, data ranges, etc. would be relevant to a user-submitted prompt, and which visualizations or operations should be based on them).”)
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 Ojha into the teachings of Salvi in view of Aversano. This combination of teachings would have resulted in an interactive and customized user interface implementing a system to automatically generate query software, as in Salvi, and receiving data through the communication interface via query languages to generate software accordingly, as in Aversano with an artificial intelligence model trained to generate, update, or replace with modified software, as in Ojha. One of ordinary skill in the art would have been motivated to combine these teachings for the purpose of using information about the user, interface context, and data source characteristics to generate SQL statements with an AI/ML model trained accordingly (Ojha Column 4 Lines 46-67).
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