DETAILED ACTION
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 § 101
35 U.S.C. 101 reads as follows:
Whoever invents or discovers any new and useful process, machine, manufacture, or composition of matter, or any new and useful improvement thereof, may obtain a patent therefor, subject to the conditions and requirements of this title.
Claims 1-20 are rejected under 35 U.S.C. 101 because the claimed invention is directed to an abstract idea without significantly more. The analysis of the claims’ subject matter eligibility will follow the 2019 Revised Patent Subject Matter Eligibility Guidance, 84 Fed. Reg. 50-57 (January 7, 2019) (“2019 PEG”).
With respect to claim 1.
Claim 1 is rejected under 35 U.S.C. 101 because the claimed invention is directed to an abstract idea without significantly more.
Step 1: Is the claim to a process, machine, manufacture, or composition of matter? Yes—claim 1 recites a method, which is a process.
Step 2A, prong one: Does the claim recite an abstract idea, law of nature or natural phenomenon? Yes—the limitations identified below each, under its broadest reasonable interpretation, covers mental processes abstract idea grouping (concepts performed in the human mind (including an observation, evaluation, judgment, opinion)), see MPEP 2106.04(a)(2), subsection III and the 2019 PEG, but for the recitation of generic computer components:
“determining, by the computing device, settable attributes of each input object of the plurality of input objects; (Mental processes- concept of observation and evaluation of information)
creating, by the computing device, a subset of the settable attributes based on an input filter; (Mental processes- concept of observation and evaluation of data analysis and filtering data)
determining, by the computing device during an execution of the rules engine, a plurality of output objects created during the execution of the rules engine and gettable attributes of each output object of the plurality of output objects; (Mental processes- concept of observation and evaluation of information)
creating, by the computing device, a subset of the gettable attributes based on an output filter;” (Mental processes- concept of observation and evaluation of data analysis and filtering data).
Step 2A, prong two: Does the claim recite additional elements that integrate the judicial exception into a practical application? No—the judicial exception is not integrated into a practical application.
“obtaining, by a computing device, a plurality of input objects;” involves the mere gathering of data, which is insignificant extra-solution activity. See MPEP § 2106.05(g).
inserting, by the computing device, the subset of the settable attributes into a rules engine, the rules engine comprising a set of rules evaluated with an input and producing an output during an execution of the rules engine; Merely reciting the words “apply it” (or an equivalent) with the judicial exception, or merely including instructions to implement an abstract idea on a computer, or merely using a computer as a tool to perform an abstract idea, as discussed in MPEP § 2106.05(f).
“storing, in a memory of the computing device, one or more rules and corresponding gettable attributes and values of the gettable attributes based on the subset of the gettable attributes”: Adding insignificant extra-solution activity to the judicial exception of data storage, as discussed in MPEP § 2106.05(g).
The generic computer components in these steps are recited at a high-level of generality (i.e., as a generic computer component performing a generic computer function) such that it amounts no more than mere instructions to apply the exception using a generic computer component. Accordingly, this additional element does not integrate the abstract idea into a practical application because it does not impose any meaningful limits on practicing the abstract idea. The claim is directed to an abstract idea.
Step 2B: Does the claim recite additional elements that amount to significantly more than the judicial exception? No—there are no additional limitations beyond the mental processes identified above. The limitation treated above, are directed to the well-understood, routine, and conventional activity of storing and retrieving information in memory. See MPEP § 2106.05(d)(II); Versata Dev. Group, Inc. v. SAP Am., Inc., 793 F.3d 1306, 1334, 115 USPQ2d 1681, 1701 (Fed. Cir. 2015). It also includes limitations that Merely reciting the words “apply it” (or an equivalent) with the judicial exception, or merely including instructions to implement an abstract idea on a computer, or merely using a computer as a tool to perform an abstract idea, as discussed in MPEP § 2106.05(f). The additional element is insignificant application, which is similar to examples of activities that the courts have found to be insignificant extra-solution activity, in accordance with MPEP 2106.05(g), Insignificant Extra-Solution Activity. Mere instructions to apply an exception using a generic computer component cannot provide an inventive concept.
Thus, considering the additional elements individually and in combination and the claims as a whole, the additional elements do not provide significantly more than the abstract idea. This claim is not patent eligible.
Claim 2.
Step 1: A method, as above.
Step 2A Prong 1: abstract idea from claim 1.
Step 2A Prong 2, Step 2B: the limitation, “subsequent to storing, in the memory of the computing device, one or more rules and corresponding gettable attributes and values of the gettable attributes based on the subset of the gettable attributes, applying one or more explainable artificial intelligence techniques to the rules engine using inputs corresponding to the subset of settable attributes and outputs corresponding to the subset of gettable attributes.”, Merely reciting the words “apply it” (or an equivalent) with the judicial exception, or merely including instructions to implement an abstract idea on a computer, or merely using a computer as a tool to perform an abstract idea, as discussed in MPEP § 2106.05(f). This judicial exception is not integrated into a practical application. Mere recitation of generic computer components neither integrates the judicial exception into a practical application nor provides an inventive concept.
Claim 3.
Step 1: A method, as above.
Step 2A Prong 1: The claim recites that “wherein the settable attributes comprise one or more attributes of an input object of the plurality of input objects that can be set with a value.”: This limitation merely specifies mental processes- concept of observation and evaluation of defining settable/gettable attributes.
Step 2A Prong 2, Step 2B: This judicial exception is not integrated into a practical application. Mere recitation of generic computer components neither integrates the judicial exception into a practical application nor provides an inventive concept.
Claim 4.
Step 1: A method, as above.
Step 2A Prong 1: The claim recites that “wherein determining the settable attributes of each input object of the plurality of input objects comprises: for each input object of the plurality of input objects: identifying attributes of the input object that can be set with a value or one or more sub-objects of the input object; and for each sub-object of the one or more sub-objects of the input object: identifying attributes of the sub-object that can be set with a value.”: This limitation merely specifies mental processes- concept of observation and evaluation of defining settable/gettable attributes.
Step 2A Prong 2, Step 2B: This judicial exception is not integrated into a practical application. Mere recitation of generic computer components neither integrates the judicial exception into a practical application nor provides an inventive concept.
Claim 5.
Step 1: A method, as above.
Step 2A Prong 1: The claim recites that “subsequent to determining the settable attributes of each input object of the plurality of input objects, overwriting one or more of the settable attributes.”: This limitation merely specifies mental processes- concept of observation and evaluation of defining settable/gettable attributes.
Step 2A Prong 2, Step 2B: This judicial exception is not integrated into a practical application. Mere recitation of generic computer components neither integrates the judicial exception into a practical application nor provides an inventive concept.
Claim 6.
Step 1: A method, as above.
Step 2A Prong 2, Step 2B: The claim recites that “wherein the input filter includes or excludes one or more of one or more rules of the rules engine, one or more field names of the plurality of input objects, and one or more input objects of the plurality of input objects.” involves the mere gathering of data, which is insignificant extra-solution activity. See MPEP § 2106.05(g). This judicial exception is not integrated into a practical application. Mere recitation of generic computer components neither integrates the judicial exception into a practical application nor provides an inventive concept.
Claim 7.
Step 1: A method, as above.
Step 2A Prong 1: The claim recites that “wherein creating the subset of the settable attributes based on the input filter comprises: creating a data structure comprising the settable attributes of each input object of the plurality of input objects and values corresponding to the settable attributes; and determining, based on the input filter, the subset of the settable attributes, the subset of the settable attributes including settable attributes in the data structure that meet criteria of the input filter”: This limitation merely specifies mental processes- concept of observation and evaluation of defining settable/gettable attributes.
Step 2A Prong 2, Step 2B: The claim recites that “obtaining the input filter.” involves the mere gathering of data, which is insignificant extra-solution activity. See MPEP § 2106.05(g). This judicial exception is not integrated into a practical application. Mere recitation of generic computer components neither integrates the judicial exception into a practical application nor provides an inventive concept.
Claim 8.
Step 1: A method, as above.
Step 2A Prong 1: The claim recites that “wherein the gettable attributes comprise one or more attributes of an output object of the plurality of output objects that are defined by a value that can be retrieved.”: This limitation merely specifies mental processes- concept of observation and evaluation of defining settable/gettable attributes.
Step 2A Prong 2, Step 2B: This judicial exception is not integrated into a practical application. Mere recitation of generic computer components neither integrates the judicial exception into a practical application nor provides an inventive concept.
Claim 9.
Step 1: A method, as above.
Step 2A Prong 1: The claim recites that “wherein determining, during the execution of the rules engine, the plurality of output objects created during the execution of the rules engine and the gettable attributes of each output object of the plurality of output objects comprises: for each output object of the plurality of output objects: identifying attributes of the output object that are defined by a value that can be retrieved or one or more sub-objects of the output object; and
for each sub-object of the one or more sub-objects of the output object: identifying attributes of the sub-object that are defined by a value that can be retrieved”: This limitation merely specifies mental processes- concept of observation and evaluation of defining settable/gettable attributes.
Step 2A Prong 2, Step 2B: This judicial exception is not integrated into a practical application. Mere recitation of generic computer components neither integrates the judicial exception into a practical application nor provides an inventive concept.
Claim 10.
Step 1: A method, as above.
Step 2A Prong 1: The claim recites that “wherein identifying the attributes of the output object comprises identifying values of the output object created, modified, or deleted during the execution of the rules engine, and identifying the attributes of the sub-object comprises identifying values of the sub-object created, modified, or deleted during the execution of the rules engine.”: This limitation merely specifies mental processes- concept of observation and evaluation of identifying/modifying attributes.
Step 2A Prong 2, Step 2B: This judicial exception is not integrated into a practical application. Mere recitation of generic computer components neither integrates the judicial exception into a practical application nor provides an inventive concept.
Claim 11.
Step 1: A method, as above.
Step 2A Prong 2, Step 2B: The claim recites that “during the execution of the rules engine: storing, in the memory of the computing device, each output object of the plurality of output objects prior to completion of the execution of the rules engine.” involves the mere gathering of data, which is insignificant extra-solution activity. See MPEP § 2106.05(g). This judicial exception is not integrated into a practical application. Mere recitation of generic computer components neither integrates the judicial exception into a practical application nor provides an inventive concept.
Claim 12.
Step 1: A method, as above.
Step 2A Prong 2, Step 2B: The claim recites that “wherein the output filter includes or excludes one or more of one or more rules of the rules engine, one or more field names of the plurality of output objects, and one or more output objects of the plurality of output objects.” involves the mere gathering of data, which is insignificant extra-solution activity. See MPEP § 2106.05(g). This judicial exception is not integrated into a practical application. Mere recitation of generic computer components neither integrates the judicial exception into a practical application nor provides an inventive concept.
Claim 13.
Step 1: A method, as above.
Step 2A Prong 1: The claim recites that “wherein creating the subset of the gettable attributes based on the output filter comprises: creating a data structure comprising the gettable attributes of each output object of the plurality of output objects, values corresponding to the gettable attributes, and rules corresponding to the gettable attributes; and determining, based on the output filter, the subset of gettable attributes, the subset of gettable attributes including gettable attributes in the data structure that meet criteria of the output filter.”: This limitation merely specifies mental processes- concept of observation and evaluation of defining settable/gettable attributes.
Step 2A Prong 2, Step 2B: The claim recites that “obtaining the output filter.” involves the mere gathering of data, which is insignificant extra-solution activity. See MPEP § 2106.05(g). This judicial exception is not integrated into a practical application. Mere recitation of generic computer components neither integrates the judicial exception into a practical application nor provides an inventive concept.
Claim 14.
Step 1: A method, as above.
Step 2A Prong 1: The claim recites that “determining a first set of values for each output object of the plurality of output objects prior to an execution of a rule of the rules engine; and determining a second set of values for each output object of the plurality of output objects subsequent to the execution of the rule of the rules engine.”: This limitation merely specifies mental processes- concept of observation and evaluation of identifying/modifying attributes.
Step 2A Prong 2, Step 2B: This judicial exception is not integrated into a practical application. Mere recitation of generic computer components neither integrates the judicial exception into a practical application nor provides an inventive concept.
Claim 15.
Step 1: A method, as above.
Step 2A Prong 1: The claim recites that “subsequent to the execution of the rule engine, determining a difference between a first value from among the first set of values and a second value from among the second set of values, wherein the first value and the second value correspond to an output object of the plurality of output objects; and identifying the difference as an output of the execution of the rule engine.”: This limitation merely specifies mental processes- concept of observation and evaluation of identifying/modifying attributes.
Step 2A Prong 2, Step 2B: This judicial exception is not integrated into a practical application. Mere recitation of generic computer components neither integrates the judicial exception into a practical application nor provides an inventive concept.
Claim 16.
Step 1: A method, as above.
Step 2A Prong 2, Step 2B: The claim recites that “wherein storing, in the memory of the computing device, one or more rules and corresponding gettable attributes and values of the gettable attributes based on the subset of the gettable attributes comprises: creating a data structure comprising one or more rules, each rule corresponding to a gettable attribute from among the subset of the gettable attributes and a value of the gettable attribute, wherein the data structure comprises a table, a graph, or a map.” involves the mere gathering of data, which is insignificant extra-solution activity. See MPEP § 2106.05(g). This judicial exception is not integrated into a practical application. Mere recitation of generic computer components neither integrates the judicial exception into a practical application nor provides an inventive concept.
Claim 17.
Step 1: A method, as above.
Step 2A Prong 1: The claim recites that “subsequent to creating the subset of the gettable attributes based on the output filter, inserting the subset of the gettable attributes into the rules engine; determining, by a monitor in the rules engine during a second execution of the rules engine, whether a gettable attribute of the subset of gettable attributes is obtained; and recording a value of the gettable attribute as an output of the rules engine.”: This limitation merely specifies mental processes- concept of observation and evaluation of monitoring/analyzing data.
Step 2A Prong 2, Step 2B: This judicial exception is not integrated into a practical application. Mere recitation of generic computer components neither integrates the judicial exception into a practical application nor provides an inventive concept.
Claims 18-19
Step 1: The claims recite a computing device, comprising: a memory; and a processor device coupled to the memory; therefore, they fall into the statutory category of machines.
Step 2A Prong 1: The claims 18-19 recite the same mental processes as claims 1-2, respectively.
Step 2A Prong 2: This judicial exception is not integrated into a practical application. Claims 18-19 recite generic computer components, namely “computing device, comprising: a memory; and a processor device coupled to the memory”. As before, the mere recitation that the method is to be performed on a generic computer amounts to a mere instruction to apply the exception on the computer. See MPEP § 2106.05(f). With that exception, the analysis mirrors that of claims 1-2, respectively.
Step 2B: The claim does not include additional elements that are sufficient to amount to significantly more than the judicial exception. The analysis, with the one exception noted above, mirrors that of claims 1-2, respectively.
Claim 20
Step 1: The claims recite a non-transitory computer-readable storage medium; therefore, they fall into the statutory category of machines.
Step 2A Prong 1: The claim 20 recite the same mental processes as claim 1.
Step 2A Prong 2: This judicial exception is not integrated into a practical application. Claim 20 recite generic computer components, namely “non-transitory computer-readable storage medium that includes computer-executable instructions that, when executed, cause one or more processor devices”. As before, the mere recitation that the method is to be performed on a generic computer amounts to a mere instruction to apply the exception on the computer. See MPEP § 2106.05(f). With that exception, the analysis mirrors that of claim 1.
Step 2B: The claim does not include additional elements that are sufficient to amount to significantly more than the judicial exception. The analysis, with the one exception noted above, mirrors that of claim 1.
Claim Rejections - 35 USC § 103
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.
Claim(s) 1-20 is/are rejected under 35 U.S.C. 103 as being unpatentable over Geada et al. (“TrustyAI Explainability Toolkit”, May 26, 2022) in view of Buckley et al. (US 20170063874 A1).
Regarding claim 1.
Geada teaches a method, comprising: obtaining, by a computing device, a plurality of input objects (see end of page 2 going into page 3, “A typical input for a decision service for credit scoring might involve huge lists of transactions and/or user profiles that are a composition of multiple different features, possibly nested.”);
determining, by the computing device, see page 15, “Actionability refers to the ability to separate between mutable and immutable features in our input x.”);
creating, by the computing device, a subset of the see page 15, “Actionability refers to the ability to separate between mutable and immutable features in our input x. Due to legal requirements and fairness reasons, we might want to explore the feature space only regarding a specific subset of attributes A.”);
inserting, by the computing device, the subset of the see page 15, “Actionability refers to the ability to separate between mutable and immutable features in our input x. Due to legal requirements and fairness reasons, we might want to explore the feature space only regarding a specific subset of attributes A.”, also see page 1, “Decision services can work on fine-grained inputs, like assessing the risk of a single transaction, or on rather complex inputs (often hierarchical), commonly involving sub-decisions to be taken and composed into a final decision. Typical examples of decision services are credit scoring systems. Such systems can leverage different kinds of predictive models underneath, from rule-based systems to decision trees [11] or machine-learning based approaches”, also see page 2, “In this paper, we present the TrustyAI Explainability Toolkit, an open source XAI Java2 and Python3 library leveraging different explainability techniques for explaining decision services (e.g. based on business rules or open standards like DMN45) as well as AI-based systems in a black-box fashion. TrustyAI6 is currently part of the Kogito ecosystem7 that aims to offer value-added services to a Business Automation solution.”, i.e. selecting mutable/immutable input features such as subset of attributes A, and provide those features as input into rule-based decision service),
the rules engine comprising a set of rules evaluated with an input and producing an output during an execution of the rules engine (see page 15, “if we have a set of features x resulting in an outcome y = f(x), where f(·) is the model’s predictive function, a counterfactual explanation will provide us with an alternative set of input features x, as close as possible to x, which results in a desired outcome y = f(x). The counterfactual method is well-suited for black-box model scenarios as it only requires access to the predictive function f(·).”, i.e. outcome y);
determining, by the computing device during an execution of the rules engine, a plurality of output objects created during the execution of the rules engine and see end of page 18 going into page 10, “Infidelity: Infidelity defines a perturbation of the input data, for example, by replacing a feature value with random noise, creating some perturbation ∆x=x−x perturbed. Infidelity then computes: E[((∆x)Tw −(f(x)−f(x perturbed)))2], that is, the mean square difference between(∆x)Tw, the product of the feature attributions and the perturbation, and f(x)−f(x perturbed), the difference in model output between the original and perturbed input. In essence, this measure show much multiplying the attributions by the vector of perturbation magnitudes reflects an equivalent perturbation of the input data”, also see page 3, “SHAP provides more advanced explanations, as it produces an itemized break down of the exact contributions of the various factors involved in a decision. The explanations require more understanding of the individual components within the decision, and thus are more suited towards internal use-cases, such as model validation and decision service auditing. Finally, counterfactual explanations provide descriptions of how to change one’s interaction with a decision service to alter the outcome towards some desirable result. This makes them well-suited to educate users on how best to interact with the decision services and guiding them towards desirable results. In summary, LIME answers the question “what affected the decision?”, SHAP answers “by how much?”, and counterfactuals answer “what could be done differently next time?””, also see page 10, “The final result of the algorithm are the Shapley values of each feature, which give an itemized “receipt” of all the contributing factors to the decision. For example, a SHAP explanation of a loan application might be as follows…From this, the applicant can see that the biggest contributor to their denial was their home ownership status, which reduced their acceptance probability by 30 percentage points. Meanwhile, their number of children was of particular benefit, increasing their probability by 22 percentage points.”);
creating, by the computing device, a subset of the see page 8, “Following suggestion from [28], we directly generate samples close to the original prediction, as opposed to the sample and weighting approach from the original LIME paper. We adopt πx to determine which samples should be taken and which ones should be discarded and not used for the linear model fitting. More formally, given a set of generated samples S, the filtered dataset ˆS is ˆ S ={s|πx(s) ≥ κ,∀s ∈ S} In our experiments, we set κ = 0.8.”);
and see page 10, “The final result of the algorithm are the Shapley values of each feature, which give an itemized “receipt” of all the contributing factors to the decision. For example, a SHAP explanation of a loan application... Table 1: Example SHAP values of a loan application.”, also see page 3, “SHAP provides more advanced explanations, as it produces an itemized break down of the exact contributions of the various factors involved in a decision.”).
Geada do not specifically teach determining settable attributes; determining gettable attributes and storing, in a memory of the computing device, one or more rules.
Buckley teaches determining settable attributes; determining gettable attributes (see ¶ 85, “an operation includes getting or setting a value of a module element where (a) the module element represents a field, (b) the getting or setting is performed with respect to an object, and (c) the object is an instance of another module element (e.g., a class which includes the field). An example set of operations include, but are not limited to: [0086] (a) getField(String name): Returns a Field object that reflects the specified field of the class or interface represented by the Class object upon which the command is executed. [0087] (b) getFields( ): Returns an array containing Field objects reflecting all the fields of the class or interface represented by the Class object upon which the command is executed.”) and storing, in a memory of the computing device, one or more rules (see ¶ 48, “the ClassName may indicate where the file is stored in the package, library, or file system hosting the class file 200.”, also see ¶ 45, “the field structures 208 represent a set of structures that identifies the various fields of the class. The field structures 208 store, for each field of the class, accessor flags for the field (whether the field is static, public, non-public, final, etc.), an index into the constant table 201 to one of the value structures 202 that holds the name of the field, and an index into the constant table 201 to one of the value structures 202 that holds a descriptor of the field.”).
Both Geada and Buckley pertain to the problem of permissive access control, thus being analogous. It would have been obvious to one skilled in the art before the effective filing date of the claimed invention to combine Geada and Buckley to teach the above limitations. The motivation for doing so would be “one or more operations require access to a module element of a provider module by a consumer module. One or more embodiments include controlling access to the module element of the provider module by the consumer module. Controlling access includes allowing access or prohibiting access. If access to the module element of the provider module by the consumer module is allowed, then the operation is successfully compiled or executed. If the access to the module element of the provider module by the consumer module is prohibited, then the operation may not successfully compile and/or may not successfully execute. Factors, as described herein, for controlling access to a particular type of module element may be applicable for controlling access to another type of module element… access controls applicable to a module element (e.g., class 406) may determine whether an operation that accesses an object, created by instantiating the module element, is allowed or prohibited. In an example, access to obtain or modify a value of field of an object is allowed or prohibited based on access controls for the particular class which is instantiated to create the object.” (see Buckley ¶¶96-98).
Regarding claim 2.
Geada and Buckley teaches the method of claim 1,
Geada further teaches further comprising: subsequent to storing, in the memory of the computing device, one or more rules and corresponding gettable attributes and values of the see page 1, abstract, “the TrustyAI Explainability Toolkit, a Java and Python library that provides XAI explanations of decision services and predictive models for both enterprise and data science use-cases. We de scribe the TrustyAI implementations and extensions to techniques such as LIME, SHAP and counterfactuals”, also see page 9, “Each of the attributes place constraints on the possible choices of φ such as to maintain the logical integrity of the explanations.”).
Buckley teaches settable attributes; and gettable attributes (see ¶ 85, “an operation includes getting or setting a value of a module element where (a) the module element represents a field, (b) the getting or setting is performed with respect to an object, and (c) the object is an instance of another module element (e.g., a class which includes the field). An example set of operations include, but are not limited to: [0086] (a) getField(String name): Returns a Field object that reflects the specified field of the class or interface represented by the Class object upon which the command is executed. [0087] (b) getFields( ): Returns an array containing Field objects reflecting all the fields of the class or interface represented by the Class object upon which the command is executed.”)
The motivation utilized in the combination of claim 1, super, applies equally as well to claim 2.
Regarding claim 3.
Geada and Buckley teaches the method of claim 1,
Buckley further teaches wherein the settable attributes comprise one or more attributes of an input object of the plurality of input objects that can be set with a value (see ¶ 85, “an operation includes getting or setting a value of a module element where (a) the module element represents a field, (b) the getting or setting is performed with respect to an object, and (c) the object is an instance of another module element (e.g., a class which includes the field). An example set of operations include, but are not limited to: [0086] (a) getField(String name): Returns a Field object that reflects the specified field of the class or interface represented by the Class object upon which the command is executed. [0087] (b) getFields( ): Returns an array containing Field objects reflecting all the fields of the class or interface represented by the Class object upon which the command is executed.”)
The motivation utilized in the combination of claim 1, super, applies equally as well to claim 3.
Regarding claim 4.
Geada and Buckley teaches the method of claim 1,
Geada further teaches wherein determining the settable attributes of each input object of the plurality of input objects comprises: for each input object of the plurality of input objects: identifying attributes of the input object that can be set with a value or one or more sub-objects of the input object; and for each sub-object of the one or more sub-objects of the input object: identifying attributes of the sub-object that can be set with a value (see end of page 2 going into page 3, “Many XAI techniques developed for AI/ML models assume inputs are composed of flat categorical, numerical, binary or textual features only. However, decision services often rely on inputs that are both nested and more complex in terms of feature types (e.g., URLs, currencies, etc.). A typical input for a decision service for credit scoring might involve huge lists of transactions and/or user profiles that are a composition of multiple different features, possibly nested…we present the TrustyAI Explainability Toolkit, an open source XAI Java2 and Python3 library leveraging different explainability techniques for explaining decision services (e.g. based on business rules or open standards like DMN)”).
Buckley teaches settable attributes; and gettable attributes (see ¶ 85, “an operation includes getting or setting a value of a module element where (a) the module element represents a field, (b) the getting or setting is performed with respect to an object, and (c) the object is an instance of another module element (e.g., a class which includes the field). An example set of operations include, but are not limited to: [0086] (a) getField(String name): Returns a Field object that reflects the specified field of the class or interface represented by the Class object upon which the command is executed. [0087] (b) getFields( ): Returns an array containing Field objects reflecting all the fields of the class or interface represented by the Class object upon which the command is executed.”)
The motivation utilized in the combination of claim 1, super, applies equally as well to claim 4.
Regarding claim 5.
Geada and Buckley teaches the method of claim 1,
Geada further teaches further comprising: subsequent to determining the settable attributes of each input object of the plurality of input objects, overwriting one or more of the settable attributes (see page 2, “Counterfactual explanations [5, 57] help users understanding the behavior of a black box system by generating modified copies of the original input that the system predicts with a different (desired) outcome.”).
Buckley teaches settable attributes (see ¶ 85, “an operation includes getting or setting a value of a module element where (a) the module element represents a field, (b) the getting or setting is performed with respect to an object, and (c) the object is an instance of another module element (e.g., a class which includes the field). An example set of operations include, but are not limited to: [0086] (a) getField(String name): Returns a Field object that reflects the specified field of the class or interface represented by the Class object upon which the command is executed. [0087] (b) getFields( ): Returns an array containing Field objects reflecting all the fields of the class or interface represented by the Class object upon which the command is executed.”)
The motivation utilized in the combination of claim 1, super, applies equally as well to claim 5.
Regarding claim 6.
Geada and Buckley teaches the method of claim 1,
Geada further teaches wherein the input filter includes or excludes one or more of one or more rules of the rules engine, one or more field names of the plurality of input objects, and one or more input objects of the plurality of input objects (see page 11, “To demonstrate the interpretability issue that background dataset choice can create, Shapley values will first be computed using the background dataset B = [[0,0,0,0]]. This will mean that feature exclusion will be simulated by replacing that feature value with 0, which indeed accurately models feature exclusion in a linear model.”, also page 15, “Due to legal requirements and fairness reasons, we might want to explore the feature space only regarding a specific subset of attributes A. We can formally express validity…”, also see page 8, “Following suggestion from [28], we directly generate samples close to the original prediction, as opposed to the sample and weighting approach from the original LIME paper. We adopt πx to determine which samples should be taken and which ones should be discarded and not used for the linear model fitting. More formally, given a set of generated samples S, the filtered dataset ˆS is ˆ S ={s|πx(s) ≥ κ,∀s ∈ S} In our experiments, we set κ = 0.8.”).
Regarding claim 7.
Geada and Buckley teaches the method of claim 1,
Geada further teaches wherein creating the subset of the see page 5 going into page 6, “LIME converts samples xi from the original domain into interpretable samples as binary vectors xi ∈ {0,1}. An encoded dataset E is built by taking non-zero elements of xi, recovering the original representation z ∈ Rd and then computing f(z).”, also see page 8, “Following suggestion from [28], we directly generate samples close to the original prediction, as opposed to the sample and weighting approach from the original LIME paper. We adopt πx to determine which samples should be taken and which ones should be discarded and not used for the linear model fitting. More formally, given a set of generated samples S, the filtered dataset ˆS is ˆ S ={s|πx(s) ≥ κ,∀s ∈ S} In our experiments, we set κ = 0.8.”).
Buckley teaches settable attributes (see ¶ 85, “an operation includes getting or setting a value of a module element where (a) the module element represents a field, (b) the getting or setting is performed with respect to an object, and (c) the object is an instance of another module element (e.g., a class which includes the field). An example set of operations include, but are not limited to: [0086] (a) getField(String name): Returns a Field object that reflects the specified field of the class or interface represented by the Class object upon which the command is executed. [0087] (b) getFields( ): Returns an array containing Field objects reflecting all the fields of the class or interface represented by the Class object upon which the command is executed.”)
The motivation utilized in the combination of claim 1, super, applies equally as well to claim 7.
Regarding claim 8.
Geada and Buckley teaches the method of claim 1,
Buckley further teaches wherein the gettable attributes comprise one or more attributes of an output object of the plurality of output objects that are defined by a value that can be retrieved (see ¶ 85, “an operation includes getting or setting a value of a module element where (a) the module element represents a field, (b) the getting or setting is performed with respect to an object, and (c) the object is an instance of another module element (e.g., a class which includes the field). An example set of operations include, but are not limited to: [0086] (a) getField(String name): Returns a Field object that reflects the specified field of the class or interface represented by the Class object upon which the command is executed. [0087] (b) getFields( ): Returns an array containing Field objects reflecting all the fields of the class or interface represented by the Class object upon which the command is executed.”)
The motivation utilized in the combination of claim 1, super, applies equally as well to claim 8.
Regarding claim 9.
Geada and Buckley teaches the method of claim 1,
Geada further teaches wherein determining, during the execution of the rules engine, the plurality of output objects created during the execution of the rules engine and the see end of page 2 going into page 3, “Many XAI techniques developed for AI/ML models assume inputs are composed of flat categorical, numerical, binary or textual features only. However, decision services often rely on inputs that are both nested and more complex in terms of feature types (e.g., URLs, currencies, etc.). A typical input for a decision service for credit scoring might involve huge lists of transactions and/or user profiles that are a composition of multiple different features, possibly nested…we present the TrustyAI Explainability Toolkit, an open source XAI Java2 and Python3 library leveraging different explainability techniques for explaining decision services (e.g. based on business rules or open standards like DMN)”).
Buckley teaches settable attributes; and gettable attributes (see ¶ 85, “an operation includes getting or setting a value of a module element where (a) the module element represents a field, (b) the getting or setting is performed with respect to an object, and (c) the object is an instance of another module element (e.g., a class which includes the field). An example set of operations include, but are not limited to: [0086] (a) getField(String name): Returns a Field object that reflects the specified field of the class or interface represented by the Class object upon which the command is executed. [0087] (b) getFields( ): Returns an array containing Field objects reflecting all the fields of the class or interface represented by the Class object upon which the command is executed.”)
The motivation utilized in the combination of claim 1, super, applies equally as well to claim 9.
Regarding claim 10.
Geada and Buckley teaches the method of claim 9,
Geada further teaches wherein identifying the attributes of the output object comprises identifying values of the output object created, modified, or deleted during the execution of the rules engine, and identifying the attributes of the sub-object comprises identifying values of the sub-object created, modified, or deleted during the execution of the rules engine (see end of page 18 going into page 10, “Infidelity: Infidelity defines a perturbation of the input data, for example, by replacing a feature value with random noise, creating some perturbation ∆x=x−x perturbed. Infidelity then computes: E[((∆x)Tw −(f(x)−f(x perturbed)))2], that is, the mean square difference between(∆x)Tw, the product of the feature attributions and the perturbation, and f(x)−f(x perturbed), the difference in model output between the original and perturbed input. In essence, this measure show much multiplying the attributions by the vector of perturbation magnitudes reflects an equivalent perturbation of the input data”, also see page 3, “SHAP provides more advanced explanations, as it produces an itemized break down of the exact contributions of the various factors involved in a decision. The explanations require more understanding of the individual components within the decision, and thus are more suited towards internal use-cases, such as model validation and decision service auditing. Finally, counterfactual explanations provide descriptions of how to change one’s interaction with a decision service to alter the outcome towards some desirable result. This makes them well-suited to educate users on how best to interact with the decision services and guiding them towards desirable results. In summary, LIME answers the question “what affected the decision?”, SHAP answers “by how much?”, and counterfactuals answer “what could be done differently next time?””, also see page 10, “The final result of the algorithm are the Shapley values of each feature, which give an itemized “receipt” of all the contributing factors to the decision. For example, a SHAP explanation of a loan application might be as follows…From this, the applicant can see that the biggest contributor to their denial was their home ownership status, which reduced their acceptance probability by 30 percentage points. Meanwhile, their number of children was of particular benefit, increasing their probability by 22 percentage points.”).
Buckley teaches field modification (see ¶ 85, “an operation includes getting or setting a value of a module element where (a) the module element represents a field, (b) the getting or setting is performed with respect to an object, and (c) the object is an instance of another module element (e.g., a class which includes the field). An example set of operations include, but are not limited to: [0086] (a) getField(String name): Returns a Field object that reflects the specified field of the class or interface represented by the Class object upon which the command is executed. [0087] (b) getFields( ): Returns an array containing Field objects reflecting all the fields of the class or interface represented by the Class object upon which the command is executed.”)
The motivation utilized in the combination of claim 1, super, applies equally as well to claim 10.
Regarding claim 11.
Geada and Buckley teaches the method of claim 1,
Geada further teaches further comprising: during the execution of the rules engine: storing, in the memory of the computing device, each output object of the plurality of output objects prior to completion of the execution of the rules engine (see page 12, “Choosing a subset of the training data is necessary due to the nature of Kernel SHAP’s synthetic data generation, where a synthetic datapoint is generated for each background datapoint for each desired feature coalition sample. All of these synthetic datapoints then have to be passed through the model.”).
Regarding claim 12.
Geada and Buckley teaches the method of claim 1,
Geada further teaches wherein the output filter includes or excludes one or more of one or more rules of the rules engine, one or more field names of the plurality of output objects, and one or more output objects of the plurality of output objects (see page 11, “To demonstrate the interpretability issue that background dataset choice can create, Shapley values will first be computed using the background dataset B = [[0,0,0,0]]. This will mean that feature exclusion will be simulated by replacing that feature value with 0, which indeed accurately models feature exclusion in a linear model.”, also page 15, “Due to legal requirements and fairness reasons, we might want to explore the feature space only regarding a specific subset of attributes A. We can formally express validity…”, also see page 8, “Following suggestion from [28], we directly generate samples close to the original prediction, as opposed to the sample and weighting approach from the original LIME paper. We adopt πx to determine which samples should be taken and which ones should be discarded and not used for the linear model fitting. More formally, given a set of generated samples S, the filtered dataset ˆS is ˆ S ={s|πx(s) ≥ κ,∀s ∈ S} In our experiments, we set κ = 0.8.”).
Regarding claim 13.
Geada and Buckley teaches the method of claim 1,
Geada further teaches wherein creating the subset of the gettable attributes based on the output filter comprises: creating a data structure comprising the gettable attributes of each output object of the plurality of output objects, values corresponding to the gettable attributes, and rules corresponding to the gettable attributes; obtaining the output filter; and determining, based on the output filter, the subset of gettable attributes, the subset of gettable attributes including gettable attributes in the data structure that meet criteria of the output filter (see page 8, “Following suggestion from [28], we directly generate samples close to the original prediction, as opposed to the sample and weighting approach from the original LIME paper. We adopt πx to determine which samples should be taken and which ones should be discarded and not used for the linear model fitting. More formally, given a set of generated samples S, the filtered dataset ˆS is ˆ S ={s|πx(s) ≥ κ,∀s ∈ S} In our experiments, we set κ = 0.8.”, also see page 10, “The final result of the algorithm are the Shapley values of each feature, which give an itemized “receipt” of all the contributing factors to the decision. For example, a SHAP explanation of a loan application might be as follows…From this, the applicant can see that the biggest contributor to their denial was their home ownership status, which reduced their acceptance probability by 30 percentage points. Meanwhile, their number of children was of particular benefit, increasing their probability by 22 percentage points.”).
Buckley teaches gettable attributes (see ¶ 85, “an operation includes getting or setting a value of a module element where (a) the module element represents a field, (b) the getting or setting is performed with respect to an object, and (c) the object is an instance of another module element (e.g., a class which includes the field). An example set of operations include, but are not limited to: [0086] (a) getField(String name): Returns a Field object that reflects the specified field of the class or interface represented by the Class object upon which the command is executed. [0087] (b) getFields( ): Returns an array containing Field objects reflecting all the fields of the class or interface represented by the Class object upon which the command is executed.”)
The motivation utilized in the combination of claim 1, super, applies equally as well to claim 13.
Regarding claim 14.
Geada and Buckley teaches the method of claim 1,
Geada further teaches further comprising: during the execution of the rules engine: determining a first set of values for each output object of the plurality of output objects prior to an execution of a rule of the rules engine; and determining a second set of values for each output object of the plurality of output objects subsequent to the execution of the rule of the rules engine (see end of page 18 going into page 10, “Infidelity: Infidelity defines a perturbation of the input data, for example, by replacing a feature value with random noise, creating some perturbation ∆x=x−x perturbed. Infidelity then computes: E[((∆x)Tw −(f(x)−f(x perturbed)))2], that is, the mean square difference between(∆x)Tw, the product of the feature attributions and the perturbation, and f(x)−f(x perturbed), the difference in model output between the original and perturbed input. In essence, this measure show much multiplying the attributions by the vector of perturbation magnitudes reflects an equivalent perturbation of the input data”, also see page 3, “SHAP provides more advanced explanations, as it produces an itemized break down of the exact contributions of the various factors involved in a decision. The explanations require more understanding of the individual components within the decision, and thus are more suited towards internal use-cases, such as model validation and decision service auditing. Finally, counterfactual explanations provide descriptions of how to change one’s interaction with a decision service to alter the outcome towards some desirable result. This makes them well-suited to educate users on how best to interact with the decision services and guiding them towards desirable results. In summary, LIME answers the question “what affected the decision?”, SHAP answers “by how much?”, and counterfactuals answer “what could be done differently next time?””, also see page 10, “The final result of the algorithm are the Shapley values of each feature, which give an itemized “receipt” of all the contributing factors to the decision. For example, a SHAP explanation of a loan application might be as follows…From this, the applicant can see that the biggest contributor to their denial was their home ownership status, which reduced their acceptance probability by 30 percentage points. Meanwhile, their number of children was of particular benefit, increasing their probability by 22 percentage points.”).
Buckley teaches field modification (see ¶ 85, “an operation includes getting or setting a value of a module element where (a) the module element represents a field, (b) the getting or setting is performed with respect to an object, and (c) the object is an instance of another module element (e.g., a class which includes the field). An example set of operations include, but are not limited to: [0086] (a) getField(String name): Returns a Field object that reflects the specified field of the class or interface represented by the Class object upon which the command is executed. [0087] (b) getFields( ): Returns an array containing Field objects reflecting all the fields of the class or interface represented by the Class object upon which the command is executed.”)
The motivation utilized in the combination of claim 1, super, applies equally as well to claim 14.
Regarding claim 15.
Geada and Buckley teaches the method of claim 14,
Geada further teaches further comprising: subsequent to the execution of the rule engine, determining a difference between a first value from among the first set of values and a second value from among the second set of values, wherein the first value and the second value correspond to an output object of the plurality of output objects; and identifying the difference as an output of the execution of the rule engine (see end of page 18 going into page 10, “Infidelity: Infidelity defines a perturbation of the input data, for example, by replacing a feature value with random noise, creating some perturbation ∆x=x−x perturbed. Infidelity then computes: E[((∆x)Tw −(f(x)−f(x perturbed)))2], that is, the mean square difference between(∆x)Tw, the product of the feature attributions and the perturbation, and f(x)−f(x perturbed), the difference in model output between the original and perturbed input. In essence, this measure show much multiplying the attributions by the vector of perturbation magnitudes reflects an equivalent perturbation of the input data”, also see page 3, “SHAP provides more advanced explanations, as it produces an itemized break down of the exact contributions of the various factors involved in a decision. The explanations require more understanding of the individual components within the decision, and thus are more suited towards internal use-cases, such as model validation and decision service auditing. Finally, counterfactual explanations provide descriptions of how to change one’s interaction with a decision service to alter the outcome towards some desirable result. This makes them well-suited to educate users on how best to interact with the decision services and guiding them towards desirable results. In summary, LIME answers the question “what affected the decision?”, SHAP answers “by how much?”, and counterfactuals answer “what could be done differently next time?””, also see page 10, “The final result of the algorithm are the Shapley values of each feature, which give an itemized “receipt” of all the contributing factors to the decision. For example, a SHAP explanation of a loan application might be as follows…From this, the applicant can see that the biggest contributor to their denial was their home ownership status, which reduced their acceptance probability by 30 percentage points. Meanwhile, their number of children was of particular benefit, increasing their probability by 22 percentage points.”).
Regarding claim 16.
Geada and Buckley teaches the method of claim 1,
Geada further teaches wherein storing, in the memory of the computing device, one or more rules and corresponding gettable attributes and values of the gettable attributes based on the subset of the gettable attributes comprises: creating a data structure comprising one or more rules, each rule corresponding to a gettable attribute from among the subset of the gettable attributes and a value of the gettable attribute, wherein the data structure comprises a table, a graph, or a map (see page 3, “SHAP provides more advanced explanations, as it produces an itemized break down of the exact contributions of the various factors involved in a decision. The explanations require more understanding of the individual components within the decision, and thus are more suited towards internal use-cases, such as model validation and decision service auditing. Finally, counterfactual explanations provide descriptions of how to change one’s interaction with a decision service to alter the outcome towards some desirable result. This makes them well-suited to educate users on how best to interact with the decision services and guiding them towards desirable results. In summary, LIME answers the question “what affected the decision?”, SHAP answers “by how much?”, and counterfactuals answer “what could be done differently next time?””, also see page 10, “The final result of the algorithm are the Shapley values of each feature, which give an itemized “receipt” of all the contributing factors to the decision. For example, a SHAP explanation of a loan application might be as follows…From this, the applicant can see that the biggest contributor to their denial was their home ownership status, which reduced their acceptance probability by 30 percentage points. Meanwhile, their number of children was of particular benefit, increasing their probability by 22 percentage points.”).
Regarding claim 17.
Geada and Buckley teaches the method of claim 1,
Geada further teaches further comprising: subsequent to creating the subset of the gettable attributes based on the output filter, inserting the subset of the gettable attributes into the rules engine; determining, by a monitor in the rules engine during a second execution of the rules engine, whether a gettable attribute of the subset of gettable attributes is obtained; and recording a value of the gettable attribute as an output of the rules engine (see page 12, “Choosing a subset of the training data is necessary due to the nature of Kernel SHAP’s synthetic data generation, where a synthetic datapoint is generated for each background datapoint for each desired feature coalition sample. All of these synthetic datapoints then have to be passed through the model.”, also see pages 29-30, iterative evaluations).
Buckley teaches gettable attributes (see ¶ 85, “an operation includes getting or setting a value of a module element where (a) the module element represents a field, (b) the getting or setting is performed with respect to an object, and (c) the object is an instance of another module element (e.g., a class which includes the field). An example set of operations include, but are not limited to: [0086] (a) getField(String name): Returns a Field object that reflects the specified field of the class or interface represented by the Class object upon which the command is executed. [0087] (b) getFields( ): Returns an array containing Field objects reflecting all the fields of the class or interface represented by the Class object upon which the command is executed.”)
The motivation utilized in the combination of claim 1, super, applies equally as well to claim 17.
Claims 18-19 recites a device, comprising: a memory; and a processor device coupled to the memory to perform the method recited in claims 1-2. Therefore the rejection of claims 1-2 above applies equally here. Buckley also teaches the addition elements of claim 18 not recited in claim 1 comprising a memory; and a processor device (see ¶ 116, “a main memory 606, such as a random access memory (RAM) or other dynamic storage device, coupled to bus 602 for storing information and instructions to be executed by processor 604.”).
Claim 20 recites a non-transitory computer-readable storage medium that includes computer-executable instructions that, when executed, cause one or more processor devices to perform the method recited in claim 1. Therefore the rejection of claim 1 above applies equally here. Buckley also teaches the addition elements of claim 20 not recited in claim 1 non-transitory computer-readable storage medium that includes computer-executable instructions that, when executed, cause one or more processor devices (see ¶ 116, “Main memory 606 also may be used for storing temporary variables or other intermediate information during execution of instructions to be executed by processor 604. Such instructions, when stored in non-transitory storage media accessible to processor 604, render computer system 600 into a special-purpose machine that is customized to perform the operations specified in the instructions.”).
Related prior arts:
Foxell et al. (US 20210042365 A1) teaches a graphical user interface (GUI) to enable setting a first ordering of the plurality of attributes, receive a candidate query; and based on the ordering of the plurality of attributes, automatically determine and output a best match among a set of all classification rules that are satisfied by the candidate query.
Lue-Sang et al. (US 7954110 B1) teaches a message may be sent to an object without the knowledge of a name of a method in the object's class 215 before getting and setting the values of the attributes in that object. The key-value coding module 200 comprises a value for key method and a set value for key method. The value for key method takes one argument and the key is a string. The string is the key of the property whose value is desired. In this way, properties of an object may be extracted without knowing how the object's class 215 implements the property getting and setting.
GRECHANIK et al. (US 20110016453 A1) teaches classes are linked to GUI objects and contain methods for locating the objects 174 in the GAP, setting and getting their values, and performing actions on them 126. When a GAP starts, the operating system assigns a positive integer number to each window (GUI object), which is the order number in which a GUI object takes focus when tabbing through the GUI.
Conclusion
Any inquiry concerning this communication or earlier communications from the examiner should be directed to IMAD M KASSIM whose telephone number is (571)272-2958. The examiner can normally be reached 10:30AM-5:30PM, M-F (E.S.T.).
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, Michael J. Huntley can be reached at (303) 297 - 4307. 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.
/IMAD KASSIM/Primary Examiner, Art Unit 2129
Prosecution Insights