Patent Grant
12164599
Image analysis is becoming increasingly important in industries such as the medical industry. Devices such as computed tomography (CT) and magnetic resonance imaging (MRI) systems can generate images including three-dimensional information that can be used to model and make measurements of objects, such as human organs. In order to make the necessary measurements, however, it is often necessary to determine the portion (e.g., the subset of pixels or voxels) of the image that corresponds to the object of interest. Conventional segmentation approaches can attempt to determine the relevant portion, but results are not always accurate which can lead to misdiagnosis or other such issues.
Various embodiments in accordance with the present disclosure will be described with reference to the drawings, in which:
In the following description, various embodiments will be described. For purposes of explanation, specific configurations and details are set forth in order to provide a thorough understanding of the embodiments. However, it will also be apparent to one skilled in the art that the embodiments may be practiced without the specific details. Furthermore, well-known features may be omitted or simplified in order not to obscure the embodiment being described.
Deep learning has achieved great successes in various computer vision tasks, such as two-dimensional (2D) image recognition and semantic segmentation. However, deep networks usually rely on large-scale labeled datasets to train on. When it comes to three-dimensional (3D) data, such as medical volumetric data and point clouds, human labeling can be extremely costly. For example, the rapid growth in the demand of finer and larger scale of Computer Aided Diagnoses (CAD) for medical image has let to 3D segmentation of these images (such as for computed tomography (CT) and magnetic resonance imaging (MRI) scans) being a critical step in biomedical image analysis and surgical planning. Well-annotated segmentation labels in medical images require high-level expertise of radiologists and careful manual labeling on the contours and boundaries. Therefore, semi-supervised approaches with unlabeled data occupying a large portion of the training data are worth exploring especially in this targeted field.
The analysis and planning may often require one or more applications to perform automatic volumetric quantification of one or more parameters of various three-dimensional objects. This can include, for example, quantifying human organ sizes using medical imaging for clinical workflows.
Accordingly, approaches in accordance with various embodiments present deep learning architectures that can provide for such training. Various embodiments can provide for semi-supervised volumetric segmentation. A multi-view volumetric co-training strategy can be utilized in various embodiments wherein a multi-view constraint loss is built on top of a set of branches. In one embodiment these branches are asymmetric branches, such as may comprise two-dimensional (2D)-initialized three-dimensional 3D branches with different views of the input. These views can include, for example, axial, sagittal, and coronal views, among other such options. The branches can utilize the advantage and the bias of two-dimensional networks. Multi-view networks can be used that are intrinsically different and complementary, leading to a large-margin improvement over existing three-dimensional semi-supervised segmentation approaches. In some embodiments the approach can be further applied to fully-supervised settings with multi-view constraint loss to assist training. In some embodiments initialization can be important in training a robust three-dimensional model. The segmentation can result in the volumetric data, such as voxels, being classified into one of at least two classifications, such as “object” or “non-object/background,” effectively creating a segmentation mask for the data, which can be binary in some embodiments.
Various semi-supervised approaches have been successfully applied to image recognition. These algorithms are mostly based on adding regularization terms and training networks resistant to specific noise, acting as an additional supervision signal for unlabeled data. Some of these approaches extended co-training into deep networks, using adversarial examples to prohibit grouped networks from collapsing into each other. In some embodiments semi-supervised analysis consists of three parts, including self-training, co-training, and graph-based approached. As volumetric data contains richer information, variant transformations of data are harder for deep networks to capture. Approaches in accordance with various embodiments can transfer the idea of deep co-training into volumetric data. Instead of using adversarial examples in 2D images, approaches are provided that encourage complementary information learned by 3D deep networks.
Two-dimensional networks and three-dimensional 3D networks both have their advantages and limitations. The former benefits from the 2D pre-trained weights and well-studied architectures in natural images, while the latter better explores 3D information with 3D convolutional kernels. It is possible for a 3D architecture to be used that is initialized by pre-trained 2D models. Moreover, multi-view 2D training can be proven effective by averaging multi-view results, indicating that complementary latent information exists in the biases of 2D networks. However, these approaches are unable to train multi-view networks jointly, in an end-to-end fashion. Accordingly, approaches in accordance with various embodiments can provide for the training of 3D multi-view networks with 2D initializations jointly as an additional loss function for multi-view networks to learn from each other.
An example framework in accordance with various embodiments can provide for multi-view volumetric co-training (MVCT). An illustration of such architecture 200 is provided in
In at least some embodiments, a multi-view constraint loss can be built over this multi-branch model, which is similar to a co-training framework. If X∈S, such that the input volume is part of the labeled portion, then a supervised loss function Lsup can be optimized. Otherwise, if the input data volume is part of the unlabeled portion without ground truth data, or X∈U, then multi-view constraints can be used as additional supervision, optimizing a co-training loss Lcot., which in the figure is illustrated as feeding back into the prediction score maps 208.
For the supervised portion, and following with the same notation, X∈D is a sample volume of the training set given by:
Pc=Tc−1(fc(Tc(X);θc))
Ps=Ts−1(fs(Ts(X);θs))
Pa=Ta−1(fa(Ta(X);θa))
where Tc, Ts, and Ta denote the transpose operation from the original input volume to the coronal, sagittal, and axial view volumes, respectively. On the supervised dataset S, each X has a ground truth voxel-wise label Y. For each of the single-view sub-networks, the Dice loss can be used as the training objective, which can be given by:
where yi and ŷi represent the ground truth label and the network prediction, respectively. The Dice loss can perform robustly with imbalanced training data. More importantly, a loss such as the Dice loss can be used to mitigate the gap between the training objective and the evaluation metrics. The loss function for supervised data then can be given by:
The co-training assumption in some embodiments can then be modeled in the semi-supervised volumetric segmentation settings. An example co-training strategy can assume that the predictions on each view should reach a consensus, so the similarity among Pc, Ps, and Pa should be modeled and it should be expected that networks in the three branches will produce similar results, even though input is received of multiple views (after being transposed back into the same direction). On par with the fully supervised part, a similarity measurement can be utilizes a Dice-Sørensen coefficient (DSC). The co-training loss can then be given by:
In this example the co-training loss is only minimized on unlabeled data. Since the Dice loss was already optimized on the supervised data to force the network prediction to be close to the ground truth, there is no need in this example to enforce the co-training assumption again under such semi-supervised settings. It may be the case, however, that the co-training loss can help each branch to learn better features on supervised data. The improvement may be negligible with respect to the limited supervised data available for various semi-supervised settings.
The framework 300 of
Approaches in accordance with various embodiments can utilize an uncertainty-aware multi-view co-training (UMCT) framework 300, as illustrated in
The framework can also include capability for view confidence estimation. In such a framework, the uncertainty of each view prediction with Bayesian deep networks can be estimated by adding dropout into the architecture. In one example, a confidence score can be computed based on epistemic uncertainty, which can act as an attention mechanism for each prediction. After propagation through an uncertainty-aware attention module (UAM), for example, a set of more accurate pseudo labels can be obtained for each view, which can provide for improved co-training. The term “multi-view” as used herein thus can have multiple meanings. A first meaning corresponds to “multi-view learning” as known for machine learning. Another meaning corresponds to “multi-viewpoint analysis” of 3D data as known for computer vision.
The following provides another approach to the task of semi-supervised learning for 3D data that can be used with the framework 300 of , with unlabeled data denoted as X∈
. The ground truth Y can either be a ground truth label (classification tasks) or dense prediction map (segmentation tasks). Suppose for each input X, there are N views denoted as vi(⋅)=1, . . . , N. Different views of the 3D data can be naturally generated by rotating the data into multiple viewpoints as discussed above, which can introduce data-level view differences. The process can then train N models fi(⋅), i=1, . . . , N over each view of data. If (X, Y)∈
, then a supervised loss function
sup is optimized, measuring the similarity between the prediction of each view (data-model combination) pi(X)=fi(vi(X)) and Y as
where is a standard loss function for a supervised learning task (e.g., classification, or segmentation).
A co-training assumption can then be constructed in the semi-supervised setting. The co-training strategy can assume the prediction on each view should reach a consensus, such that the prediction 308 of each model 306 can act as a pseudo label to supervise other views, in order to learn from unlabeled data. Since the prediction of each view is expected to be diverse after boosting view differences, the confidence of each view can be measured before generating trustworthy pseudo labels. This can be accomplished in some embodiments using an uncertainty-aware attention module (UAM), as may be designed for deep neural networks in our framework. With UAM, the co-training loss can be formulated in the following format:
where
Ŷi=Uf
is the pseudo label for the ith view, Uf
The following combined loss function then can be optimized:
Encouraging view difference can mean enlarging the variance of each view prediction var(pi(X)). This can raise the question of which view should be trusted to continue with the co-training. Inaccurate predictions from one view may hurt the training procedure of other views through pseudo-label assignments. Meanwhile, encouraging trust in an accurate prediction as a “strong” label from co-training can help to boost performance, and can lead to improved performance of the overall semi-supervised learning process. Instead of assigning a pseudo-label for each view directly from the predictions of other views, an adaptive approach can be utilized through the uncertainty-aware attention module to fuse the outputs of different views. The attention module can be built up of all the views, taking the prediction of each view as input and outputting a set of pseudo labels for each view.
The uncertainty of each view branch for each training sample can be measured in some embodiments after turning the model into a Bayesian deep network by adding dropout layers. Between two types of uncertainty candidates, including aleatoric and epistemic uncertainties in this example, the process can compute the epistemic uncertainty that is raised by not having enough training data. Such measurement can fit a semi-supervised learning goal of improving model generalizability by exploring unlabeled data. If, for example, y is the output of a Bayesian deep network, then the epistemic uncertainty can be estimated by the following equation:
where {ŷt}t=1T are a set of sampled outputs.
With a transformation function h(⋅), the uncertainty score can be transformed into a confidence score c(y)=h(Ue(y)). After normalization over all views, the confidence score can act as an attention weight for each prediction to assign as a pseudo label for other views. The pseudo label Ŷi assigned for a single view i can be formatted as, for example:
Depending at least in part upon the type of data, values 310 used can then correspond to the ground truth data or the pseudo label for a given view.
In the specific scenario of medical image segmentation, the input data can correspond to a 3D volume. In order to generate multi-view data, the data volume X can be used to generate multiple views, as discussed previously.
In order to avoid such conditions, view difference can be encouraged at the feature level by designing a task-specific model. In some embodiments 2D-initialized asymmetric 3D models can be used for the backbone network of each view to encourage diverse features for each view learning, as discussed above. Such a structure can make the model convenient to be initialized with 2D pre-trained weights and fine-tuned in a 3D fashion. In some embodiments the rotated volumes can be forwarded into such deep networks {fi(⋅)}i=1N with parameters {θi}i=1N and the outputs of the networks rotated back to align them into a common view. {pi(X)}i=1N are the corresponding voxel-wise prediction score maps:
pi(X)=Ti−1(fi(Ti(X);θi)),
where Ti denotes the ith rotation operation to generate multi-view inputs. On the supervised dataset , each X has a ground truth voxel-wise label Y. For each of the single-view sub-network, the Dice loss as the training objective, as defined above. As mentioned, the Dice loss can perform robustly with imbalanced training data, and can be used to mitigate the gap between the training objective and commonly used evaluation metrics, such as Dice score.
In terms of view confidence estimation, the network can be modified into a Bayesian deep network by adding dropout operations as discussed elsewhere herein. In one example T=10 outputs can be sampled for each view and voxel-wise epistemic uncertainty computed. Since the voxel-wise uncertainty can be inaccurate, the sum can be performed over the entire volume to finalize the uncertainty for each view. The reciprocal for the confidence transformation function h(⋅) can be used to compute the confidence score. The pseudo label assigned for one view can be a weighted average of all predictions of multiple views based on the normalized confidence score. After obtaining the pseudo label set {Ŷi}i=1N the network parameters {θi}i=1N can be N optimized.
In the training phase, the combined loss algorithm can be optimized by gradient descent. For each iteration, a labeled batch bl= (xl, yl) and an unlabeled batch bu=(xu) can be sampled. Gradients can first be computed using the supervised loss function after forwarding the labeled batch, and then gradients aggregated after forwarding the gradients from the unlabeled loss function. The network parameters can be updated at the end of each iteration, such as by using the following algorithm, which can be used for uncertainty-aware multi-view co-training in accordance with at least one embodiment:
Example Algorithm:
Input:
Model of each view f1, . . . , fn
In one embodiment, a neural network can comprise an encoder-decoder network based on ResNet-18, which is modified into a 3D version. For encoder part, the first 7×7 convolutional layer can be inflated into 7×7×7 kernels for low level 3D feature extraction. All other 3×3 convolutional layers can be changed into 3×3×1 that can be trained in as a 3D convolutional layer. In the decoder part, three skip connections can be adopted from the encoder, followed by 3D convolutions to give low level cues for more accurate boundary prediction needed in segmentation tasks.
With respect to data pre-processing, the training and testing data can be re-sampled to an isotropic volume resolution, such as 1.0 mm for each axis in some embodiments. Data intensities are normalized to have zero mean and unit variance. Patch-based training can be utilized, with sample training patches of size 963 with 1:1 ratio between foreground and background. Unlike other 3D segmentation approaches, such an approach does not rely on any kind of 3D data augmentation due to the effectiveness of initialization with 2D pre-trained weights.
In training approaches in accordance with various embodiments, the views can first be trained separately on the labeled data, and then UMCT conducted by fine-tuning the weights. A stochastic gradient descent (SGD) optimizer can be used for both stages. In the view-wise training stage, a constant learning rate policy can be adopted at 7×10−3, momentum at 0.9, and weight decay of 4×10−5 for 20k iterations. In the co-training stage, a constant learning rate policy can be adopted at 1×10−3, with the parameter λcot=0.2, training for 5k iterations. The batch size can be four for both stages. Such a framework can be implemented in PyTorch, for example, with the training procedure executing on processors such as four NVIDIA Titan V GPUs. As mentioned, the testing can follow a coarse-to-fine strategy using a sliding window approach. In order to reduce the inference time, a coarse stride of 48 can be employed, followed by a fine stride of 16, using the same size patch and resolution as in training. The testing results can then be re-sampled back to the original image resolution to obtain the final results.
A UMCT approach in accordance with various embodiments can also be applied to fully supervised training. For semi-supervised tasks, there may not be significant improvement when enforcing cot on labeled data due in part to the quantity limitation. However, when data quantity is large, UMCT can guide each 2D-initialized branch to help each other by enforcing 3D consistency. A full framework for fully supervised training can be obtained by training three networks of different views, and then fine-tuning with a loss function such as the following:
=Σ(X,Y)∈
[
sup(X,Y)+λ
cot(X)],
Without any hyper parameter change allowed, it can be desirable in at least some embodiments for a model to be generalizable and robust to various tasks. Model described herein can satisfy such requirements, as such a model, although trained in 3D patches, can be initialized from 2D pre-trained models. Further, there are multiple views of networks with cot used to help each other gaining more 3D information through the UMCT process. These characteristics help to boost the robustness of the model on supervised volumetric segmentation tasks.
In this example, the volumetric data is processed using a multi-view generator, for example, to generate 604 multiple views of the object. For medical imaging this may include three distinct views as discussed above, but for other applications may include two or more views. There may be no upper limit on the number of views utilized, although for most applications the additional benefit will decrease as the number of views exceeds a certain amount. These views can include two-dimensional images representative of views from specific viewpoints of the object in some embodiments. Each of these views can be provided 606 to a set of neural networks in this example. The networks can be the same for each view, or in some embodiments can be trained for specific views or orientations, such as where specific views are used for every object imaged for a specific purpose or entity. A set of properties can be generated 608, or inferred, by the networks in parallel. As discussed herein, these can include properties of features determined for the image data, where those properties can relate to aspects such as segmentations, classifications, or regressions, among other such options. A set of loss values can be computed 610 using a co-training loss function that compares the predictions from the set of networks. As mentioned, the results of one network for a view can be used as a pseudo-label, or quasi-ground truth, for purposes of determining the loss. The relevant network parameters, such as the weight parameters for an overall loss function for the primary image analysis network, can be updated 612 using the relevant loss values.
In this example, the volumetric data is processed using a multi-view generator, for example, to generate 704 a set of multi-view inputs for the object, corresponding to multiple views of the object for determined viewpoints or orientations. As mentioned, the views can include two-dimensional images representative of views from specific viewpoints of the object in some embodiments. The multi-view inputs can be provided 706 to a set of neural networks in this example. The networks can be the same for each view, or trained for specific views or orientations, as discussed elsewhere herein. A set of segmentations inferences can be generated 708 by the networks in parallel. From the inferences, a set of pseudo-labels can be computed 710 for the unlabeled data, which can function as a quasi-ground truth for comparison. A supervised loss can then be computed 712 where there is labeled data, using a supervised loss function. A co-training loss can also be computed 714, using the pseudo-labels, where there is unlabeled data, using a co-training loss function. The gradient of an overall loss function can then be computed 716, where the overall loss function is a combination of the supervised and/or co-training loss, where available. If there is no supervised or co-training loss, then the overall loss will then be a factor of only the other loss. The relevant network parameters can then be updated 718 through backpropagation, where the network parameters can include weight or bias parameters of the overall loss function. In this example the models are also returned 720 for each view for use in subsequent training or inference. If it is determined 722 that an end condition is not satisfied then the process can continue. Otherwise, the result(s) can be provided for analysis, as may include further training and/or inference.
In this example, a user is able to submit requests across at least one network 804 to be received to a provider environment 806. The client device may be any appropriate electronic and/or computing devices enabling the user to generate and send such requests, as may include desktop computers, notebook computers, computer servers, smartphones, tablet computers, gaming consoles (portable or otherwise), computer processors, computing logic, and set-top boxes, among other such options. The network(s) 804 can include any appropriate network for transmitting the request or other such data, as may include the Internet, an intranet, an Ethernet, a cellular network, a local area network (LAN), a network of direct wireless connections among peers, and the like.
Requests can be received to an interface layer 808, which can forward the data to a content manager 810 in this example. The content manager can be a system or service including hardware and software for managing requests and service corresponding data or content in at least some embodiments. The content manager can receive a request to train a neural network, and can provide data for the request to a training manger 812. The training manager 812 can select an appropriate model or network to be used, if not specified by the request, and can train the model using relevant training data. In some embodiments the training data can be a batch of data stored to a training data repository 814, received from the client device 802 or obtained from a third party provider 824, among other such options. The training manager 812 can be responsible for training the data, such as by using a LARC-based approach as discussed herein. The network can be any appropriate network, such as a recurrent neural network (RNN) or convolutional neural network (CNN), among other such options. Once a network is trained and successfully evaluated, the trained network can be stored to a model repository 816, for example, that may store different models or networks for users, applications, or services, etc. As mentioned, in some embodiments there may be multiple models for a single application or entity, as may be utilized based on a number of different factors.
At a subsequent point in time, a request may be received from the client device 802 (or another such device) for content or data that is at least partially determined or impacted by the trained neural network. The request can include, for example, input data to be processed using the neural network to obtain one or more inferences or other output values, classifications, or predictions. The input data can be received to the interface layer 808 and directed to the inference module 818, although a different system or service can be used as well in various embodiments. The inference module 818 can obtain the appropriate trained network, such as a trained deep neural network (DNN) as discussed herein, from the model repository 816 if not already stored locally to the inference module 818. The inference module 818 can provide the data as input to the trained network, which can then generate one or more inferences as output. This may include, for example, a classification of an instance of the input data. The inferences can then be transmitted to the client device 802 for display or other communication to the user. Context data for the user may also be stored to a user context data repository 822, which may include data about the user which may be useful as input to the network in generating the inferences, or determining the data to return to the user after obtaining the instances, among other such options. Relevant data, which may include at least some of the input or inference data, may also be stored to a local database 820 for processing future requests. In some embodiments, the user can use account or other information to access resources or functionality of the provider environment. If permitted and available, user data may also be collected and used to further train the models, in order to provide more accurate inferences for future requests. Requests may be received through a user interface to a machine learning application 826 executing on the client device 802 in some embodiments, and the results displayed through the same interface. The client device can include resources such as a processor 828 and memory 830 for generating the request and processing the results or response, as well as at least one data storage element 832 for storing data for the machine learning application 826.
In various embodiments a processor 828 (or a processor of the training manager 812 or inference module 818) will be a central processing unit (CPU). As mentioned, however, resources in such environments can utilize GPUs to process data for at least certain types of requests. With thousands of cores, GPUs are designed to handle substantial parallel workloads and, therefore, have become popular in deep learning for training neural networks and generating predictions. While the use of GPUs for offline builds has enabled faster training of larger and more complex models, generating predictions offline implies that either request-time input features cannot be used or predictions must be generated for all permutations of features and stored in a lookup table to serve real-time requests. If the deep learning framework supports a CPU-mode and the model is small and simple enough to perform a feed-forward on the CPU with a reasonable latency, then a service on a CPU instance could host the model. In this case, training can be done offline on the GPU and inference done in real-time on the CPU. If the CPU approach is not a viable option, then the service can run on a GPU instance. Because GPUs have different performance and cost characteristics than CPUs, however, running a service that offloads the runtime algorithm to the GPU can require it to be designed differently from a CPU based service.
As mentioned, various embodiments take advantage of machine learning. As an example, deep neural networks (DNNs) developed on processors have been used for diverse use cases, from self-driving cars to faster drug development, from automatic image captioning in online image databases to smart real-time language translation in video chat applications. Deep learning is a technique that models the neural learning process of the human brain, continually learning, continually getting smarter, and delivering more accurate results more quickly over time. A child is initially taught by an adult to correctly identify and classify various shapes, eventually being able to identify shapes without any coaching. Similarly, a deep learning or neural learning system needs to be trained in object recognition and classification for it get smarter and more efficient at identifying basic objects, occluded objects, etc., while also assigning context to objects.
At the simplest level, neurons in the human brain look at various inputs that are received, importance levels are assigned to each of these inputs, and output is passed on to other neurons to act upon. An artificial neuron or perceptron is the most basic model of a neural network. In one example, a perceptron may receive one or more inputs that represent various features of an object that the perceptron is being trained to recognize and classify, and each of these features is assigned a certain weight based on the importance of that feature in defining the shape of an object.
A deep neural network (DNN) model includes multiple layers of many connected perceptrons (e.g., nodes) that can be trained with enormous amounts of input data to quickly solve complex problems with high accuracy. In one example, a first layer of the DLL model breaks down an input image of an automobile into various sections and looks for basic patterns such as lines and angles. The second layer assembles the lines to look for higher level patterns such as wheels, windshields, and mirrors. The next layer identifies the type of vehicle, and the final few layers generate a label for the input image, identifying the model of a specific automobile brand. Once the DNN is trained, the DNN can be deployed and used to identify and classify objects or patterns in a process known as inference. Examples of inference (the process through which a DNN extracts useful information from a given input) include identifying handwritten numbers on checks deposited into ATM machines, identifying images of friends in photos, delivering movie recommendations to over fifty million users, identifying and classifying different types of automobiles, pedestrians, and road hazards in driverless cars, or translating human speech in real-time.
During training, data flows through the DNN in a forward propagation phase until a prediction is produced that indicates a label corresponding to the input. If the neural network does not correctly label the input, then errors between the correct label and the predicted label are analyzed, and the weights are adjusted for each feature during a backward propagation phase until the DNN correctly labels the input and other inputs in a training dataset. Training complex neural networks requires massive amounts of parallel computing performance, including floating-point multiplications and additions that are supported. Inferencing is less compute-intensive than training, being a latency-sensitive process where a trained neural network is applied to new inputs it has not seen before to classify images, translate speech, and generally infer new information.
Neural networks rely heavily on matrix math operations, and complex multi-layered networks require tremendous amounts of floating-point performance and bandwidth for both efficiency and speed. With thousands of processing cores, optimized for matrix math operations, and delivering tens to hundreds of TFLOPS of performance, a computing platform can deliver performance required for deep neural network-based artificial intelligence and machine learning applications.
A model can be trained in a number of different ways, as may depend in part upon the type of model selected. For example, in one embodiment a machine learning algorithm can be provided with a set of training data, where the model is a model artifact created by the training process. Each instance of training data contains the correct answer (e.g., classification), which can be referred to as a target or target attribute. The learning algorithm finds patterns in the training data that map the input data attributes to the target, the answer to be predicted, and a machine learning model is output that captures these patterns. The machine learning model can then be used to obtain predictions on new data for which the target is not specified.
In one example, a training manager 904 can select from a set of machine learning models including binary classification, multiclass classification, and regression models. The type of model to be used can depend at least in part upon the type of target to be predicted. Machine learning models for binary classification problems predict a binary outcome, such as one of two possible classes. A learning algorithm such as logistic regression can be used to train binary classification models. Machine learning models for multiclass classification problems allow predictions to be generated for multiple classes, such as to predict one of more than two outcomes. Multinomial logistic regression can be useful for training multiclass models. Machine learning models for regression problems predict a numeric value. Linear regression can be useful for training regression models.
In order to train a machine learning model in accordance with one embodiment, the training manager must determine the input training data source, as well as other information such as the name of the data attribute that contains the target to be predicted, required data transformation instructions, and training parameters to control the learning algorithm. During the training process, a training manager 904 in some embodiments may automatically select the appropriate learning algorithm based on the type of target specified in the training data source. Machine learning algorithms can accept parameters used to control certain properties of the training process and of the resulting machine learning model. These are referred to herein as training parameters. If no training parameters are specified, the training manager can utilize default values that are known to work well for a large range of machine learning tasks. Examples of training parameters for which values can be specified include the maximum model size, maximum number of passes over training data, shuffle type, regularization type, learning rate, and regularization amount. Default settings may be specified, with options to adjust the values to fine-tune performance.
The maximum model size is the total size, in units of bytes, of patterns that are created during the training of model. A model may be created of a specified size by default, such as a model of 100 MB. If the training manager is unable to determine enough patterns to fill the model size, a smaller model may be created. If the training manager finds more patterns than will fit into the specified size, a maximum cut-off may be enforced by trimming the patterns that least affect the quality of the learned model. Choosing the model size provides for control of the trade-off between the predictive quality of a model and the cost of use. Smaller models can cause the training manager to remove many patterns to fit within the maximum size limit, affecting the quality of predictions. Larger models, on the other hand, may cost more to query for real-time predictions. Larger input data sets do not necessarily result in larger models because models store patterns, not input data. If the patterns are few and simple, the resulting model will be small. Input data that has a large number of raw attributes (input columns) or derived features (outputs of the data transformations) will likely have more patterns found and stored during the training process.
In some embodiments, the training manager 904 can make multiple passes or iterations over the training data to attempt to discover patterns. There may be a default number of passes, such as ten passes, while in some embodiments up to a maximum number of passes may be set, such as up to one hundred passes. In some embodiments there may be no maximum set, or there may be a convergence criterion or other factor set that will trigger an end to the training process. In some embodiments the training manager 904 can monitor the quality of patterns (i.e., the model convergence) during training, and can automatically stop the training when there are no more data points or patterns to discover. Data sets with only a few observations may require more passes over the data to obtain sufficiently high model quality. Larger data sets may contain many similar data points, which can reduce the need for a large number of passes. The potential impact of choosing more data passes over the data is that the model training can takes longer and cost more in terms of resources and system utilization.
In some embodiments the training data is shuffled before training, or between passes of the training. The shuffling in many embodiments is a random or pseudo-random shuffling to generate a truly random ordering, although there may be some constraints in place to ensure that there is no grouping of certain types of data, or the shuffled data may be reshuffled if such grouping exists, etc. Shuffling changes the order or arrangement in which the data is utilized for training so that the training algorithm does not encounter groupings of similar types of data, or a single type of data for too many observations in succession. For example, a model might be trained to predict an object. The data might be sorted by object type before uploading. The algorithm can then process the data alphabetically by object type, encountering only data for a certain object type first. The model will begin to learn patterns for that type of object. The model will then encounter only data for a second object type, and will try to adjust the model to fit that object type, which can degrade the patterns that fit that the first object type. This sudden switch from between object types can produce a model that does not learn how to predict object types accurately. Shuffling can be performed in some embodiments before the training data set is split into training and evaluation subsets, such that a relatively even distribution of data types is utilized for both stages. In some embodiments the training manager 904 can automatically shuffle the data using, for example, a pseudo-random shuffling technique.
When creating a machine learning model, the training manager 904 in some embodiments can enable a user to specify settings or apply custom options. For example, a user may specify one or more evaluation settings, indicating a portion of the input data to be reserved for evaluating the predictive quality of the machine learning model. The user may specify a policy that indicates which attributes and attribute transformations are available for model training. The user may also specify various training parameters that control certain properties of the training process and of the resulting model.
Once the training manager has determined that training of the model is complete, such as by using at least one end criterion discussed herein, the trained model 908 can be provided for use by a classifier 914 in classifying (or otherwise generating inferences for) validation data 912. As illustrated, this involves a logical transition between a training mode for the model and an inference mode for the model. In many embodiments, however, the trained model 908 will first be passed to an evaluator 910, which may include an application, process, or service executing on at least one computing resource (e.g., a CPU or GPU of at least one server) for evaluating the quality (or another such aspect) of the trained model. The model is evaluated to determine whether the model will provide at least a minimum acceptable or threshold level of performance in predicting the target on new and future data. If not, the training manager 904 can continue to train the model. Since future data instances will often have unknown target values, it can be desirable to check an accuracy metric of the machine learning on data for which the target answer is known, and use this assessment as a proxy for predictive accuracy on future data.
In some embodiments, a model is evaluated using a subset of the training data 902 that was provided for training. The subset can be determined using a shuffle and split approach as discussed above. This evaluation data subset will be labeled with the target, and thus can act as a source of ground truth for evaluation. Evaluating the predictive accuracy of a machine learning model with the same data that was used for training is not useful, as positive evaluations might be generated for models that remember the training data instead of generalizing from it. Once training has completed, the evaluation data subset is processed using the trained model 908 and the evaluator 910 can determine the accuracy of the model by comparing the ground truth data against the corresponding output (or predictions/observations) of the model. The evaluator 910 in some embodiments can provide a summary or performance metric indicating how well the predicted and true values match. If the trained model does not satisfy at least a minimum performance criterion, or other such accuracy threshold, then the training manager 904 can be instructed to perform further training, or in some instances try training a new or different model, among other such options. If the trained model 908 satisfies the relevant criteria, then the trained model can be provided for use by the classifier 914.
When creating and training a machine learning model, it can be desirable in at least some embodiments to specify model settings or training parameters that will result in a model capable of making the most accurate predictions. Example parameters include the number of passes to be performed (forward and/or backward), regularization, model size, and shuffle type. As mentioned, however, selecting model parameter settings that produce the best predictive performance on the evaluation data might result in an overfitting of the model. Overfitting occurs when a model has memorized patterns that occur in the training and evaluation data sources, but has failed to generalize the patterns in the data. Overfitting often occurs when the training data includes all of the data used in the evaluation. A model that has been over fit may perform well during evaluation, but may fail to make accurate predictions on new or otherwise validation data. To avoid selecting an over fitted model as the best model, the training manager can reserve additional data to validate the performance of the model. For example, the training data set might be divided into 60 percent for training, and 40 percent for evaluation or validation, which may be divided into two or more stages. After selecting the model parameters that work well for the evaluation data, leading to convergence on a subset of the validation data, such as half the validation data, a second validation may be executed with a remainder of the validation data to ensure the performance of the model. If the model meets expectations on the validation data, then the model is not overfitting the data. Alternatively, a test set or held-out set may be used for testing the parameters. Using a second validation or testing step helps to select appropriate model parameters to prevent overfitting. However, holding out more data from the training process for validation makes less data available for training. This may be problematic with smaller data sets as there may not be sufficient data available for training. One approach in such a situation is to perform cross-validation as discussed elsewhere herein.
There are many metrics or insights that can be used to review and evaluate the predictive accuracy of a given model. One example evaluation outcome contains a prediction accuracy metric to report on the overall success of the model, as well as visualizations to help explore the accuracy of the model beyond the prediction accuracy metric. The outcome can also provide an ability to review the impact of setting a score threshold, such as for binary classification, and can generate alerts on criteria to check the validity of the evaluation. The choice of the metric and visualization can depend at least in part upon the type of model being evaluated.
Once trained and evaluated satisfactorily, the trained machine learning model can be used to build or support a machine learning application. In one embodiment building a machine learning application is an iterative process that involves a sequence of steps. The core machine learning problem(s) can be framed in terms of what is observed and what answer the model is to predict. Data can then be collected, cleaned, and prepared to make the data suitable for consumption by machine learning model training algorithms. The data can be visualized and analyzed to run sanity checks to validate the quality of the data and to understand the data. It might be the case that the raw data (e.g., input variables) and answer data (e.g., the target) are not represented in a way that can be used to train a highly predictive model. Therefore, it may be desirable to construct more predictive input representations or features from the raw variables. The resulting features can be fed to the learning algorithm to build models and evaluate the quality of the models on data that was held out from model building. The model can then be used to generate predictions of the target answer for new data instances.
In the example system 900 of
The classifier 914 can include appropriate hardware and software for processing the validation data 912 using the trained model. In some instances the classifier will include one or more computer servers each having one or more graphics processing units (GPUs) that are able to process the data. The configuration and design of GPUs can make them more desirable to use in processing machine learning data than CPUs or other such components. The trained model in some embodiments can be loaded into GPU memory and a received data instance provided to the GPU for processing. GPUs can have a much larger number of cores than CPUs, and the GPU cores can also be much less complex. Accordingly, a given GPU may be able to process thousands of data instances concurrently via different hardware threads. A GPU can also be configured to maximize floating point throughput, which can provide significant additional processing advantages for a large data set.
Even when using GPUs, accelerators, and other such hardware to accelerate tasks such as the training of a model or classification of data using such a model, such tasks can still require significant time, resource allocation, and cost. For example, if the machine learning model is to be trained using 100 passes, and the data set includes 1,000,000 data instances to be used for training, then all million instances would need to be processed for each pass. Different portions of the architecture can also be supported by different types of devices. For example, training may be performed using a set of servers at a logically centralized location, as may be offered as a service, while classification of raw data may be performed by such a service or on a client device, among other such options. These devices may also be owned, operated, or controlled by the same entity or multiple entities in various embodiments.
In this example network 1000, all nodes of a given layer are interconnected to all nodes of an adjacent layer. As illustrated, the nodes of an intermediate layer will then each be connected to nodes of two adjacent layers. The nodes are also referred to as neurons or connected units in some models, and connections between nodes are referred to as edges. Each node can perform a function for the inputs received, such as by using a specified function. Nodes and edges can obtain different weightings during training, and individual layers of nodes can perform specific types of transformations on the received input, where those transformations can also be learned or adjusted during training. The learning can be supervised or unsupervised learning, as may depend at least in part upon the type of information contained in the training data set. Various types of neural networks can be utilized, as may include a convolutional neural network (CNN) that includes a number of convolutional layers and a set of pooling layers, and have proven to be beneficial for applications such as image recognition. CNNs can also be easier to train than other networks due to a relatively small number of parameters to be determined.
In some embodiments, such a complex machine learning model can be trained using various tuning parameters. Choosing the parameters, fitting the model, and evaluating the model are parts of the model tuning process, often referred to as hyperparameter optimization. Such tuning can involve introspecting the underlying model or data in at least some embodiments. In a training or production setting, a robust workflow can be important to avoid overfitting of the hyperparameters as discussed elsewhere herein. Cross-validation and adding Gaussian noise to the training dataset are techniques that can be useful for avoiding overfitting to any one dataset. For hyperparameter optimization it may be desirable in some embodiments to keep the training and validation sets fixed. In some embodiments, hyperparameters can be tuned in certain categories, as may include data preprocessing (in other words, translating words to vectors), CNN architecture definition (for example, filter sizes, number of filters), stochastic gradient descent parameters (for example, learning rate), and regularization (for example, dropout probability), among other such options.
In an example pre-processing step, instances of a dataset can be embedded into a lower dimensional space of a certain size. The size of this space is a parameter to be tuned. The architecture of the CNN contains many tunable parameters. A parameter for filter sizes can represent an interpretation of the information that corresponds to the size of an instance that will be analyzed. In computational linguistics, this is known as the n-gram size. An example CNN uses three different filter sizes, which represent potentially different n-gram sizes. The number of filters per filter size can correspond to the depth of the filter. Each filter attempts to learn something different from the structure of the instance, such as the sentence structure for textual data. In the convolutional layer, the activation function can be a rectified linear unit and the pooling type set as max pooling. The results can then be concatenated into a single dimensional vector, and the last layer is fully connected onto a two-dimensional output. This corresponds to the binary classification to which an optimization function can be applied. One such function is an implementation of a Root Mean Square (RMS) propagation method of gradient descent, where example hyperparameters can include learning rate, batch size, maximum gradient normal, and epochs. With neural networks, regularization can be an extremely important consideration. As mentioned, in some embodiments the input data may be relatively sparse. A main hyperparameter in such a situation can be the dropout at the penultimate layer, which represents a proportion of the nodes that will not “fire” at each training cycle. An example training process can suggest different hyperparameter configurations based on feedback for the performance of previous configurations. The model can be trained with a proposed configuration, evaluated on a designated validation set, and the performance reporting. This process can be repeated to, for example, trade off exploration (learning more about different configurations) and exploitation (leveraging previous knowledge to achieve better results).
As training CNNs can be parallelized and GPU-enabled computing resources can be utilized, multiple optimization strategies can be attempted for different scenarios. A complex scenario allows tuning the model architecture and the preprocessing and stochastic gradient descent parameters. This expands the model configuration space. In a basic scenario, only the preprocessing and stochastic gradient descent parameters are tuned. There can be a greater number of configuration parameters in the complex scenario than in the basic scenario. The tuning in a joint space can be performed using a linear or exponential number of steps, iteration through the optimization loop for the models. The cost for such a tuning process can be significantly less than for tuning processes such as random search and grid search, without any significant performance loss.
Some embodiments can utilize backpropagation to calculate a gradient used for determining the weights for the neural network. Backpropagation is a form of differentiation, and can be used by a gradient descent optimization algorithm to adjust the weights applied to the various nodes or neurons as discussed above. The weights can be determined in some embodiments using the gradient of the relevant loss function. Backpropagation can utilize the derivative of the loss function with respect to the output generated by the statistical model. As mentioned, the various nodes can have associated activation functions that define the output of the respective nodes. Various activation functions can be used as appropriate, as may include radial basis functions (RBFs) and sigmoids, which can be utilized by various support vector machines (SVMs) for transformation of the data. The activation function of an intermediate layer of nodes is referred to herein as the inner product kernel. These functions can include, for example, identity functions, step functions, sigmoidal functions, ramp functions, and the like. Activation functions can also be linear or non-linear, among other such options.
The various embodiments can be implemented in a wide variety of operating environments, which in some cases can include one or more user computers or computing devices which can be used to operate any of a number of applications. User or client devices can include any of a number of general purpose personal computers, such as desktop or laptop computers running a standard operating system, as well as cellular, wireless and handheld devices running mobile software and capable of supporting a number of networking and messaging protocols. Such a system can also include a number of workstations running any of a variety of commercially-available operating systems and other known applications for purposes such as development and database management. These devices can also include other electronic devices, such as dummy terminals, thin-clients, gaming systems and other devices capable of communicating via a network.
Most embodiments utilize at least one network that would be familiar to those skilled in the art for supporting communications using any of a variety of commercially-available protocols, such as TCP/IP or FTP. The network can be, for example, a local area network, a wide-area network, a virtual private network, the Internet, an intranet, an extranet, a public switched telephone network, an infrared network, a wireless network and any combination thereof. In embodiments utilizing a Web server, the Web server can run any of a variety of server or mid-tier applications, including HTTP servers, FTP servers, CGI servers, data servers, Java servers and business application servers. The server(s) may also be capable of executing programs or scripts in response requests from user devices, such as by executing one or more Web applications that may be implemented as one or more scripts or programs written in any programming language, such as Java®, C, C# or C++ or any scripting language, such as Python, as well as combinations thereof. The server(s) may also include database servers, including without limitation those commercially available from Oracle®, Microsoft®, Sybase® and IBM®.
The environment can include a variety of data stores and other memory and storage media as discussed above. These can reside in a variety of locations, such as on a storage medium local to (and/or resident in) one or more of the computers or remote from any or all of the computers across the network. In a particular set of embodiments, the information may reside in a storage-area network (SAN) familiar to those skilled in the art. Similarly, any necessary files for performing the functions attributed to the computers, servers or other network devices may be stored locally and/or remotely, as appropriate. Where a system includes computerized devices, each such device can include hardware elements that may be electrically coupled via a bus, the elements including, for example, at least one central processing unit (CPU), at least one input device (e.g., a mouse, keyboard, controller, touch-sensitive display element or keypad) and at least one output device (e.g., a display device, printer or speaker). Such a system may also include one or more storage devices, such as disk drives, optical storage devices and solid-state storage devices such as random access memory (RAM) or read-only memory (ROM), as well as removable media devices, memory cards, flash cards, etc.
Such devices can also include a computer-readable storage media reader, a communications device (e.g., a modem, a network card (wireless or wired), an infrared communication device) and working memory as described above. The computer-readable storage media reader can be connected with, or configured to receive, a computer-readable storage medium representing remote, local, fixed and/or removable storage devices as well as storage media for temporarily and/or more permanently containing, storing, transmitting and retrieving computer-readable information. The system and various devices also typically will include a number of software applications, modules, services or other elements located within at least one working memory device, including an operating system and application programs such as a client application or Web browser. It should be appreciated that alternate embodiments may have numerous variations from that described above. For example, customized hardware might also be used and/or particular elements might be implemented in hardware, software (including portable software, such as applets) or both. Further, connection to other computing devices such as network input/output devices may be employed.
Storage media and other non-transitory computer readable media for containing code, or portions of code, can include any appropriate media known or used in the art, such as but not limited to volatile and non-volatile, removable and non-removable media implemented in any method or technology for storage of information such as computer readable instructions, data structures, program modules or other data, including RAM, ROM, EEPROM, flash memory or other memory technology, CD-ROM, digital versatile disk (DVD) or other optical storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices or any other medium which can be used to store the desired information and which can be accessed by a system device. Based on the disclosure and teachings provided herein, a person of ordinary skill in the art will appreciate other ways and/or methods to implement the various embodiments
The specification and drawings are, accordingly, to be regarded in an illustrative rather than a restrictive sense. It will, however, be evident that various modifications and changes may be made thereunto without departing from the broader spirit and scope of the invention as set forth in the claims.
This application is a continuation of U.S. patent application Ser. No. 16/383,347, filed Apr. 12, 2019, which claims priority to U.S. Provisional Patent Application Ser. No. 62/726,718, filed Sep. 4, 2018, entitled “Multi-view Volumetric Co-training: Utilizing the gap between 2D and 3D deep networks for semi-supervised volumetric segmentation and robust 3D model training,” the entire contents of which are incorporated herein by reference.
| Number | Name | Date | Kind |
|---|---|---|---|
| 20190147339 | Nachum | May 2019 | A1 |
| 20190147642 | Cole | May 2019 | A1 |
| 20190197358 | Madani | Jun 2019 | A1 |
| 20190385047 | Lei | Dec 2019 | A1 |
| Entry |
|---|
| Bachman et al., “Learning With Pseudo-Ensembles,” Dec. 16, 2014, 9 Pages. |
| Bai et al., “Semi-supervised Learning for Network-based Cardiac MR Image Segmentation,” International Conference on Medical Image Computing and Computer-Assisted Intervention, 2017, 8 pages. |
| Blum et al., “Combining Labeled and Unlabeled Data with Co-Training,” 1998, 9 Pages. |
| Chen et al., “Deeplab: Semantic Image Segmentation with Deep Convolutional Nets, Atrous Convolution, and Fully Connected CRFS,” IEEE transactions on pattern analysis and machine intelligence, 40(4):, May 12, 2017, 14 pages. |
| Cheplygina et al., “Not-so-Supervised: A Survey of Semi-Supervised, Multi-Instance, and Transfer Learning in Medical Image Analysis,” Sep. 14, 2018, 24 pages. |
| He et al., “Deep Residual Learning for Image Recognition,” CVPR, 2016, 9 pages. |
| Laine et al., “Temporal Ensembling for Semi-Supervised Learning,” International Conference on Learning Representations, 2017, 13 pages. |
| Li et al., “H-DenseUNet: Hybrid Densely Connected UNet for Liver and Tumor Segmentation from CT Volumes,” IEEE Transactions on Medical Imaging, 37(12): 2018, 13 pages. |
| Li et al., “Semi-supervised Skin Lesion Segmentation via Transformation Consistent Self-Ensembling Model,” BMVC, 2018, 12 pages. |
| Liu et al., “3D Anisotropic Hybrid Network: Transferring Convolutional Features from 2D Images to 3D Anisotropic Volumes,” International Conference on Medical Image Computing and Computer-Assisted Intervention, 2018, 8 pages. |
| Milletari et al., “V-net: Fully Convolutional Neural Networks for Volumetric Medical Image Segmentation,” 2016 Fourth International Conference on 3D Vision (3DV), Oct. 25, 2016, 11 pages. |
| Miyato et al., Virtual Adversarial Training: A Regularization Method for Supervised and Semi-supervised Learning, IEEE Transactions on Pattern Analysis and Machine Intelligence, 41(8): Jun. 27, 2018, 16 pages. |
| Qiao et al., “Deep Co-Training for Semi-Supervised Image Recognition,” Proceedings of the European Conference on Computer Vision, 2018, 18 pages. |
| Rasmus et al., “Semi-Supervised Learning with Ladder Networks,” Advances in Neural Information Processing Systems, 2015, 9 Pages. |
| Roth et al., “Improving Computer-aided Detection using Convolutional Neural Networks and Random View Aggregation,” IEEE Transaction on Medical Imaging, May 2016, 35 Pages. |
| Sajjadi et al., “Regularization with Stochastic Transformations and Perturbations for Deep Semi-Supervised Learning,” In Advances in Neural Information Processing Systems, 2016, 9 pages. |
| Xia et al., “Bridging the Gap Between 2D and 3D Organ Segmentation with Volumetric Fusion Net,” MICCAI, 2018, 8 pages. |
| Zhou et al., “A Fixed-Point Model for Pancreas Segmentation in Abdominal CT Scans,” MICCAI, 2017, 9 pages. |
| Zhou et al., “Semi-Supervised Multi-Organ Segmentation via Multi-Planar Co-training,” IEEE Winter Conference on Applications of Computer Vision, 2019, 20 pages. |
| Number | Date | Country | |
|---|---|---|---|
| 62726718 | Sep 2018 | US |
| Number | Date | Country | |
|---|---|---|---|
| Parent | 16383347 | Apr 2019 | US |
| Child | 18232202 | US |
