Computer implementation methods, systems, and computer programs (stable, locally interpretable models for prediction)

Abstract

To solve the problem that conventional methods for understanding the predictions of classifiers cannot provide calculation or presentation of confidence in the results of such methods and cannot provide an appropriate kernel width selection for determining appropriate weights of records for building local models.SOLUTION: Examples described in this specification provide a computer-implemented method that includes determining a kernel width for the machine learning model. The method further includes building a local interpretable linear model using the kernel width. The method further includes computing a contribution and confidence for a feature of the local interpretable linear model. The method further includes updating the local interpretable linear model to generate a final model and computing an overall confidence for the final model.SELECTED DRAWING: Figure 3

Description

[Technical Field]

[0001] The embodiments described herein relate generally to machine learning, and more specifically to stable, locally interpretable models for prediction. [Background technology]

[0002] The term "machine learning" broadly describes the function of electronic systems that learn from data. A machine learning system, engine, or module, or a combination thereof, may include a trainable machine learning algorithm that can be trained to learn functional relationships between inputs and currently unknown outputs, and the resulting machine learning model can be used to perform the task associated with the training (such as predicting outputs based on input data). Machine learning functions may be performed using artificial neural networks (ANNs) that have the ability to be trained to perform currently unknown functions. In machine learning and cognitive science, ANNs are a lineage of statistical learning models inspired by biological neural networks in animals, particularly the brain. ANNs can be used to estimate or approximate systems and functions that depend on a large number of inputs. [Overview of the project] [Problems that the invention aims to solve]

[0003] Conventional methods for understanding classifier predictions cannot provide either the calculation or presentation of the confidence level of such methods, nor can they provide the selection of appropriate kernel widths to determine the appropriate weights of records for constructing local models. [Means for solving the problem]

[0004] In one exemplary embodiment, a computer implementation method is provided for a stable, locally interpretable model for prediction. This method includes the step of determining a kernel width for a machine learning model. This method further includes the step of constructing a locally interpretable linear model using the kernel width. This method further includes the step of calculating the contributions and confidence levels of the features of the locally interpretable linear model. This method further includes the step of updating the locally interpretable linear model to produce a final model and calculating the overall confidence level of the final model.

[0005] In addition to or as an alternative to one or more features described herein, further embodiments of this method may include the steps of: constructing a default local model using a default kernel width value; constructing a shifted local model having gradually increasing and gradually decreasing kernel widths until a stopping condition is reached; and selecting a final kernel width based at least partially on the default local model and the shifted local model. In addition to or as an alternative to one or more features described herein, further embodiments of this method may include the stopping condition being at least one of the maximum number of iterations, the convergence condition being met, or the accuracy meeting a threshold.

[0006] In addition to, or as an alternative to, one or more features described herein, further embodiments of the method may include a step of calculating the overall confidence of the final model, which is at least partially based on the contributions and confidence of the features of the locally interpretable linear model.

[0007] In addition to or as an alternative to one or more features described in this specification, further embodiments of this method may comprise the step of calculating an additional contribution and a confidence level for an additional feature of said locally interpretable linear model. In addition to or as an alternative to one or more features described in this specification, further embodiments of this method may comprise that the overall confidence level of said final model is calculated using said additional contribution and said confidence level of said additional feature.

[0008] In another exemplary embodiment, a method of determining a kernel width for a machine learning model comprises the step of constructing a default local model using a default kernel width value. The method further comprises the step of constructing shifted local models having gradually increasing kernel widths and gradually decreasing kernel widths until a stopping condition is met. The method further comprises the step of selecting a final kernel width based at least in part on the default local model and the shifted local models.

[0009] In addition to or as an alternative to one or more features described in this specification, further embodiments of the system may comprise that the final kernel width is selected from the gradually increasing kernel widths and the gradually decreasing kernel widths based at least in part on identifying the kernel width that causes convergence.

[0010] In addition to or as an alternative to one or more features described in this specification, further embodiments of the system may comprise that, in response to not identifying a kernel width that causes convergence during construction of said shifted local models having gradually increasing kernel widths and gradually decreasing kernel widths, the final kernel width is selected as the default kernel width.

[0011] Other embodiments described in this specification implement the features of the above method in computer systems and computer program products.

[0012] According to one or more embodiments described in this specification, selection of kernel width makes the model more stable. One or more embodiments described in this specification provide confidence levels to locally interpretable models for better application. One or more embodiments described in this specification provide evaluation of the stability of the contribution of each feature, and provide corresponding confidence levels, so that users can emphasize appropriate features in applications.

[0013] The above features and advantages of the present disclosure, as well as other features and advantages, will be readily apparent when the following detailed description is read in connection with the accompanying drawings. BRIEF DESCRIPTION OF THE DRAWINGS

[0014] What is claimed as exclusive right herein is particularly pointed out and distinctly claimed in the claims at the conclusion of the specification. The above and other features and advantages of embodiments of the present invention will be apparent from the following detailed description read in conjunction with the accompanying drawings.

