Training interpretable deep learning models using disentangling learning

Abstract

A method and system of training an explainable deep learning model includes receiving an input dataset that can be complex. The input dataset is provided to a deep learning model for feature extraction. In an exemplary embodiment, the deep learning model generates an unentangled latent space of features from the feature extraction. The features can include semantically meaningful data that is then provided to a low complexity learning model. The low complexity learning model generates an output based on a specified task (e.g., classification or regression). As a low complexity learning model, the data output from the deep learning model is believed to be inherently explainable.

Description

Technical Field

[0001] This disclosure generally relates to data processing, and more specifically to systems and methods for training interpretable deep learning models using unentanglement learning. Background Technology

[0002] Neural networks are generally considered a technique that mimics the operation of a living brain. Artificial networks simulate decision layers to perform specified tasks. Tasks include, for example, feature identification and classification. Layers may include an input layer, an output layer, and at least one hidden layer in between. Each layer performs a specific type of sorting and ranking in the process; some of these are referred to as "feature hierarchical structures."

[0003] To better understand the features of this disclosure, it may be helpful to discuss what is known about deep neural networks. Deep neural networks can be used to process unlabeled or unstructured data. Deep learning represents a form of machine learning in which techniques from various aspects of artificial intelligence seek to classify and rank information in ways that go beyond simple input / output protocols. Deep neural networks extract data representations that are often difficult for humans to interpret or that are too time-consuming to interpret. Meaningful representations of data from complex datasets can be provided with minimal user intervention.

[0004] Much of how deep neural networks operate remains unknown and unsolved. Often, deep neural networks can perform tasks without being given rules or conditions to follow. Deep learning is useful for the performance it provides with minimal user intervention when processing large batches of data.

[0005] The industry is currently working to better understand and explain how deep neural networks behave, so as to improve modeling. Interpretability (or explainability) is related to the task being performed. This means, for example, for an input image classified as "dog," that the explanation from the model indicates why or which features of the input image are most responsible for the classification. Therefore, the attempt is to explain the classification (or regression) model.

[0006] Traditionally, models are trained for a specific task. The model extracts desired features from the input and predicts the output. If the model archives its performance on difficult datasets, it suffers. Alternatively, if a complex deep architecture is used, the model can learn difficult decision boundaries and perform well. However, simple models are interpretable, while complex deep models are not. Choosing one type of model over another requires undesirable trade-offs. Simple models are interpretable but perform poorly, while deep models are not interpretable but offer excellent performance.

[0007] Current methods use, for example, explanatory modules to provide interpretability for complex deep models. Explanatory modules are typically decoupled from the deep learning model. For example, an explanatory module examines the data model and images and generates explanations from outside the learning model. Explanations can highlight input features whose presence (and absence) is most important for the model's decisions. However, the explanations are considered guesses from the explanatory module and are not necessarily true explanations of how the learned model achieves its output.

[0008] Other approaches may include using surrogate models that provide localized descriptions around the data points. However, the output from a surrogate model may also be based on inference and is not necessarily an accurate depiction of the decisions made by the learned model. Surrogate models use different features than the original neural network and only describe specific examples. Furthermore, the surrogate model itself may not help describe the global model. Surrogate models are typically limited to describing a small region of the decision boundary near a given test data point.

[0009] It is clear that finding a way to better explain how deep learning models operate to refine and improve aspects of their training remains a challenge. Summary of the Invention

[0010] According to embodiments of this disclosure, a method for training an interpretable deep learning model for a machine learning system is provided. The method includes receiving an input dataset; feeding the input dataset to a deep neural network model; extracting features from the deep neural network model; generating a latent space of vectors comprising the extracted features; feeding the latent space of vectors to a task-specific model; and generating interpretable predictions of the feature dimensions from the task-specific model.

[0011] In one embodiment of the method, an encoder module is used to extract features.

[0012] According to another embodiment of this disclosure, a computer program product for training an interpretable deep learning model for a machine learning system is provided. The computer program product includes one or more computer-readable storage media, and program instructions commonly stored on the one or more computer-readable storage media. The program instructions include receiving an input dataset; providing the input dataset to a deep neural network model; extracting features from the deep neural network model; generating a latent space comprising vectors of the extracted features; feeding the latent space of vectors into a task-specific model; and additionally generating interpretable predictions of the feature dimensions from the task-specific model.

[0013] According to one embodiment, the latent space of the vectors is a disentangled representation of the input dataset.

[0014] According to another embodiment of the present invention, a computer server is disclosed. The computer server includes: a network connection; one or more computer-readable storage media; a processor coupled to the network connection and coupled to one or more computer-readable storage media; and a computer program product including: program instructions co-stored on the one or more computer-readable storage media, the program instructions including receiving an input dataset; providing the input dataset to a deep neural network model; extracting features from the deep neural network model; generating a latent space of vectors including the extracted features; feeding the latent space of vectors to a task-specific model; and additionally, generating interpretable predictions of the feature dimensions from the task-specific model.

[0015] According to one embodiment, the task-specific model is a low-complexity learning model.

[0016] According to another embodiment of this disclosure, a method for training an interpretable deep learning model for a machine learning system is provided. The method includes receiving an input dataset. The input dataset is then provided to a beta variable autoencoder.

