OHEM support for Fast R-CNN
The field of object detection has made significant advances riding on the wave of region-based ConvNets, but their training procedure still includes many heuristics and hyperparameters that are costly to tune. We present a simple yet surprisingly effective online hard example mining (OHEM) algorithm for training region-based ConvNet detectors. Our motivation is the same as it has always been -- detection datasets contain an overwhelming number of easy examples and a small number of hard examples. Automatic selection of these hard examples can make training more effective and efficient. OHEM is a simple and intuitive algorithm that eliminates several heuristics and hyperparameters in common use. But more importantly, it yields consistent and significant boosts in detection performance on benchmarks like PASCAL VOC 2007 and 2012. Its effectiveness increases as datasets become larger and more difficult, as demonstrated by the results on the MS COCO dataset. Moreover, combined with complementary advances in the field, OHEM leads to state-of-the-art results of 78.9 PASCAL VOC 2007 and 2012 respectively.READ FULL TEXT VIEW PDF
OHEM support for Fast R-CNN
Image classification and object detection are two fundamental computer vision tasks. Object detectors are often trained through areduction that converts object detection into an image classification problem. This reduction introduces a new challenge that is not found in natural image classification tasks: the training set is distinguished by a large imbalance between the number of annotated objects and the number of background examples (image regions not belonging to any object class of interest). In the case of sliding-window object detectors, such as the deformable parts model (DPM) , this imbalance may be as extreme as 100,000 background examples to every one object. The recent trend towards object-proposal-based detectors [32, 15] mitigates this issue to an extent, but the imbalance ratio may still be high (e.g., 70:1). This challenge opens space for learning techniques that cope with imbalance and yield faster training, higher accuracy, or both.
Unsurprisingly, this is not a new challenge and a standard solution, originally called bootstrapping (and now often called hard negative mining), has existed for at least 20 years. Bootstrapping was introduced in the work of Sung and Poggio 
in the mid-1990’s (if not earlier) for training face detection models. Their key idea was to gradually grow, orbootstrap, the set of background examples by selecting those examples for which the detector triggers a false alarm. This strategy leads to an iterative training algorithm that alternates between updating the detection model given the current set of examples, and then using the updated model to find new false positives to add to the bootstrapped training set. The process typically commences with a training set consisting of all object examples and a small, random set of background examples.
Bootstrapping has seen widespread use in the intervening decades of object detection research. Dalal and Triggs  used it when training SVMs for pedestrian detection. Felzenszwalb et al.  later proved that a form of bootstrapping for SVMs converges to the global optimal solution defined on the entire dataset. Their algorithm is often referred to as hard negative mining and is frequently used when training SVMs for object detection [32, 15, 16]
. Bootstrapping was also successfully applied to a variety of other learning models, including shallow neural networks
and boosted decision trees
. Even modern detection methods based on deep convolutional neural networks (ConvNets)[20, 19], such as R-CNN  and SPPnet , still employ SVMs trained with hard negative mining.
It may seem odd then that the current state-of-the-art object detectors, embodied by Fast R-CNN and its descendants 
, do not use bootstrapping. The underlying reason is a technical difficulty brought on by the shift towards purely online learning algorithms, particularly in the context of deep ConvNets trained with stochastic gradient descent (SGD) on millions of examples. Bootstrapping, and its variants in the literature, rely on the aforementioned alternation template: (a) for some period of time afixed model is used to find new examples to add to the active training set; (b) then, for some period of time the model is trained on the fixed active training set. Training deep ConvNet detectors with SGD typically requires hundreds of thousands of SGD steps and freezing the model for even a few iterations at a time would dramatically slow progress. What is needed, instead, is a purely online form of hard example selection.
In this paper, we propose a novel bootstrapping technique called online hard example mining111We use the term hard example mining, rather than hard negative mining, because our method is applied in a multi-class setting to all classes, not just a “negative” class. (OHEM) for training state-of-the-art detection models based on deep ConvNets. The algorithm is a simple modification to SGD in which training examples are sampled according to a non-uniform, non-stationary distribution that depends on the current loss of each example under consideration. The method takes advantage of detection-specific problem structure in which each SGD mini-batch consists of only one or two images, but thousands
of candidate examples. The candidate examples are subsampled according to a distribution that favors diverse, high loss instances. Gradient computation (backpropagation) is still efficient because it only uses a small subset of all candidates. We apply OHEM to the standard Fast R-CNN detection method and show three benefits compared to the baseline training algorithm:
It removes the need for several heuristics and hyperparameters commonly used in region-based ConvNets.
It yields a consistent and significant boosts in mean average precision.
Its effectiveness increases as the training set becomes larger and more difficult, as demonstrated by results on the MS COCO dataset.
Object detection is one of the oldest and most fundamental problems in computer vision. The idea of dataset bootstrapping [30, 25], typically called hard negative mining in recent work , appears in the training of most successful object detectors [25, 9, 7, 23, 29, 12, 15, 16, 13]. Many of these approaches use SVMs as the detection scoring function, even after training a deep convolutional neural network (ConvNet) [20, 19]
for feature extraction. One notable exception is the Fast R-CNN detector and its descendants, such as Faster R-CNN . Since these models do not use SVMs, and are trained purely online with SGD, existing hard example mining techniques cannot be immediately applied. This work addresses that problem by introducing an online hard example mining algorithm that improves optimization and detection accuracy. We briefly review hard example mining, modern ConvNet-based object detection, and relationships to concurrent works using hard example selection for training deep networks.
There are two hard example mining algorithms in common use. The first is used when optimizing SVMs. In this case, the training algorithm maintains a working set of examples and alternates between training an SVM to convergence on the working set, and updating the working set by removing some examples and adding others according to a specific rule 
. The rule removes examples that are “easy” in the sense that they are correctly classified beyond the current model’s margin. Conversely, the rule adds new examples that are hard in the sense that they violate the current model’s margin. Applying this rule leads to the global SVM solution. Importantly, the working set is usually a small subset of the entire training set.
. This algorithm usually starts with a dataset of positive examples and a random set of negative examples. The machine learning model is then trained to convergence on that dataset and subsequently applied to a larger dataset to harvest false positives. The false positives are then added to the training set and then the model is trained again. This process is usually iterated only once and does not have any convergence proofs.
In the last three years significant gains have been made in object detection. These improvements were made possible by the successful application of deep ConvNets 
to ImageNet classification. The R-CNN  and OverFeat  detectors lead this wave with impressive results on PASCAL VOC  and ImageNet detection. OverFeat is based on the sliding-window detection method, which is perhaps the most intuitive and oldest search method for detection. R-CNN, in contrast, uses region proposals [1, 2, 10, 32, 4, 3, 6, 34, 18], a method that was made popular by the selective search algorithm . Since R-CNN, there has been rapid progress in region-based ConvNets, including SPPnet , MR-CNN , and Fast R-CNN , which our work builds on.
There is recent work [27, 33, 22] concurrent to our own that selects hard examples for training deep networks. Similar to our approach, all these methods base their selection on the current loss for each datapoint.  independently selects hard positive and negative example from a larger set of random examples based on their loss to learn image descriptors. Given a positive pair of patches,  finds hard negative patches from a large set using triplet loss. Akin to our approach,  investigates online selection of hard examples for mini-batch SGD methods. Their selection is also based on loss, but the focus is on ConvNets for image classification. Complementary to , we focus on online hard example selection strategy for region-based object detectors.
We first summarize the Fast R-CNN  (FRCN) framework. FRCN takes as input an image and a set of object proposal regions of interest (RoIs). The FRCN network itself can be divided into two sequential parts: a convolutional (conv
) network with several convolution and max-pooling layers (Figure1, “Convolutional Network”); and an RoI network with an RoI-pooling layer, several fully-connected (fc) layers and two loss layers (Figure 1, “RoI Network”).
During inference, the conv network is applied to the given image to produce a conv feature map, size of which depends on the input image dimensions. Then, for each object proposal, the RoI-pooling layer projects the proposal onto the conv feature map and extracts a fixed-length feature vector. Each feature vector is fed into the fc layers, which finally give two outputs: (1) a softmax probability distribution over the object classes and background; and (2) regressed coordinates for bounding-box relocalization.
There are several reasons for choosing FRCN as our base object detector, apart from it being a fast end-to-end system. Firstly, the basic two network setup (conv and RoI) is also used by other recent detectors like SPPnet and MR-CNN; therefore, our proposed algorithm is more broadly applicable. Secondly, though the basic setup is similar, FRCN also allows for training the entire conv network, as opposed to both SPPnet and MR-CNN which keep the conv network fixed. And finally, both SPPnet and MR-CNN require features from the RoI network to be cached for training a separate SVM classifier (using hard negative mining). FRCN uses the RoI network itself to train the desired classifiers. In fact,  shows that in the unified system using the SVM classifiers at later stages was unnecessary.
Like most deep networks, FRCN is trained using stochastic gradient descent (SGD). The loss per example RoI is the sum of a classification log loss that encourages predicting the correct object (or background) label and a localization loss that encourages predicting an accurate bounding box (see  for details).
To share conv network computation between RoIs, SGD mini-batches are created hierarchically. For each mini-batch, images are first sampled from the dataset, and then RoIs are sampled from each image. Setting and works well in practice . The RoI sampling procedure uses several heuristics, which we describe briefly below. One contribution of this paper is to eliminate some of these heuristics and their hyperparameters.
For an example RoI to be labeled as foreground (fg), its intersection over union (IoU) overlap with a ground-truth bounding box should be at least . This is a fairly standard design choice, in part inspired by the evaluation protocol of the PASCAL VOC object detection benchmark. The same criterion is used in the SVM hard mining procedures of R-CNN, SPPnet, and MR-CNN. We use the same setting.
A region is labeled background (bg) if its maximum IoU with ground truth is in the interval bg_lo. A lower threshold of bg_lo is used by both FRCN and SPPnet, and is hypothesized in  to crudely approximate hard negative mining; the assumption is that regions with some overlap with the ground truth are more likely to be the confusing or hard ones. We show in Section 5.4 that although this heuristic helps convergence and detection accuracy, it is suboptimal because it ignores some infrequent, but important, difficult background regions. Our method removes the bg_lo threshold.
To handle the data imbalance described in Section 1,  designed heuristics to rebalance the foreground-to-background ratio in each mini-batch to a target of by undersampling the background patches at random, thus ensuring that of a mini-batch is fg RoIs. We found that this is an important design decision for the training FRCN. Removing this ratio (i.e. randomly sampling RoIs), or increasing it, decreases accuracy by points mAP. With our proposed method, we can remove this ratio hyperparameter with no ill effect.
We propose a simple yet effective online hard example mining algorithm for training Fast R-CNN (or any Fast R-CNN style object detector). We argue that the current way of creating mini-batches for SGD (Section 3.1) is inefficient and suboptimal, and we demonstrate that our approach leads to better training (lower training loss) and higher testing performance (mAP).
Recall the alternating steps that define a hard example mining algorithm: (a) for some period of time a fixed model is used to find new examples to add to the active training set; (b) then, for some period of time the model is trained on the fixed active training set. In the context of SVM-based object detectors, such as the SVMs trained in R-CNN or SPPnet, step (a) inspects a variable number of images (often 10’s or 100’s) until the active training set reaches a threshold size, and then in step (b) the SVM is trained to convergence on the active training set. This process repeats until the active training set contains all support vectors. Applying an analogous strategy to FRCN ConvNet training slows learning because no model updates are made while selecting examples from the 10’s or 100’s of images.
Our main observation is that these alternating steps can be combined with how FRCN is trained using online SGD. The key is that although each SGD iteration samples only a small number of images, each image contains thousands of example RoIs from which we can select the hard examples rather than a heuristically sampled subset. This strategy fits the alternation template to SGD by “freezing” the model for only one mini-batch. Thus the model is updated exactly as frequently as with the baseline SGD approach and therefore learning is not delayed.
More specifically, the online hard example mining algorithm (OHEM) proceeds as follows. For an input image at SGD iteration , we first compute a conv feature map using the conv network. Then the RoI network uses this feature map and the all the input RoIs , instead of a sampled mini-batch , to do a forward pass. Recall that this step only involves RoI pooling, a few fc layers, and loss computation for each RoI. The loss represents how well the current network performs on each RoI. Hard examples are selected by sorting the input RoIs by loss and taking the examples for which the current network performs worst. Most of the forward computation is shared between RoIs via the conv feature map, so the extra computation needed to forward all RoIs is relatively small. Moreover, because only a small number of RoIs are selected for updating the model, the backward pass is no more expensive than before.
However, there is a small caveat: co-located RoIs with high overlap are likely to have correlated losses. Moreover, these overlapping RoIs can project onto the same region in the conv feature map, because of resolution disparity, thus leading to loss double counting. To deal with these redundant and correlated regions, we use standard non-maximum suppression (NMS) to perform deduplication (the implementation from ). Given a list of RoIs and their losses, NMS works by iteratively selecting the RoI with the highest loss, and then removing all lower loss RoIs that have high overlap with the selected region. We use a relaxed IoU threshold of to suppress only highly overlapping RoIs.
We note that the procedure described above does not need a fg-bg ratio for data balancing. If any class were neglected, its loss would increase until it has a high probability of being sampled. There can be images where the fg RoIs are easy (e.g. canonical view of a car), so the network is free to use only bg regions in a mini-batch; and vice-versa when bg is trivial (e.g. sky, grass etc.), the mini-batch can be entirely fg regions.
There are many ways to implement OHEM in the FRCN detector, each with different trade-offs. An obvious way is to modify the loss layers to do the hard example selection. The loss layer can compute loss for all RoIs, sort them based on this loss to select hard RoIs, and finally set the loss of all non-hard RoIs to . Though straightforward, this implementation is inefficient as the RoI network still allocates memory and performs backward pass for all RoIs, even though most RoIs have
loss and hence no gradient updates (a limitation of current deep learning toolboxes).
To overcome this, we propose the architecture presented in Figure 2. Our implementation maintains two copies of the RoI network, one of which is readonly. This implies that the readonly RoI network (Figure 2(a)) allocates memory only for forward pass of all RoIs as opposed to the standard RoI network, which allocates memory for both forward and backward passes. For an SGD iteration, given the conv feature map, the readonly RoI network performs a forward pass and computes loss for all input RoIs (Figure 2, green arrows). Then the hard RoI sampling module uses the procedure described in Section 4.1 to select hard examples , which are input to the regular RoI network (Figure 2(b), red arrows)). This network computes forward and backward passes only for , accumulates the gradients and passes them to the conv network. In practice, we use all RoIs from all images as , therefore the effective batch size for the readonly RoI network is and for the regular RoI network is the standard from Section 3.1.
We implement both options described above using the Caffe framework (see ). Our implementation uses gradient accumulation with forward-backward passes of single image mini-batches. Following FRCN , we use (which results in ) and . Under these settings, the proposed architecture (Figure 2) has similar memory footprint as the first option, but is faster. Unless specified otherwise, the architecture and settings described above will be used throughout this paper.
This section compares FRCN training with online hard example mining (OHEM) to the baseline heuristic sampling approach. We also compare FRCN with OHEM to a less efficient approach that uses all available example RoIs in each mini-batch, not just the hardest examples.
We conduct experiments with two standard ConvNet architectures: VGG_CNN_M_1024 (VGGM, for short) from , which is a wider version of AlexNet , and VGG16 from . All experiments in this section are performed on the PASCAL VOC07 dataset. Training is done on the trainval set and testing on the test set. Unless specified otherwise, we will use the default settings from FRCN . We train all methods with SGD for 80k mini-batch iterations, with an initial learning rate of 0.001 and we decay the learning rate by 0.1 every 30k iterations. The baseline numbers reported in Table 1 (row 1-2) were reproduced using our training schedule and are slightly higher than the ones reported in .
Standard FRCN, reported in Table 1 (rows ), uses as a heuristic for hard mining (Section 3.1). To test the importance of this heuristic, we ran FRCN with . Table 1 (rows ) shows that for VGGM, mAP drops by points, whereas for VGG16 it remains roughly the same. Now compare this to training FRCN with OHEM (rows ). OHEM improves mAP by points compared to FRCN with the heuristic for VGGM, and points without the heuristic. This result demonstrates the sub-optimality of these heuristics and the effectiveness of our hard mining approach.
One concern over using only images per batch is that it may cause unstable gradients and slow convergence because RoIs from an image may be highly correlated . FRCN  reports that this was not a practical issue for their training. But this detail might raise concerns over our training procedure because we use examples with high loss from the same image and as a result they may be more highly correlated. To address this concern, we experiment with in order to increase correlation in an effort to break our method. As seen in Table 1 (rows ), performance of the original FRCN drops by point with , but when using our training procedure, mAP remains approximately the same. This shows that OHEM is robust in case one needs fewer images per batch in order to reduce GPU memory usage.
Online hard example mining is based on the hypothesis that it is important to consider all RoIs in an image and then select hard examples for training. But what if we train with all the RoIs, not just the hard ones? The easy examples will have low loss, and won’t contribute much to the gradient; training will automatically focus on the hard examples. To compare this option, we ran standard FRCN training with a large mini-batch size of , using , and with other hyperparameters fixed. Because this experiment uses a large mini-batch, it’s important to tune the learning rate to adjust for this change. We found optimal results by increasing it to for VGG16 and for VGGM. The outcomes are reported in Table 1 (rows ). Using these settings, mAP of both VGG16 and VGGM increased by point compared to , but the improvement from our approach is still points over using all RoIs. Moreover, because we compute gradients with a smaller mini-batch size training is faster.
|1||Fast R-CNN ||VGGM||2||0.001||128||0.1||59.6|
|3||Removing hard mining heuristic (Section 5.2)||VGGM||2||0.001||128||0||57.2|
|5||Fewer images per batch (Section 5.3)||VGG16||1||0.001||128||0.1||66.3|
|7||Bigger batch, High LR (Section 5.4)||VGGM||1||0.004||2048||0||57.7|
Finally, we analyze the training loss for the various FRCN training methods discussed above. It’s important to measure training loss in a way that does not depend on the sampling procedure and thus results in a valid comparison between methods. To achieve this goal, we take model snapshots from each method every 20k steps of optimization and run them over the entire VOC07 trainval set to compute the average loss over all RoIs. This measures the training set loss in a way that does not depend on the example sampling scheme.
Figure 3 shows the average loss per RoI for VGG16 with the various hyperparameter settings discussed above and presented in Table 1. We see that results in the highest training loss, while using the heuristic results in a much lower training loss. Increasing the mini-batch size to and increasing the learning rate lowers the training loss below the heuristic. Our proposed online hard example mining method achieves the lowest training loss of all methods, validating our claims that OHEM leads to better training for FRCN.
|max. memory (G)||2.6||3.6||11.2||6.4||8.7|
*: uses gradient accumulation over two forward/backward passes
OHEM adds reasonable computational and memory overhead, as reported in Table 2. OHEM costs 0.09s per training iteration for VGGM network (0.43s for VGG16) and requires 1G more memory (2.3G for VGG16). Given that FRCN  is a fast detector to train, the increase in training time is likely acceptable to most users.
http://host.robots.ox.ac.uk:8080/anonymous/XNDVK7.html, http://host.robots.ox.ac.uk:8080/anonymous/H49PTT.html, http://host.robots.ox.ac.uk:8080/anonymous/LSANTB.html, http://host.robots.ox.ac.uk:8080/anonymous/R7EAMX.html
In this section, we evaluate our method on VOC 2012  as well as the more challenging MS COCO  dataset. We demonstrate consistent and significant improvement in FRCN performance when using the proposed OHEM approach. Per-class results are also presented on VOC 2007 for comparison with prior work.
We use VGG16 for all experiments. When training on VOC07 trainval, we use the SGD parameters as in Section 5 and when using extra data (07+12 and 07++12, see Table 3 and 4), we use 200k mini-batch iterations, with an initial learning rate of 0.001 and decay step size of 40k. When training on MS COCO 
, we use 240k mini-batch iterations, with an initial learning rate of 0.001 and decay step size of 160k, owing to a larger epoch size.
Table 3 shows that on VOC07, OHEM improves the mAP of FRCN from 67.2% to 69.9% (and 70.0% to 74.6% with extra data). On VOC12, OHEM leads to an improvement of 4.1 points in mAP (from 65.7% to 69.8%). With extra data, we achieve an mAP of 71.9% as compared to 68.4% mAP of FRCN, an improvement of 3.5 points. Interestingly the improvements are not uniform across categories. Bottle, chair, and tvmonitor show larger improvements that are consistent across the different PASCAL splits. Why these classes benefit the most is an interesting and open question.
). On the standard COCO evaluation metric, FRCN scores 19.7% AP, and OHEM improves it to 22.6% AP.222COCO AP averages over classes, recall, and IoU levels. See http://mscoco.org/dataset/#detections-eval for details. Using the VOC overlap metric of , OHEM gives a 6.6 points boost in AP. It is also interesting to note that OHEM helps improve the AP of medium sized objects by 4.9 points on the strict COCO AP evaluation metric, which indicates that the proposed hard example mining approach is helpful when dealing with smaller sized objects. Note that FRCN with and without OHEM were trained on MS COCO train set.
We’ve demonstrated consistent gains in detection accuracy by applying OHEM to FRCN training. In this section, we show that these improvements are orthogonal to recent bells and whistles that enhance object detection accuracy. OHEM with the following two additions yields state-of-the-art results on VOC and competitive results on MS COCO.
We adopt the multi-scale strategy from SPPnet  (and used by both FRCN  and MR-CNN ). Scale is defined as the size of the shortest side () of an image. During training, one scale is chosen at random, whereas at test time inference is run on all scales. For VGG16 networks, we use for training, and during testing, with the max dimension capped at 1000. The scales and caps were chosen because of GPU memory constraints.
We adopt the iterative localization and bounding-box (bbox) voting scheme from . The network evaluates each proposal RoI to get scores and relocalized boxes . High-scoring boxes are the rescored and relocalized, yielding boxes . Union of and is used as the final set for post-processing, where is obtained using NMS on with an IoU threshold of 0.3 and weighted voting is performed on each box in using boxes in with an IoU of 0.5 with (see  for details).
|APIoU||area||FRCN||Ours||Ours [+M]||Ours* [+M]|
from the leaderboard, *trained on trainval set
We report the results on VOC benchmarks in Table 3 and 4. On VOC07, FRCN with the above mentioned additions achieves 72.4% mAP and OHEM improves it to 75.1%, which is currently the highest reported score under this setting (07 data). When using extra data (07+12), OHEM achieves 78.9% mAP, surpassing the current state-of-the-art MR-CNN (78.2% mAP). We note that MR-CNN uses selective search and edge boxes during training, whereas we only use selective search boxes. Our multi-scale implementation is also different, using fewer scales than MR-CNN. On VOC12 (Table 4), we consistently perform better than MR-CNN. When using extra data, we achieve state-of-the-art mAP of 76.3% (vs. 73.9% mAP of MR-CNN).
We now study in detail the impact of these two additions and whether OHEM is complementary to them, and report the analysis in Table 6. Baseline FRCN mAP improves from 67.2% to 68.6% when using multi-scale during both training and testing (we refer to this as M). However, note that there is only a marginal benefit of using it at training time. Iterative bbox regression (B) further improves the FRCN mAP to 72.4%. But more importantly, using OHEM improves it to 75.1% mAP, which is state-of-the-art for methods trained on VOC07 data (see Table 3). In fact, using OHEM consistently results in higher mAP for all variants of these two additions (see Table 6).
|Multi-scale (M)||Iterative bbox reg. (B)||VOC07 mAP|
MS COCO  test-dev 2015 evaluation server results are reported in Table 5. Using multi-scale improves the performance of our method to 24.4% AP on the standard COCO metric and to 44.4% AP on the VOC metric. This again shows the complementary nature of using multi-scale and OHEM. Finally, we train our method using the entire MS COCO trainval set, which further improves performance to 25.5% AP (and 45.9% AP). In the 2015 MS COCO Detection Challenge, a variant of this approach finished place overall.
We presented an online hard example mining (OHEM) algorithm, a simple and effective method to train region-based ConvNet detectors. OHEM eliminates several heuristics and hyperparameters in common use by automatically selecting hard examples, thus simplifying training. We conducted extensive experimental analysis to demonstrate the effectiveness of the proposed algorithm, which leads to better training convergence and consistent improvements in detection accuracy on standard benchmarks. We also reported state-of-the-art results on PASCAL VOC 2007 and 2012 when using OHEM with other orthogonal additions. Though we used Fast R-CNN throughout this paper, OHEM can be used for training any region-based ConvNet detector.
Our experimental analysis was based on the overall detection accuracy, however it will be an interesting future direction to study the impact of various training methodologies on individual category performance.
This project started as an intern project at Microsoft Research and continued at CMU. We thank Larry Zitnick, Ishan Misra and Sean Bell for many helpful discussions. AS was supported by the Microsoft Research PhD Fellowship. This work was also partially supported by ONR MURI N000141612007. We thank NVIDIA for donating GPUs.