[0015] [Figure 1A] Shows an instance where the linear model is unstable or unreliable. [Figure 1B] Shows an instance where the linear model is unstable or unreliable.

[0016] [Figure 2] Shows a plot of black box predictions for various data values.

[0017] [Figure 3] Shows a flowchart of a method for evaluating a machine learning model, in accordance with one or more embodiments described herein.

[0018] [Figure 4] Shows a flowchart of a method for determining kernel width for the machine learning model evaluated in FIG. 3, in accordance with one or more embodiments described herein.

[0019] [Figure 5A] The table shows local models constructed by gradually increasing the kernel width according to one or more embodiments described herein.

[0020] [Figure 5B] The table shows local models constructed by gradually reducing the kernel width according to one or more embodiments described herein.

[0021] [Figure 6] This specification shows exemplary plots of locally interpretable models according to one or more embodiments described herein.

[0022] [Figure 7] This specification shows a cloud computing environment according to one or more embodiments described herein.

[0023] [Figure 8] This specification shows an abstraction model layer according to one or more embodiments described herein.

[0024] [Figure 9] A block diagram of a processing system for carrying out one or more embodiments described herein is shown.

[0025] The figures illustrated herein are illustrative. Many variations are possible in the figures or actions described herein without departing from the scope of the invention. For example, actions can be performed in a different order, or actions can be added, deleted, or modified. Furthermore, the term “coupled” and its variations describe the existence of a communication pathway between two elements, and do not imply a direct connection between elements where no intervening element / connection exists. All of these variations are considered part of the specification. [Modes for carrying out the invention]

[0026] One or more embodiments of the present invention provide a stable, locally interpretable model for prediction. In machine learning, machine learning models can be trained to predict outputs based on input data. Classification is a subset of machine learning concerning predicting which of a set of categories an observation (i.e., input data) belongs to. An algorithm trained to perform classification is called a “classifier.” These machine learning models, and classifiers in particular, are almost “black boxes” in that it is difficult to understand the reasoning behind their predictions.

[0027] One conventional method for understanding classifier predictions is called locally interpretable, model-apart explanation (LIME). Generally, LIME provides an interpretable model identification for an interpretable representation that is locally accurate for the classifier. LIME is further explained by Riberio et al. in "Why Should I Trust You? Explaining the Predictions of Any Classifier," which is incorporated herein by reference. The complex decision function f of a black-box model is not recognized by LIME and cannot be well approximated by a linear model. LIME samples instances, makes predictions using the model's complex decision function f, and weights them by their proximity to the explained instance. The learned explanations may be observed to be locally accurate, but not overall.

[0028] Traditional methods such as LIME can be unstable or unreliable in some instances, for example, because the linear model is unstable in a particular instance, or the orientation of the model is unstable, or both. Figures 1A and 1B show instances 111 and 112, where linear models 101 and 102 are unstable or unreliable, respectively, because the linear models 101 and 102 are unstable at the locations of instances 111 and 112, and the orientation of models 101 and 102 is unstable.

[0029] Furthermore, conventional methods such as LIME are sensitive to instance weights (distance to the explained instance). For example, Figure 2 shows plots 200 of black-box predictions for various data values ​​"x". This figure shows the explanation of the prediction for instance x=1.6. The prediction of the black-box model that depends on a single feature is shown by line 201, and the data distribution is shown by lag 202. Three local surrogate models with different kernel widths, namely 0.1 (line 203), 0.75 (line 204), and 2 (line 205), are computed. The resulting linear regression model depends on the kernel width, and from plot 100, it can be subsequently determined whether its feature has a negative, positive, or neutral (none) effect with respect to x=1.6. A small kernel width means that the instance is nearby and influencing the local model, while a large kernel width means that even more distant instances are influencing the model.

[0030] Therefore, conventional methods for understanding classifier predictions cannot provide either the calculation or presentation of the confidence level of such methods, nor can they provide the selection of appropriate kernel widths to determine the appropriate weights of records for constructing local models.

[0031] One or more embodiments described herein address the shortcomings of the prior art by providing a stable, locally interpretable model for prediction. One or more embodiments described herein provide a method for selecting a kernel width ("kernel_width"), calculating weights for sampled instances, and constructing a stable local model. One or more embodiments described herein provide a method for identifying disturbances around the features of an instance and calculating the stability and associated confidence of the contribution of each feature. One or more embodiments described herein provide an updated final locally interpretable model, and the overall confidence of the model can be calculated.

[0032] One or more embodiments of the present invention provide technical improvements to current methods for evaluating machine learning models that do not consider kernel width and are unable to calculate and present confidence in the explanatory results of LIME methods. One or more embodiments of the present invention provide technical solutions to one or more of these shortcomings of existing solutions, to that end by selecting kernel width to make the model more stable, providing confidence in locally interpretable models for better application, evaluating the stability of the contribution of each feature and providing corresponding confidence so that users can focus on the appropriate features in application, and / or similar, including combinations thereof.