[0017] A Beta variational autoencoder generates the output representation of the input dataset. A low-complexity learning model is used to process the output representation. This low-complexity learning model determines the task-specific output dataset. Furthermore, an interpretation of the input dataset is presented based on the task-specific output dataset.

[0018] In one embodiment, the output representation of the input dataset generated by the Beta variational autoencoder is a latent space of dimensional vectors organized by features with semantic relationships.

[0019] According to another embodiment of this disclosure, a computer program product for training an interpretable deep learning model for an artificial intelligence computing system is provided. The computer program product includes one or more computer-readable storage media, and program instructions co-stored on the one or more computer-readable storage media. The program instructions include receiving an input dataset; providing the input dataset to a Beta-variable autoencoder; the Beta-variable autoencoder generating an output representation of the input dataset; processing the output representation using a low-complexity learning model; the low-complexity learning model determining a task-specific output dataset; and further, presenting an interpretation of the input dataset based on the task-specific output dataset.

[0020] In one embodiment, the program instructions further include using a decoder module to reconstruct the input dataset. The reconstruction error loss is determined based on the reconstructed input dataset. The classification or regression loss is determined from the task-specific output dataset. Additionally, a combination of the reconstruction error loss and the classification or regression loss is used to train the Beta variational autoencoder, the decoder module, and the low-complexity learning model.

[0021] The techniques described in this article can be implemented in a variety of ways. Example implementations are provided below with reference to the accompanying figures. Attached Figure Description

[0022] The accompanying drawings illustrate illustrative embodiments. They do not show all embodiments. Other embodiments may be used alternatively or in lieu of them. Details that may be obvious or unnecessary may be omitted to save space or for more efficient description. Some embodiments may be practiced with additional components or steps and / or without all components or steps shown. When the same reference numerals appear in different drawings, they refer to the same or similar components or steps.

[0023] Figure 1 This is a block diagram of an architecture for interpretable deep learning of data according to an embodiment.

[0024] Figure 2 This is a block diagram of an architecture for training an interpretable deep learning model according to an embodiment.

[0025] Figure 3 This is a block diagram of a system for training an interpretable deep learning model according to an embodiment.

[0026] Figure 4 This is a schematic diagram of batches of potential dimensions under various levels of supervision according to some embodiments.

[0027] Figure 5 This is a schematic diagram of the results of example datasets under various levels of supervision, based on embodiments disclosed in the subject matter.

[0028] Figure 6 This is a flowchart of a method for training an interpretable deep learning model according to an embodiment.

[0029] Figure 7 It is a functional block diagram of a computer hardware platform that can communicate with various networked components.

[0030] Figure 8 A cloud computing environment consistent with the illustrative embodiments is described.

[0031] Figure 9 An abstract model layer consistent with the illustrative embodiments is described. Detailed Implementation

[0032] In the following detailed description, many specific details are illustrated by way of examples to provide a thorough understanding of the teachings. However, it should be apparent, however, that these teachings can be practiced without these details. In other instances, well-known methods, procedures, components, and / or circuits have been described at a relatively high level without detail to avoid unnecessarily obscuring aspects of these teachings.

[0033] This disclosure generally relates to systems and methods for interpretable deep learning models of training data. As will be understood, aspects of the subject matter disclosure improve the interpretability of data from deep learning models. Typically, embodiments can be practiced in the domain of machine learning applications.

[0034] definition

[0035] Deep neural networks or deep learning models A neural network consisting of more than two layers.

[0036] Low complexity model Low-complexity models can be parametric models (e.g., linear models), nonparametric models (e.g., K-nearest neighbors), simple decision trees (e.g., classification and regression trees (CART)), or ensemble models (e.g., bagging methods, random forests, or boosting methods, gradient boosting trees).

[0037] Unsupervised learning A machine learning process that searches for previously undetected patterns in datasets with no pre-existing labels and minimal human supervision.

[0038] Supervised learning A machine learning task that learns a function that maps inputs to outputs based on example input-output pairs.

[0039] Overview

[0040] In the following disclosure, embodiments propose a deep learning model system with an architecture that is inherently more interpretable than conventional deep learning models. Aspects of the disclosure reconcile the trade-off between the performance of deep learning models and the interpretability of low-complexity models by decoupling the burden of feature extraction from the task-specific model. It should be understood that the disclosure utilizes unconventional features that combine relatively low-complexity models with the outputs from deep learning models to provide inherent interpretability of the deep learning outputs. In exemplary embodiments, the feature extractor model (e.g., an encoder) can be very complex, but the task-specific model can be of a low-complexity type (e.g., a linear model). The encoder can handle all the complexity associated with extracting the correct unentangled latent space. Once the unentangled latent space is obtained, the embodiments use it as the task-specific model, which processes the latent space features extracted by the encoder. As will be understood, with respect to the features extracted by the encoder, the output of the task-specific model can be reliably considered interpretable.

[0041] As will be understood, the disclosed aspects of the subject matter provide an unexpected ability to accurately classify features extracted by the encoder, even when they are uninterpretable. By including disentanglement learning in the embodiments, the system (or process) can generate interpretable features from the encoder, also with high performance. If these features extracted by the encoder can be associated with semantically meaningful concepts, then the low-complexity model, which has been assumed to be interpretable, can remain interpretable and also perform well. Additional discussion on generating semantically meaningful data will be referenced below. Figure 2 and 6 This is an improvement over using external mechanisms (such as explainers), as the subject-matter model becomes inherently explainable through a combination of deep learning models and low-complexity task-specific models. No external explainer is needed to explain the entire model.