[0033] Moving on to Figure 3, a flowchart of Method 300 provides an evaluation of a machine learning model (e.g., an artificial neural network) according to one or more embodiments described herein. In particular, Method 300 provides the construction of a stable, locally interpretable model for prediction according to one or more embodiments described herein. Method 300 can be carried out using any suitable system or device, or a combination thereof, examples of which include the processing system 900 in Figure 9, one or more cloud computing nodes 10 in Figure 7, or similar combinations and / or overlaps thereof.

[0034] In block 302, the processing system 900 determines the kernel width for the machine learning model being evaluated. The process for determining the kernel width is described in more detail herein with reference to Figures 4, 5A, and 5B.

[0035] In block 304, the processing system 900 constructs a locally interpretable linear model using the kernel width determined in block 302 (see, for example, Figure 4). Figure 6 shows an exemplary plot of a locally interpretable model 600 according to one or more embodiments described herein. Two points 601 and 602 are shown, where point 601 is unstable (also called “unstable point 601”) and point 602 is stable (also called “stable point 602”). Each of these points corresponds to a feature of model 600. Consider an exemplary prediction of whether a plant is poisonous or edible. Model 600 can be evaluated for one or more of these features, such as odor, spore print color, stem surface characteristics or similar, or a combination thereof. The coefficient β of the feature in the linear model is used as the corresponding contribution to the prediction. The description of each feature is evaluated to determine whether stability exists. In other words, when disturbances are observed around the feature values, it is determined whether the linear direction on the feature (e.g., point 601, point 602, etc.) remains stable. With respect to unstable point 601, the model may be observed to be unstable around point 601, as shown by lines 601a and 601b. In contrast, point 602 may be observed to be stable, as shown by lines 602a and 602b. These decisions regarding stability / instability provide an explanation for the predictions of model 600.

[0036] In 306, the processing system 900 calculates the contribution degree and reliability of a feature (e.g., feature F1) of a locally interpretable linear model (e.g., the model 600 in FIG. 6). For example, only "l" instances of disturbance are generated around the original explained instance (e.g., feature F1). Disturbance around the value V of feature F1 can be used to generate a value V+αΔ, where Δ is the standard deviation of F1, and α satisfies α∈(-0.1, 0.1) and is randomly generated. According to one or more embodiments described herein, the values of other features are kept constant (e.g., they are not changed). In some examples, a plurality of local linear models are generated for each instance, and the contribution degrees β11, β12, ... β1 of feature F1 l are obtained, and on the other hand, the contribution degree of the original instance F1 is denoted as β10.

[0037] Next, the final contribution degree and reliability of feature F1 can be calculated. First, the value β1 avg and the value β1 std are calculated, and the original local model is updated using the following formula. [Formula] Here, "ι" is the number of newly generated instances.

[0038] The value β1 avg represents the contribution degree of feature F1. The standard deviation β1 of the coefficients (e.g., β10, β11, β12, ... β1 l ) std can also be calculated using the following formula. [Formula]

[0039] Next, the accuracy Acc of the updated model F1 can be calculated. As an example, instead of the original β10, β1 avg is used to update the model. Next, the updated model is used to calculate predicted values with data for constructing the local model. The accuracy Acc F1This represents the accuracy between the predicted value and the original target value for constructing the local model.

[0040] Next, the stability of the model for feature F1 is expressed by the following formula, based on the determined mean and standard deviation values.

number

[0041] Next, combining the stability and accuracy of the updated model's features, we calculate the confidence level of feature F1 using the following formula.

number

[0042] Next, we use this method to determine the contribution βi avg and confidence level Conf Fi Features from F1 to F i Calculate for each feature F1 to F i Obtain the feature contribution.

[0043] In block 308, the processing system 900 updates the locally interpretable linear model to generate the final model and calculates the overall confidence of the final model. For example, instead of the original β10, β1 avg We use this to obtain the updated model for each feature. That is, the overall confidence of the explanation for the instance prediction is obtained from each feature F1 to F i Contribution βi avg and confidence level Conf Fi It can be calculated using the following formula. In particular, the overall confidence in the explanation of instance predictions can be calculated using the following formula:

number

[0044] Additional processes may be included, and the processes shown in Figure 3 are illustrative. It should be understood that other processes may be added, or existing processes may be removed, modified, or restructured without departing from the scope of this disclosure.

[0045] Moving on to Figure 4, a flowchart of Method 400 provides the determination of the kernel width for the machine learning model being evaluated, according to one or more embodiments described herein. Method 400 can be implemented using any suitable system or device, or a combination thereof, examples of which include the processing system 900 in Figure 9, one or more cloud computing nodes 10 in Figure 7, or similar combinations and / or overlaps thereof.

[0046] In block 402, the processing system 900 constructs a default local model using the default kernel width value. For example, using the default kernel width, the model coefficients (β1 A , β2 A , ...) and Accuracy Acc A A local model (e.g., a linear model) M has A This is constructed. The default kernel width can be set to any preferred value, such as 0.75.

[0047] In block 404, the processing system 900 constructs a shifted local model with gradually increasing kernel widths and gradually decreasing kernel widths until a stopping condition is reached. That is, two sets of models are constructed: a first set of models with gradually increasing kernel widths and a second set of models with gradually decreasing kernel widths. These are shown in the tables in Figures 5A and 5B, respectively. For example, Figure 5A shows local model M constructed using a gradually increasing kernel width. B Table 500 shows the first set of models (for example, M). B1 M B2, ...M Bn The kernel width (e.g., 0.75+£, 0.75+2£, ..., 0.75+n£) and model coefficients (e.g., (β1)) each gradually increase in multiples of the value of £, B1 , β2 B1 ,…),(β1 B2 , β2 B2 ,…),…(β1 Bn , β2 Bn , ...)), and precision (e.g., Acc B1 Acc B2 , ...Acc Bn Figure 5B shows a local model M constructed using a gradually decreasing kernel width. S Table 501 shows the following. Similar to Figure 5A, Table 501 in Figure 5B shows each model in the second set of models (e.g., M S1 M S2 , ...M Sn ) are each a kernel width that gradually decreases by multiples of the £ value (e.g., 0.75-£, 0.75-2£, ... 0.75-n£), and model coefficients (e.g., (β1 S1 , β2 S1 ,…),(β1 S2 , β2 S2 ,…),…(β1 Sn , β2 Sn , ...)), and precision (e.g., Acc S1 Acc S2 , ...Acc Sn It is shown together with ( ). It should be understood that the value of £ can be any suitable value.

[0048] The shifted local model (e.g., the first set of models and the second set of models) is constructed until a stopping condition is reached. For example, the stopping condition can be the maximum number of iterations (e.g., 5, 7, 10, 30, etc.). Another example is that the stopping condition can be that the convergence condition is met. For example, convergence is said to be met when the following equation is satisfied:

number

[0049] As another example, the stopping condition can be set when the model accuracy Acc meets a threshold. For example, if the model accuracy Acc is Acc A The stopping condition is met if it is less than . Once the first set of models and the second set of models are built in block 404, method 400 proceeds to block 406, and the processing system 900 selects the final kernel width based at least partially on the default local model and the shifted local model. For example, if the stopping condition is a convergence condition and it is determined that the convergence condition is met, the final kernel width is selected to be the kernel width at which the optimization reached convergence (e.g., the kernel width that made the convergence condition to be met). As another example, if the stopping condition is the maximum number of iterations, once the maximum number of iterations is met, the final kernel width is selected to be the kernel width with the minimum value. In such an example, during the iterations, the following expression gradually decreases:

number

[0050] Otherwise, the default kernel width will be selected as the final kernel width. This is the case, for example, if convergence does not occur.

[0051] Additional processes may be included, and the processes shown in Figure 4 are illustrative. It should be understood that other processes may be added, or existing processes may be removed, modified, or restructured without departing from the scope of this disclosure.

[0052] While this disclosure includes a detailed description of cloud computing, it should be understood that the implementation of the teachings described herein is not limited to cloud computing environments. Rather, embodiments of the present invention can be implemented in any other type of computing environment that is currently known or may be developed in the future.

[0053] Cloud computing is a service delivery model that enables convenient on-demand network access to a shared pool of configurable computing resources (e.g., networks, network bandwidth, servers, processing, memory, storage, applications, virtual machines, and services) that can be rapidly provisioned and deployed with minimal administrative effort or interaction with service providers. This cloud model may include at least five characteristics, at least three service models, and at least four deployment models.

[0054] The following are its characteristics.

[0055] On-demand self-service: Cloud consumers can unilaterally provision computing power, such as server time and network storage, automatically as needed, without requiring human interaction with service providers.

[0056] Broad network access: Capabilities are available over the network and can be accessed through standard mechanisms that facilitate use by heterogeneous thin-client or thick-client platforms (e.g., mobile phones, laptops, and PDAs).

[0057] Resource pooling: A provider pools its computing resources and serves multiple consumers using a multi-tenant model, where different physical and virtual resources are dynamically allocated and reallocated according to demand. Consumers generally have no control over or knowledge of the exact location of the resources provided, but they have a sense of location independence, as they can specify the location at a higher level of abstraction (e.g., country, state, or data center).

[0058] Rapid scalability: In some cases, capacity can be provisioned quickly and flexibly to scale out rapidly, or released quickly to scale in rapidly, automatically. For consumers, the capacity available for provisioning is often displayed as unlimited and can be purchased in any quantity at any time.

[0059] Measurement Services: By leveraging metric capabilities at an appropriate level of abstraction for each type of service (e.g., storage, processing, bandwidth, and active user accounts), cloud systems automatically control and optimize resource usage. This allows for monitoring, control, and reporting of resource usage, providing transparency to both service providers and consumers.

[0060] The following is the service model.

[0061] Software as a Service (SaaS): The capability offered to consumers is the use of a provider's applications running on cloud infrastructure. These applications can be accessed from various client devices via thin client interfaces such as web browsers (e.g., web-based email). Consumers do not manage or control the underlying cloud infrastructure, including the network, servers, operating systems, storage, or individual application capabilities, with the exception of limited, user-specific application configuration settings.

[0062] Platform as a Service (PaaS): The capability offered to consumers is the deployment of consumer-created or acquired applications, written using programming languages ​​and tools supported by the provider, onto cloud infrastructure. Consumers do not manage or control the underlying cloud infrastructure, including networks, servers, operating systems, or storage, but they can control the deployed applications and, in some cases, the configuration of the hosting environment for those applications.

[0063] Infrastructure as a Service (IaaS): The ability provided to consumers is the provisioning of processing, storage, networking, and other basic computing resources, where consumers can deploy and run any software (which may include operating systems and applications). Consumers do not manage or control the underlying cloud infrastructure, but they can control the operating system, storage, and deployed applications, and in some cases, have limited control over selected network components (e.g., host firewalls).

[0064] The following is the deployment model.

[0065] Private Cloud: Cloud infrastructure operates exclusively for an organization. It is managed by the organization or a third party and may reside on-premises or off-premises.

[0066] Community Cloud: Cloud infrastructure is shared by multiple organizations, supporting a specific community that has shared concerns (e.g., mission, security requirements, policies, and compliance considerations). This can be managed by the organization or a third party and may reside on-premises or off-premises.

[0067] Public cloud: Cloud infrastructure is available to the general public or large industry associations and is owned by organizations that sell cloud services.

[0068] Hybrid Cloud: Cloud infrastructure is a composite of two or more clouds (private, community, or public) that are independent entities but are bound together by standardized or proprietary technologies that enable data and application portability (e.g., cloud bursting for load balancing across clouds).

[0069] Cloud computing environments are service-oriented, emphasizing statelessness, low coupling, modularity, and semantic interoperability. At the core of cloud computing lies an infrastructure that includes a network of interconnected nodes.

[0070] Referring to Figure 7, an exemplary cloud computing environment 50 is shown. As shown in the figure, the cloud computing environment 50 comprises one or more cloud computing nodes 10, to which local computing devices used by cloud consumers (e.g., personal digital assistants (PDAs) or mobile phones 54A, desktop computers 54B, laptop computers 54C, or automotive computer systems 54N, or a combination thereof) can communicate. The nodes 10 may communicate with each other. They may be grouped physically or virtually in one or more networks (such as a private cloud, community cloud, public cloud, or hybrid cloud, or a combination thereof, as described above) (not shown). This allows the cloud computing environment 50 to provide infrastructure, platforms, or software, or a combination thereof, as a service, so that cloud consumers do not need to maintain resources on their local computing devices. The types of computing devices 54A to N shown in Figure 7 are for illustrative purposes only, and it should be understood that the computing node 10 and the cloud computing environment 50 can communicate with any type of computerized device through any type of network, a network-addressable connection, or a combination thereof (for example, using a web browser).

[0071] Referring now to Figure 8, a set of functional abstraction layers provided by the cloud computing environment 50 (Figure 7) is shown. It should be understood in advance that the components, layers, and functions shown in Figure 8 are for illustrative purposes only and that embodiments of the invention are not limited thereto. As shown in the figure, the following layers and corresponding functions are provided:

[0072] The hardware layer and software layer 60 comprise hardware and software components. Examples of hardware components include a mainframe 61, a RISC (Reduced Instruction Set Computer) architecture-based server 62, server 63, blade server 64, storage device 65, and a network and network components 66. In some embodiments, software components include network application server software 67 and database software 68.

[0073] Examples of virtual entities that may be provided from the abstraction layer provided by the virtualization layer 70 include virtual servers 71, virtual storage 72, virtual networks 73 including virtual private networks, virtual applications and operating systems 74, and virtual clients 75.

[0074] For example, the management layer 80 may provide the following functions: Resource provisioning 81 provides dynamic procurement of computing and other resources used to perform tasks within the cloud computing environment. Metering and pricing 82 provides cost tracking as resources are used within the cloud computing environment and accounting or billing for the consumption of these resources. For example, these resources may include application software licenses. Security provides identity verification of cloud consumers and tasks, and protection of data and other resources. User portal 83 provides consumers and system administrators with access to the cloud computing environment. Service level management 84 provides allocation and management of cloud computing resources to meet required service levels. Service level agreement (SLA) planning and execution 85 provides pre-organization and acquisition of cloud computing resources that are expected to be needed in the future in accordance with the SLA.

[0075] The workload layer 90 provides examples of functions that can utilize a cloud computing environment. Examples of workloads and functions that can be provided from this layer include mapping and navigation 91, software development and lifecycle management 92, virtual classroom education delivery 93, data analysis processing 94, transaction processing 95, and machine learning model evaluation 96.

[0076] It is understood that one or more embodiments described herein can be implemented in combination with any other type of computing environment currently known or to be developed later. For example, Figure 9 shows a block diagram of a processing system 900 for implementing the technology described herein. According to one or more embodiments described herein, the processing system 900 is an example of the cloud computing node 10 in Figure 7. In the example, the processing system 900 has one or more central processing units ("processors" or "processing resources" or "processing devices") 921a, 921b, 921c, etc. (collectively or comprehensively referred to as processors 921 or processing devices, or both). In aspects of this disclosure, each processor 921 may include a reduced instruction set computer (RISC) microprocessor. The processors 921 are coupled via a system bus 933 to system memory (e.g., random access memory (RAM) 924) and various other components. The read-only memory (ROM) 922 is coupled to the system bus 933 and may include a basic input / output system (BIOS) that controls certain basic functions of the processing system 900.

[0077] An input / output (I / O) adapter 927 and a network adapter 926 coupled to the system bus 933 are further shown. The I / O adapter 927 may be a small computer system interface (SCSI) adapter that communicates with a hard disk 923 or a storage device 925, or a combination thereof, or any other similar component. The I / O adapter 927, the hard disk 923, and the storage device 925 are collectively referred to herein as mass storage 934. An operating system 940 for running on the processing system 900 may be stored in the mass storage 934. The network adapter 926 interconnects the system bus 933 with an external network 936, enabling the processing system 900 to communicate with other such systems.

[0078] A display 935 (e.g., a display monitor) is connected to the system bus 933 by a display adapter 932, which may include a graphics adapter to enhance the performance of graphics-intensive applications and the video controller. In one aspect of this disclosure, adapters 926, 927, or 932, or a combination thereof, may be connected to one or more I / O buses connected to the system bus 933 via an intermediate bus bridge (not shown). Suitable I / O buses for connecting peripheral devices such as hard disk controllers, network adapters, and graphics adapters typically include common protocols such as Peripheral Component Interconnect (PCI). Additional input / output devices are shown as being connected to the system bus 933 via a user interface adapter 928 and a display adapter 932. A keyboard 929, a mouse 930, and a speaker 931 may be interconnected to the system bus 933 via the user interface adapter 928, which may include, for example, a super I / O chip that integrates multiple device adapters into a single integrated circuit.

[0079] In some aspects of this disclosure, the processing system 900 includes a graphics processing unit 937. The graphics processing unit 937 is a special electronic circuit designed to manipulate and modify memory to accelerate the creation of an image in a frame buffer intended for output to a display. Generally, the graphics processing unit 937 is highly efficient in computer graphics and image processing operations and has an advanced parallel structure that makes it more effective than a general-purpose CPU for algorithms in which large data blocks are processed in parallel.

[0080] Accordingly, as provided herein, the processing system 900 comprises processing capabilities in the form of a processor 921, storage capabilities including system memory (e.g., RAM 924) and mass storage 934, input means such as a keyboard 929 and a mouse 930, and output capabilities including a speaker 931 and a display 935. In some aspects of this disclosure, a portion of the system memory (e.g., RAM 924) and the mass storage 934 collectively store an operating system 940, such as IBM Corporation's AIX® operating system, to coordinate the functions of the various components shown in the processing system 900.

[0081] Various embodiments of the present invention are described herein with reference to the relevant drawings. Alternative embodiments of the present invention can be devised without departing from the scope of the invention. Various connection and positional relationships (e.g., above, below, adjacent, etc.) are described between elements in the following description and drawings. These connection or positional relationships, or combinations thereof, may be direct or indirect unless otherwise specified, and the present invention is not intended to be limited in this respect. Thus, connections between entities may refer to direct or indirect connections, and positional relationships between entities may be direct or indirect positional relationships. Furthermore, the various tasks and process steps described herein may be incorporated into broader procedures or processes having additional steps or functions not described in detail herein.

[0082] The following definitions and abbreviations are for use in interpreting the claims and specification. As used herein, the terms “comprises,” “comprising,” “includes,” “including,” “has,” “having,” “contains,” or “containing,” or any other variation thereof, are intended to cover non-exclusive inclusion. For example, a composition, mixture, process, method, article, or apparatus comprising a list of elements is not necessarily limited to these elements and may include a list of other elements not expressly enumerated or specific to such composition, mixture, process, method, article, or apparatus.

[0083] Furthermore, the term “exemplary” is used herein to mean “serving as an example, instance, or illustration.” Any embodiment or design described herein as “exemplary” is not necessarily construed to be preferable or advantageous to other embodiments or designs. The terms “at least one” and “one or more” may be understood to include any integer one or more, i.e., 1, 2, 3, 4, etc. The term “multiple” may be understood to include any integer two or more, i.e., 2, 3, 4, 5, etc. The term “connection” may include both indirect and direct “connections.”

[0084] The terms “about,” “substantially,” and “approximately,” and their variations, are intended to include the degree of error associated with measuring a particular quantity based on the equipment available at the time of filing. For example, “about” may include a range of ±8%, 5%, or 2% of a given value.

[0085] For the sake of brevity, prior art relating to the creation and use of embodiments of the present invention may or may not be described in detail herein. In particular, various embodiments of computing systems and specific computer programs for implementing the various technical features described herein are well known. Therefore, for the sake of brevity, many details of prior art are mentioned only briefly herein, or are omitted entirely without providing details of well known systems or processes, or both.

[0086] The present invention may be an integrated system, method, or computer program product, or a combination thereof, at any possible level of technical detail. The computer program product may include a computer-readable storage medium having computer-readable program instructions for causing a processor to carry out aspects of the present invention.

[0087] A computer-readable storage medium can be a tangible device capable of holding and storing instructions for use by an instruction execution device. A computer-readable storage medium may, but is not limited to, electronic storage devices, magnetic storage devices, optical storage devices, electromagnetic storage devices, semiconductor storage devices, or any preferred combination thereof. A non-exclusive list of more specific examples of computer-readable storage media includes portable computer diskettes, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), static random access memory (SRAM), portable compact disk read-only memory (CD-ROM), digital multipurpose disks (DVDs), memory sticks, floppy disks, mechanically encoded devices such as punch cards or grooved raised structures on which instructions are recorded, and any preferred combination thereof. When used herein, computer-readable storage media should not be construed as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through waveguides or other transmission media (e.g., light pulses passing through optical fiber cables), or transient signals such as electrical signals transmitted through wires.

[0088] The computer-readable program instructions described herein may be downloaded from a computer-readable storage medium to each computing / processing device, or they may be downloaded to an external computer or external storage device via a network, such as the Internet, a local area network, a wide area network, or a wireless network, or a combination thereof. The network may include copper transmission cables, optical transmission fibers, wireless transmissions, routers, firewalls, switches, gateway computers, or edge servers, or a combination thereof. A network adapter card or network interface in each computing / processing device receives computer-readable program instructions from the network and transfers those computer-readable program instructions for storage in a computer-readable storage medium within each computing / processing device.

[0089] The computer-readable program instructions that perform the operation of the present invention may be assembler instructions, instruction set architecture (ISA) instructions, machine instructions, machine-dependent instructions, microcode, firmware instructions, state setting data, integrated circuit configuration data, source code or object code written in any combination of one or more programming languages, including object-oriented programming languages ​​such as Smalltalk® or C++, and procedural programming languages ​​such as the C programming language or similar programming languages. The computer-readable program instructions can be executed as a standalone software package entirely on the user's computer, partially on the user's computer, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In the latter scenario, the remote computer may be connected to the user's computer via any type of network, including a local area network (LAN) or wide area network (WAN), or the connection may be made to an external computer (for example, via the Internet using an Internet service provider). In some embodiments, for example, an electronic circuit including a programmable logic circuit, a field-programmable gate array (FPGA), or a programmable logic array (PLA) may execute a computer-readable program instruction by personalizing the electronic circuit using state information of the computer-readable program instruction in order to carry out an aspect of the present invention.

[0090] Aspects of the present invention are described herein with reference to flowcharts or block diagrams, or combinations thereof, of methods, apparatus (systems), and computer program products according to embodiments of the present invention. It will be understood that each block in a flowchart or block diagram, or combination thereof, and combinations of blocks in a flowchart or block diagram, or both, can be implemented by computer-readable program instructions.

[0091] These computer-readable program instructions may be provided to the processor of a general-purpose computer, a dedicated computer, or other programmable data processing device to create a machine in which instructions executed via the processor of the computer or other programmable data processing device create means for performing functions / operations specified in one or more blocks of a flowchart and / or block diagram. These computer-readable program instructions may be stored in a computer-readable storage medium that can direct a computer, a programmable data processing device, or other device, or a combination thereof, to function in a particular manner, so that the computer-readable storage medium storing the instructions contains a product containing instructions that perform the modes of functions / operations specified in one or more blocks of a flowchart and / or block diagram.

[0092] Furthermore, computer-readable program instructions can be loaded into a computer, another programmable data processing device, or another device to create a computer-executed process by having the computer, other programmable device, or other device perform a series of operational steps, thereby causing the instructions executed on the computer, other programmable device, or other device to perform the functions / operations specified in one or more blocks of a flowchart and / or block diagram.

[0093] The flowcharts and block diagrams in the drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of the present invention. In this regard, each block in a flowchart or block diagram may represent a module, segment, or part of an instruction, which contains one or more executable instructions for performing a specified logical function. In some alternative implementations, the functions described in a block may be performed in a different order than shown in the diagram. For example, two blocks shown consecutively may actually be executed substantially simultaneously, and blocks may be executed in reverse order depending on the functions involved. It should also be noted that each block in a block diagram or flowchart, or a combination thereof, and the combination of blocks in a block diagram or flowchart, or a combination thereof, may be implemented by an application-specific hardware-based system that performs a specified function or operation, or implements a combination of application-specific hardware and computer instructions.

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

Claims

1. A computer-based method for evaluating machine learning models, The step of determining the kernel width for the aforementioned machine learning model; The step of constructing a locally interpretable linear model using the aforementioned kernel width; The step of calculating the contribution and confidence level of the features of the locally interpretable linear model; and The step of updating the locally interpretable linear model to generate the final model and calculating the overall confidence level of the final model. A computer implementation method comprising:

2. The step of determining the kernel width for the machine learning model is: The stage of building a default local model using the default kernel width value; The step of constructing a shift local model with gradually increasing and gradually decreasing kernel widths until a stopping condition is reached; and The step of selecting the final kernel width based at least partially on the default local model and the shifted local model. A computer implementation method according to claim 1, comprising:

3. The computer implementation method according to claim 2, wherein the termination condition is at least one of the following: the maximum number of iterations, the convergence condition being met, or the accuracy meeting a threshold.

4. The computer implementation method according to any one of claims 1 to 3, wherein the step of calculating the overall reliability of the final model is at least partially based on the contribution and reliability of the features of the locally interpretable linear model.

5. The step of calculating the additional contribution and confidence of the additional features of the locally interpretable linear model. A computer implementation method according to any one of claims 1 to 3, further comprising:

6. The computer implementation method according to claim 5, wherein the additional contribution and confidence of the additional features are used to calculate the overall confidence of the final model.

7. Memory containing computer-readable instructions; A processing device for executing the computer-readable instructions, wherein the computer-readable instructions control the processing device to perform an operation for evaluating a machine learning model, and the operation is: The step of determining the kernel width for the aforementioned machine learning model; The step of constructing a locally interpretable linear model using the aforementioned kernel width; The step of calculating the contribution and confidence level of the features of the locally interpretable linear model; and The step of updating the locally interpretable linear model to generate the final model and calculating the overall confidence level of the final model. including A system equipped with these features.

8. The step of determining the kernel width for the machine learning model is: The stage of building a default local model using the default kernel width value; The step of constructing a shift local model with gradually increasing and gradually decreasing kernel widths until a stopping condition is reached; and The step of selecting the final kernel width based at least partially on the default local model and the shifted local model. The system according to claim 7, having the following features.

9. The system according to claim 8, wherein the termination condition is at least one of the maximum number of iterations, the convergence condition being met, or the accuracy meeting a threshold.

10. The system according to any one of claims 7 to 9, wherein the step of calculating the overall reliability of the final model is at least in part based on the contribution and reliability of the features of the locally interpretable linear model.

11. The aforementioned operation is, The step of calculating the additional contribution and confidence of the additional features of the locally interpretable linear model. The system according to any one of claims 7 to 9, further comprising:

12. The system according to claim 11, wherein the overall reliability of the final model is calculated using the additional contribution and reliability of the additional features.

13. A computer program for evaluating machine learning models, which uses a processor, A procedure for determining the kernel width for the aforementioned machine learning model; A procedure for constructing a locally interpretable linear model using the aforementioned kernel width; A procedure for calculating the contribution and confidence of the features of the locally interpretable linear model; and A procedure to update the locally interpretable linear model to generate a final model and to calculate the overall confidence level of the final model. A computer program designed to execute something.

14. The procedure for determining the kernel width for the machine learning model is: Procedure for constructing a default local model using the default kernel width value; A procedure for constructing a shift local model with gradually increasing and gradually decreasing kernel widths until a stopping condition is reached; and A procedure for selecting the final kernel width based at least partially on the default local model and the shifted local model. A computer program according to claim 13, having the following characteristics.

15. The computer program according to claim 14, wherein the termination condition is at least one of the following: the maximum number of iterations, the convergence condition being met, or the accuracy meeting a threshold.

16. A computer program according to any one of claims 13 to 15, wherein the procedure for calculating the overall confidence of the final model is at least partially based on the contribution and confidence of the features of the locally interpretable linear model.

17. The aforementioned processor, Procedure for calculating the additional contribution and confidence of additional features of the locally interpretable linear model. A computer program according to any one of claims 13 to 15, which further performs the following:

18. The computer program according to claim 17, wherein the overall reliability of the final model is calculated using the additional contribution and reliability of the additional features.

19. A computer implementation method for determining the kernel width for a machine learning model, The stage of building a default local model using the default kernel width value; The step of constructing a shift local model with gradually increasing and gradually decreasing kernel widths until a stopping condition is reached; and The step of selecting the final kernel width based at least partially on the default local model and the shifted local model. A computer implementation method comprising:

20. The computer implementation method according to claim 19, wherein the final kernel width is selected from the gradually increasing kernel width and the gradually decreasing kernel width, at least in part, based on the identification of a kernel width that causes convergence.

21. The computer implementation of claim 20, in response to not identifying a kernel width that causes convergence during the construction of the shift local model having gradually increasing and gradually decreasing kernel widths, the final kernel width is selected as the default kernel width value.

22. In the processor, Procedure for constructing a default local model using the default kernel width value; A procedure for constructing a shift local model with gradually increasing and gradually decreasing kernel widths until a stopping condition is reached; and A procedure for selecting the final kernel width based at least partially on the default local model and the shifted local model. A computer program designed to execute something.

23. The computer program according to claim 22, wherein the final kernel width is selected from the gradually increasing kernel width and the gradually decreasing kernel width, at least in part, based on the identification of the kernel width that causes convergence.

24. The computer program according to claim 23, wherein, in response to not identifying a kernel width that causes convergence during the construction of the shift local model having gradually increasing and gradually decreasing kernel widths, the final kernel width is selected as the default kernel width value.

25. The computer program according to any one of claims 22 to 24, wherein the termination condition is at least one of the maximum number of iterations, the convergence condition being met, or the accuracy meeting a threshold.

Images