[0042] Typically, external systems (e.g., explanatory modules) are used to evaluate the output of unsupervised learning systems to allow the expressiveness of the unsupervised learning system to remain robust. When dealing with highly complex data, it may be particularly desirable to use unsupervised learning models that provide a high degree of disentanglement of the extracted features. Essentially, humans may not be able to discern groupings of data from systems that provide highly disentangled outputs, thus requiring computational devices with appropriate configurations as described in this paper. While a high level of expressiveness may be desirable, human users may not be able to understand the criteria used by the unsupervised model when observing a set of dimensions if the output lacks discernible precision. Furthermore, the ability of external explanatory modules to provide accurate explanations of results from more complex data becomes less reliable, as explanatory modules all rely on inferences from estimates. As will be understood, the combination of deep learning models handling denser disentanglement learning and low-complexity models handling task-specific problems strikes a balance by allowing the deep learning portion to maintain a high degree of expressiveness of its results, while the low-complexity model provides a higher degree of explanatoryness from the output of the deep learning portion of the system. Moreover, the results provide improvements in precision on the data being processed, which can lead to significant advances in image processing, feature labeling, and drug discovery technologies, to name just a few.

[0043] Example Architecture

[0044] Figure 1 An example architecture 100 for interpretable deep learning of data is shown. Architecture 100 includes a network 106 that allows various computing devices 102(1) to 102(N) to communicate with each other, and other elements connected to the network 106, such as training data input sources 112, machine learning servers 116, and cloud 120.

[0045] Network 106 may be, but is not limited to, a local area network (“LAN”), a virtual private network (“VPN”), a cellular network, the Internet, or a combination thereof. For example, network 106 may include a mobile network communicatively coupled to a private network, sometimes referred to as an intranet providing various ancillary services, such as communication with various app stores, libraries, and the Internet. Network 106 allows machine learning engine 110 (which is a software program running on machine learning server 116) to communicate with training data input source 112, computing devices 102(1) to 102(N), and cloud 120 to provide data processing. Training data input source 112 may provide data that will be processed using one or more techniques described herein. Data processing may be one or more user-specified tasks, such as feature learning and classification. Data input to training data input source 112 may be, for example, complex images, text data, numbers, symbols, gene sequences, or other data that may not be explainable by direct human analysis. In one embodiment, data processing is performed at least partially on cloud 120.

[0046] For purposes discussed later, several user devices are shown in the accompanying drawings to represent some examples of computing devices that may be data sources analyzed according to a selected task. Aspects of symbol sequence data (e.g., 103(1) and 103(N)) can communicate via network 106 with the machine learning engine 110 of machine learning server 116. Today, user devices typically take the form of mobile phones, smartphones, tablets, personal digital assistants (PDAs), and smartwatches, although they can be implemented in other form factors, including consumer and business electronic devices.

[0047] For example, a computing device (e.g., 102(N)) may send a request 103(N) to a machine learning engine 110 to identify features present in the input data stored in the computing device 102(N).

[0048] Although the training data input source 112 and the machine learning engine 110 are illustrated by way of example as being on different platforms, it will be understood that in various embodiments, the training data input source 112 and the machine learning server 116 can be combined. In other embodiments, these computing platforms can be implemented by virtual computing devices in the form of virtual machines or software containers hosted in the cloud 120, thereby providing a resilient architecture for processing and storage.

[0049] Now for reference Figure 2 This is an architecture 200 for training interpretable deep learning models according to embodiments. These embodiments provide a balance between the performance output of deep learning models and the interpretability of the models. Architecture 200 typically includes a deep neural network 220. The deep neural network 220 can process complex input data to extract features that may not be inherently interpretable to human users of the system when presented for evaluation. The deep neural network 220 processes the features extracted from the input to generate a semantically meaningful latent space of features 240. As used herein, the term "semantically meaningful" includes the meaning that features can be grouped based on some shared or similar characteristics or sequences identified by the deep neural network 220. As will be understood, the deep neural network 220 provides good performance when processing input data. Data in the latent space 240 can be fed into a low-complexity shallow model 260, which, in one example, could be a linear classifier.

[0050] The low-complexity model 260 can use a supervised learning process. The low-complexity model can be configured to identify the dimensions represented by the content in the latent space 240. Typically, the low-complexity model can process the localization boundaries of the data in the latent space 240 to determine the criteria being processed. As a result, the output from the low-complexity shallow model 260 becomes more informative than the data in the latent space 240.

[0051] Now for reference Figure 3 A system 300 for training an interpretable deep learning model according to an embodiment is shown. In an exemplary embodiment, the deep learning portion is supplemented by a low-complexity model 370 to provide inherently more interpretable data from the deep learning portion. The overall interpretable model of system 300 operates under the parameters of the following equation:

[0052] Eq.1: L(θ, φ, w; x) = E ((Qφ(z|x)) [logP θ (x|z)]-βD KL (Q φ (z|x)|p(z))+λLoss(y, Fw(y|z)).

[0053] In system 300, the deep neural network may include a variational autoencoder (VAE). In an exemplary embodiment, the autoencoder may be a beta-varying autoencoder (β-VAE). In this case, the input from dataset 310 may be mapped to a distribution. By way of illustrative example only and not by way of limitation, dataset 310 may represent an image being processed for features.

[0054] (β-VAE) can be unsupervised and is used to learn the latent space 330. The latent space 330 is generated based on the input dataset 310 using an encoder module 320. The encoder module 320 can transform the original high-dimensional input from the dataset 310 into latent low-dimensional data features that include the latent space. In β-VAE, a given input sample is first encoded (by the encoder module 320) as a distribution over the latent space 330. In Eq. 1, the encoder loss from the encoder module 320 is given by D. KL (Q φThe distribution (z|x)|p(z) is given. The distribution can be modeled as a Gaussian mixture. Samples can be extracted from the distribution and decoded by decoder module 340. The decoder loss of decoder module 340 is given by E((Qφ(z|x))[logPθ(x|z)]. The difference between the original sample and the reconstructed sample can be used to calculate the reconstruction loss, and the β value can be used to ensure that the factors in the latent space 330 are properly unentangled. Ideally, the reconstructed data version 350 from decoder module 340 matches the input dataset, and the loss can be used to optimize the input to encoder module 320. In the subject disclosure, in addition to the traditional ELBO loss used to train β-VAE as an unsupervised model, classification / regression loss terms can be used. In the model, model training is supervised.

[0055] The classification or regression loss (given by λLoss(y, Fw(y|z))) ensures that the unentanglement factor will also lead to better performance of the task.

[0056] The combination of loss terms is used to optimize encoder module 320 to produce a better unentangled potential space.

[0057] It is noteworthy that the β-VAE separates the latent space 330 into a disentangled space of factors. For example, assuming Gaussian mixtures comprise different files, given any input data, the system can decompose the file into disentangled factors. These disentangled factors can be correlated such that if the system changes one factor, the other factors are unaffected by that change. Therefore, in some embodiments, the proposed structure allows for the separation of factors. Since each factor represents a semantic attribute of the input data (e.g., eyes, hair, etc.), each dimension in the disentangled space represents a disentangled feature. For illustrative purposes only, the input to the encoder module 320 can be considered as a dataset of faces. It is conceivable that the disentangled factors represent semantic features such as skin color, hair color, facial orientation, etc. In the subject example, a user might not readily know which dimension in the latent space represents skin color, and which represents hair color or other features. To identify the semantic attributes represented by the latent factors, the user might require some help or hints to traverse the latent space. As will be understood, an additional aspect of system 300 allows human experts to examine the latent space and perform a latent space traversal to map semantic labels to latent factors (or, dimensions).

[0058] In an exemplary embodiment, system 300 includes a low-complexity model 370 coupled to the output of encoder module 320. The low-complexity model 370 may be a task-specific model, and its output 380 may be used to perform user-specified tasks (e.g., dimensionality reduction, classification, prediction, anomaly detection, etc.).

[0059] In some embodiments, noise from the reconstruction and task-specific outputs can be used to train the model (encoder, decoder, low complexity). The inputs to the latent space 330 can be trained using a loss. The supervised loss (classification / regression) in system 300 can be represented by a portion of Eq.1, including λLoss(y, Fw(y|z)). Factors / features from λLoss(y, Fw(y|z)) can be used to train the overall model to improve its accuracy. In some embodiments, the amount of loss in the model can be user-tunable.

[0060] Example data application

[0061] refer to Figure 4 The diagram shows three batch datasets (sets 410, 420, and 430) with different λ values ​​of the loss factor applied to the datasets. The first two rows represent the data being reconstructed. Each row below the first two rows represents a traversal of the latent dimensions over 200 training epochs.

[0062] Set 410 was processed without adding any additional loss factor to the process, and represents unsupervised unentanglement of the data. Four rows produce some reconstructions with some identifiable semantic dimensions. However, the batch accuracy is only 6% of the accuracy score. The reconstruction loss is 149.4.

[0063] Set 420 represents data processed using supervised deentanglement. The lambda (λ) value used is 50. In set 520, seven rows produce some reconstructions with some identifiable semantic dimensions. Under supervision, batch accuracy is improved to 99.1%, and the reconstruction loss is reduced to 126.15.

[0064] Set 430 represents data processed using the enhanced supervised deentanglement technique. The λ value applied to the data for training is 100, which improves the accuracy to 99.5% and further reduces the reconstruction loss to 125.27.

[0065] Now for reference Figure 5 This illustrates a comparison between a guided β-VAE learning model system and an unguided system on an example dataset. The input dataset consists of two-dimensional shapes procedurally generated from six baseline true independent latent factors. The factors in the example dataset are the color, shape, scaling, rotation, and “X” and “Y” positions of the sub-images. All possible combinations of these latent factors appear only once, producing N = 737280 total images. Output set 510 is processed by a guided β-VAE using a λ value of 50, and output set 520 is processed using an unguided β-VAE. The first two rows of each set represent the data being reconstructed.

[0066] Referring to the third, fourth, and fifth lines from the top of the set, it can be seen that the results in set 510 are inherently more interpretable to humans compared to the same lines in set 520. For example, in line 512 of set 510, the basic semantic criterion for the latent dimension being processed can be discerned by the naked eye as being based on the “X” position of the sub-picture (which can represent a horizontal or transverse position in a Cartesian coordinate system). In a similar line in set 520, it is the same latent dimension, but the interpretation is less clear. Similarly, in line 514 of set 510, it can be seen that the latent dimension represents the “Y” position (which can represent a vertical position in a Cartesian coordinate system). In line 516 of set 510, the guiding β-VAE discernibly shows that the latent dimension represents a scale dimension.

[0067] Example Method

[0068] Now for reference Figure 6 The diagram illustrates a method 600 for training an interpretable deep learning model according to an embodiment. Method 600 may include receiving an input dataset 610. The data may include abstract data features. In application, method 600 may be used, for example, to perform a specific task of classifying features present in the input data. The input dataset may be provided 620 to a deep neural network. The deep neural network may include a β-VAE. Features may be extracted from the deep neural network by an encoder 630. A latent space comprising the extracted, disentangled feature vectors learned from the input data may be generated by the encoder 640. The latent space of the vectors may be decoded by a decoder 650. The decoded data from the latent space may be reconstructed 660. A reconstruction loss may be determined 670, which may be used to train the output generated in the latent space.

[0069] Additionally, the unentangled vectors can be used to train supervised models for classification or regression tasks up to block 680. For example, a user might want to predict the label of an input image. Given an image, the user might want the model to predict whether it is a "dog" or a "cat". The error between the reconstructed input (from the decoder's output at block 650) and the original input data is the reconstruction error (which is the unsupervised loss).

[0070] The output of a supervised model (e.g., classification or prediction) can be compared to the labels of the data to determine the classification / regression loss. This is the supervised loss. For example, if the model predicts an image is "dog," but the baseline true label is "cat," this error can be used to calculate the loss.

[0071] Combinations of reconstruction loss and classification / regression loss can be used to train models (e.g., encoders, decoders, and task models (classification / regression)).

[0072] Once the unentangled space is generated (box 640), the process can associate the dimensions of the unentangled vectors with semantically meaningful concepts in the input. For example, for a face as input, there might be a five-dimensional unentangled vector. In an exemplary association, the first dimension could represent hair color, the second dimension could represent skin color, the third dimension could represent the orientation of the face, and so on. To obtain semantically meaningful data, noise can be added to selected dimensions. In some embodiments, it can be assumed that each dimension of the unentangled vector is appropriately normalized. Each time noise is added, a decoder can be used to reconstruct the input using the noisy latent vector. This process can be repeated for various values ​​of noise in the range [0, 1], and the input is reconstructed each time. Ideally, the set of reconstructed inputs should indicate what semantic concepts are represented by the dimensions.

[0073] The process can consider a second dimension and repeat the steps above to identify semantic concepts, etc., for each dimension. In some embodiments, analysis of the reconstructed input set for each dimension provides the ability to associate each dimension with semantically meaningful concepts.

[0074] Why does adding noise to a dimension only change a single concept in the image? This is because dimensions are disentangled. Therefore, the process can change dimensions independently, one after another, and analyze their effects on the input image. Furthermore, a change to one dimension is not necessarily related to a change to another.

[0075] Example computer platform

[0076] As described above, the functions related to interpretable modeling disclosed in the subject matter can be executed using one or more computing devices connected via wireless or wired communication for data communication, such as... Figure 1 As shown. Figure 7 This is a functional block diagram of a computer hardware platform that can communicate with various networked components such as training input data sources and the cloud. Specifically, Figure 7 A network or host computer platform 700 is shown, which can be used to implement, for example Figure 1 Servers like the machine learning server 116.

[0077] Computer platform 700 may include a central processing unit (CPU) 704 and a hard disk drive.

[0078] (HDD) 706, random access memory (RAM) and / or read-only memory (ROM) 708, keyboard 710, mouse 712, display 714 and communication interface 716, which are connected to system bus 702.

[0079] In one embodiment, HDD 706 has the capability to include a stored program that can perform various processes such as machine learning engine 740 in the manner described herein. Typically, machine learning engine 740 can be configured to operate a deep neural network in the above embodiments. Machine learning engine 740 may have various modules configured to perform different functions. In some embodiments, machine learning engine 740 may operate under the processing of an autoencoder. For example, an encoder module 742 may be present, which is operable to interpret input data and provide feature extraction. Encoder module 742 may be configured to generate a latent space 744 of feature dimensions. Decoder module 746 may process data in latent space 744 and perform reconstruction of the input data to optimize the data used by encoder module 742.

[0080] In some embodiments, platform 700 may include a supervised modeler module 748. The supervised modeler module 748 is operable to perform one or more low-complexity modeling tasks. Examples of supervised learning processes may include classifiers, linear regression, logistic regression, support vector machines (SVM), K-nearest neighbors, decision trees, and random forests.

[0081] In some embodiments, a denoising module 750 may be included, which adds noise to the data to mask some features and make the underlying dimensionality criteria more apparent. In some embodiments, the loss from the decoder module 746 and / or from the supervised modeler module 748 may be used to generate the noise.

[0082] In one embodiment, HDD 706 can store an executable application that includes one or more library software modules, such as those used to implement a JVM (Java JVM). TM Java Virtual Machine TM The library software modules of the runtime environment program.

[0083] Example cloud platform

[0084] As mentioned above, functionalities related to using low-complexity models to illustrate data processing from the output of deep learning models can include Cloud120 (see [link to Cloud120]). Figure 1 It should be understood that although this disclosure includes a detailed description of cloud computing, the implementation of the teachings set forth herein is not limited to cloud computing environments. Rather, embodiments of this disclosure can be implemented in conjunction with any other type of computing environment now known or developed hereafter.

[0085] 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, storage, storage devices, applications, virtual machines, and services) that can be rapidly and dynamically deployed and released with minimal management effort or interaction with service providers. A cloud model may include at least five features, at least three service models, and at least four deployment models.

[0086] The features are as follows:

[0087] On-demand self-service: Cloud consumers can unilaterally and automatically deploy computing functions, such as server time and network storage, as needed, without requiring manual interaction with the service provider.

[0088] Extensive network access: Functionality is available on the network and accessed through standard mechanisms that facilitate the use of heterogeneous thin or thick client platforms (e.g., mobile phones, laptops, and PDAs).

[0089] Resource pooling: The provider's computing resources are pooled to serve multiple consumers using a multi-tenant model, and different physical and virtual resources are dynamically allocated and reallocated based on demand. Location independence exists because consumers typically cannot control or know the exact location of the resources provided, but may be able to specify the location at a higher level of abstraction (e.g., country, state, or data center).

[0090] Rapid and elastic: Features can be dynamically configured (and in some cases automatically) quickly and flexibly to scale up rapidly, and released quickly to scale down rapidly. For consumers, the capabilities available for dynamic deployment often appear unlimited, and any quantity can be purchased at any time.

[0091] Measurement services: Cloud systems automatically control and optimize resource usage by leveraging metering capabilities at a level of abstraction appropriate to the service type (e.g., storage, processing, bandwidth, and active user accounts). Resource usage can be monitored, controlled, and reported, providing transparency to both service providers and consumers.

[0092] The service model is as follows:

[0093] Software as a Service (SaaS): The functionality provided to consumers is the use of the provider's applications running on cloud infrastructure. These applications can be accessed from various client devices through 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 system, storage devices, or even individual application functionality, with possible exceptions such as limited user-specific application configuration settings.

[0094] Platform as a Service (PaaS): This provides consumers with the ability to deploy applications created or acquired by the consumer onto cloud infrastructure. These applications are created using programming languages ​​and tools supported by the provider. Consumers do not manage or control the underlying cloud infrastructure, including networks, servers, operating systems, or storage, but they have control over the deployed applications and the configuration of any application hosting environments.

[0095] Infrastructure as a Service (IaaS): The functionality provided to consumers includes processing, storage, networking, and other basic computing resources that enable consumers to deploy and run any software, which may include operating systems and applications. Consumers do not manage or control the underlying cloud infrastructure, but they have control over the operating system, storage devices, deployed applications, and possibly limited control over selected networking components (e.g., host firewalls).

[0096] The deployment model is as follows:

[0097] Private cloud: Cloud infrastructure operated solely by an organization. It can be managed by the organization or a third party, and can exist internally or externally.

[0098] Community cloud: A cloud infrastructure shared by several organizations and supporting a specific community with shared concerns (e.g., tasks, security requirements, policies, and compliance considerations). It can be managed by an organization or a third party and can exist internally or externally.

[0099] Public cloud: Cloud infrastructure available to the general public or large industry groups and owned by the organization that sells cloud services.

[0100] Hybrid cloud: A cloud infrastructure is a combination of two or more clouds (private, community, or public) that remain a single entity but are bound together by standardized or proprietary technologies that enable data and applications to be ported (e.g., cloud bursts for load balancing between clouds).

[0101] Cloud computing environments are service-oriented, emphasizing statelessness, loose coupling, modularity, and semantic interoperability. At the heart of cloud computing is the infrastructure of a network of interconnected nodes.

[0102] Now for reference Figure 8The diagram illustrates an illustrative cloud computing environment 800. As shown, the cloud computing environment 800 includes one or more cloud computing nodes 810 that can communicate with local computing devices used by a cloud consumer, such as, for example, a personal digital assistant (PDA) or cellular phone 854A, a desktop computer 854B, a laptop computer 854C, and / or an automotive computer system 854N. The nodes 810 can communicate with each other. They can be physically or virtually grouped (not shown) in one or more networks, such as private clouds, community clouds, public clouds, or hybrid clouds, or combinations thereof, as described above. This allows the cloud computing environment 850 to provide infrastructure, platform, and / or software as a service, without requiring the cloud consumer to maintain resources on their local computing devices. It should be understood that... Figure 8 The types of computing devices 854A-N shown are for illustrative purposes only, and computing node 810 and cloud computing environment 850 can communicate with any type of computing device via any type of network and / or network-addressable connection (e.g., using a web browser).

[0103] Now for reference Figure 9 This demonstrates the 850 (cloud computing environment) Figure 8 This provides a set of functional abstraction layers. It should be understood beforehand that... Figure 9 The components, layers, and functions shown are for illustrative purposes only, and embodiments of this disclosure are not limited thereto. As depicted, the following layers and corresponding functions are provided:

[0104] The hardware and software layer 960 includes hardware and software components. Examples of hardware components include: a mainframe 961; a RISC (Reduced Instruction Set Computer) based server 962; a server 963; a blade server 964; a storage device 965; and a network and networking component 966. In some embodiments, the software components include network application server software 967 and database software 968.

[0105] The virtualization layer 970 provides an abstraction layer from which the following examples of virtual entities can be provided: virtual servers 971; virtual storage 972; virtual networks 973, including virtual private networks; virtual applications and operating systems 974; and virtual clients 975.

[0106] In one example, management layer 980 can provide the functionality described below. Resource Provisioning 981 provides dynamic procurement of computing resources and other resources used to perform tasks within the cloud computing environment. Metering and Pricing 982 provides cost tracking for resource utilization within the cloud computing environment, as well as invoicing or issuing invoices for the consumption of these resources. In one example, these resources may include application software licenses. Security provides authentication for cloud consumers and tasks, as well as protection for data and other resources. User Portal 983 provides access to the cloud computing environment for customers and system administrators. Service Level Management 984 provides cloud resource allocation and management to ensure the required service level is met. Service Level Agreement (SLA) Planning and Fulfillment 985 provides pre-scheduling and procurement of cloud resources for anticipated future needs according to the SLA.

[0107] Workload tier 990 provides examples of functionalities that can be leveraged in a cloud computing environment. Examples of workloads and functionalities that can be provided from this tier include: mapping and navigation 991; software development and lifecycle management 992; virtual classroom education delivery 993; data analytics and processing 994; transaction processing 995; and interpretable modeling 996, as discussed in this paper.

[0108] in conclusion

[0109] Various embodiments of this teaching have been described for illustrative purposes, but are not intended to be exhaustive or limited to 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 terminology used herein has been chosen to best describe the principles of the embodiments, their practical application in the market, or technical improvements, or to enable others skilled in the art to understand the embodiments disclosed herein.

[0110] While the foregoing has described what is considered the best-case scenario and / or other instances, it should be understood that various modifications may be made therein, and the subject matter disclosed herein can be implemented in various forms and examples, and the teachings can be applied to many applications, of which only a few are described herein. The appended claims are intended to claim protection for any and all applications, modifications, and variations that fall within the true scope of this teaching.

[0111] The components, steps, features, purposes, benefits, and advantages discussed herein are merely illustrative. No single one of these or any related discussion is intended to limit the scope of protection. While various advantages have been discussed herein, it is understood that not all embodiments are necessarily intended to include all advantages. Unless otherwise stated, all measurements, values, ratings, positions, amplitudes, dimensions, and other specifications set forth in this specification, including those in the appended claims, are approximate and not precise. They are intended to have a reasonable range consistent with the functionality associated with them and with the conventions of the art to which they pertain.

[0112] Many other embodiments have also been considered. These embodiments include those with fewer, additional, and / or different components, steps, features, purposes, benefits, and advantages. These embodiments also include those in which components and / or steps are arranged and / or ordered in different ways.

[0113] According to embodiments of this disclosure, aspects of this disclosure are described herein with reference to call flowcharts and / or block diagrams of methods, apparatus (systems), and computer program products. It will be understood that each step of the flowchart and / or block diagram, and combinations of boxes in the call flowchart and / or block diagram, can be implemented by computer-readable program instructions.

[0114] These computer-readable program instructions may be provided to a computer, a special-purpose computer processor, or other programmable data processing apparatus to produce a machine, such that the instructions are executed via the computer's processor or other programmable data processing apparatus to create components for implementing the functions / actions specified in one or more blocks of a call flow and / or block diagram. These computer-readable program instructions may also be stored in a computer-readable storage medium that can instruct a computer, programmable data processing apparatus, and / or other device to operate in a particular manner, such that the computer-readable storage medium having the instructions stored therein includes a product comprising instructions for implementing the functions / actions specified in one or more blocks of a call flow and / or block diagram.

[0115] Computer-readable program instructions may also be loaded onto a computer, other programmable data processing apparatus or other device to cause a series of operational steps to be performed on the computer, other programmable apparatus or other device to produce a computer-implemented process, such that the instructions, which execute on the computer, other programmable apparatus or other device, implement the functions / actions specified in one or more blocks of a call flow procedure and / or block diagram.

[0116] The flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of the present disclosure. In this regard, each block in a call flow or block diagram may represent a portion of a module, segment, or instruction, which includes one or more executable instructions for implementing a specified logical function. In some alternative embodiments, the functions indicated in the blocks may occur in a non-linear order as shown in the figures. For example, two blocks shown consecutively may actually be executed substantially simultaneously, or these blocks may sometimes be executed in reverse order, depending on the functions involved. It will also be noted that each block in the block diagrams and / or call flow diagrams, and combinations of blocks in the block diagrams and / or call flow diagrams, may be implemented by a dedicated hardware-based system that performs the specified function or action or executes a combination of dedicated hardware and computer instructions.

[0117] While the foregoing has been described in conjunction with exemplary embodiments, it should be understood that the term "exemplary" means only as an example, and not the best or optimal. Except as stated above, whether or not it is stated in the claims, nothing in any statement or description is intended or should be construed as causing any component, step, feature, object, benefit, advantage, or equivalent to be made public.

[0118] It should be understood that, unless otherwise specified herein, the terms and expressions used herein have the general meaning consistent with those in the respective fields of investigation and research. Relational terms such as "first" and "second" may be used merely to distinguish one entity or action from another, without necessarily requiring or implying any actual such relationship or order between these entities or actions. The terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that includes a list of elements includes not only those elements but may also include other elements not expressly listed or inherent to such a process, method, article, or apparatus. Without further limitation, an element preceded by "a" or "an" does not exclude the presence of additional identical elements in the process, method, article, or apparatus that includes that element.

Claims

1. A method for training an interpretable deep learning model for a machine learning system, comprising: Receive an input dataset, which includes images; The input dataset is provided to the deep neural network model; Features are extracted from the deep neural network model; Generate a latent space that includes vectors of the extracted features; The latent space into which vectors are fed to a task-specific model, which is a low-complexity learning model; and Interpretable predictions for feature dimensions are generated from the task-specific model.

2. The method of claim 1, wherein the feature is extracted using an encoder module.

3. The method of claim 1, wherein the latent space of the vectors is a disentangled representation of the input dataset.

4. The method of claim 1, further comprising using a beta variational autoencoder to extract the features from the deep neural network.

5. The method according to claim 1, further comprising: Associate the feature dimensions of each vector in the latent space with semantically meaningful properties; as well as The interpretable predictions for the feature dimensions are generated based on the semantically meaningful properties of each vector.

6. A computer program product for training an interpretable deep learning model for a machine learning system, the computer program product comprising: Program instructions, the program instructions being used for: Receive an input dataset, which includes images; The input dataset is provided to the deep neural network model; Features are extracted from the deep neural network model; Generate a latent space that includes vectors of the extracted features; The latent space into which vectors are fed to a task-specific model, which is a low-complexity learning model; and Interpretable predictions for feature dimensions are generated from the task-specific model.

7. The computer program product of claim 6, wherein the feature is extracted using an encoder module.

8. The computer program product of claim 6, wherein the latent space of the vectors is a disentangled representation of the input dataset.

9. The computer program product of claim 6, wherein the program instructions are further configured to extract the features from the deep neural network using a beta variational autoencoder.

10. The computer program product of claim 6, wherein the program instructions are further configured to: Associating the feature dimensions of each vector in the latent space with semantically meaningful properties; and The interpretable predictions for the feature dimensions are generated based on the semantically meaningful properties of each vector.

11. A computer server, comprising: Network connectivity; One or more computer-readable storage media; A processor, the processor being coupled to the network connection and to the one or more computer-readable storage media; as well as A computer program product, comprising program instructions stored together on the one or more computer-readable storage media, the program instructions being used for: Receive an input dataset, which includes images; The input dataset is provided to the deep neural network model; Features are extracted from the deep neural network model; Generate a latent space that includes vectors of the extracted features; The latent space into which vectors are fed to a task-specific model, which is a low-complexity learning model; and Interpretable predictions for feature dimensions are generated from the task-specific model.

12. The computer server of claim 11, wherein the feature is extracted using an encoder module.

13. The computer server of claim 11, wherein the latent space of the vectors is a disentangled representation of the input dataset.

14. The computer server of claim 11, wherein the program instructions are further configured to extract the features from the deep neural network using a beta variational autoencoder.

15. The computer server of claim 11, wherein the program instructions are further configured to: Associating the feature dimensions of each vector in the latent space with semantically meaningful properties; and The interpretable predictions for the feature dimensions are generated based on the semantically meaningful properties of each vector.

16. A method for training an interpretable deep learning model for a machine learning system, comprising: Receive an input dataset, which includes images; The input dataset is provided to the beta variational autoencoder; The beta variational autoencoder generates the output representation of the input dataset; The output representation is processed using a low-complexity learning model; The low-complexity learning model determines the task-specific output dataset; as well as The interpretation of the input dataset is provided based on the task-specific output dataset.

17. The method of claim 16, wherein the output representation of the input dataset generated by the beta variational autoencoder is a latent space of dimensional vectors organized by features having semantic relationships.

18. The method of claim 16, further comprising: The input dataset is reconstructed using the decoder module; The reconstruction error loss is determined based on the reconstructed input dataset; Determine the classification loss or regression loss from the task-specific output dataset; as well as The beta variational autoencoder, the decoder module, and the low-complexity learning model are trained using a combination of the reconstruction error loss and the classification loss or the regression loss.

19. The method of claim 16, wherein the low-complexity learning model is one of the following: Parametric models, nonparametric models, decision trees, regression trees, or ensemble models.

20. A computer program product for training an interpretable deep learning model for an artificial intelligence computing system, the computer program product comprising: Program instructions, the program instructions being used for: Receive an input dataset, which includes images; The input dataset is provided to the beta variational autoencoder; The beta variational autoencoder generates the output representation of the input dataset; The output representation is processed using a low-complexity learning model; The low-complexity learning model determines the task-specific output dataset; as well as The interpretation of the input dataset is provided based on the task-specific output dataset.

21. The computer program product of claim 20, wherein the program instructions are further configured to: The input dataset is reconstructed using the decoder module; The reconstruction error loss is determined based on the reconstructed input dataset; Determine the classification loss or regression loss from the task-specific output dataset; and The beta variational autoencoder, the decoder module, and the low-complexity learning model are trained using a combination of the reconstruction error loss and the classification loss or the regression loss.

22. The computer program product of claim 20, wherein the low-complexity learning model is one of the following: a parametric model, a non-parametric model, a decision tree, a regression tree, or an ensemble model.

Images