Below are the abstract, introduction, and conclusion of a computer science research paper. Please summarize the main contribution of the work in a single sentence. Your response should include the summary and no additional text.

Paper text:

Recurrent Neural Networks (RNNs) are used in state-of-the-art models in domains such as speech recognition, machine translation, and language modelling.
Sparsity is a technique to reduce compute and memory requirements of deep learning models.
Sparse RNNs are easier to deploy on devices and high-end server processors.
Even though sparse operations need less compute and memory relative to their dense counterparts, the speed-up observed by using sparse operations is less than expected on different hardware platforms.
In order to address this issue, we investigate two different approaches to induce block sparsity in RNNs: pruning blocks of weights in a layer and using group lasso regularization with pruning to create blocks of weights with zeros.
Using these techniques, we can create block-sparse RNNs with sparsity ranging from 80% to 90% with a small loss in accuracy.
This technique allows us to reduce the model size by roughly 10x.
Additionally, we can prune a larger dense network to recover this loss in accuracy while maintaining high block sparsity and reducing the overall parameter count.
Our technique works with a variety of block sizes up to 32x32.
Block-sparse RNNs eliminate overheads related to data storage and irregular memory accesses while increasing hardware efficiency compared to unstructured sparsity.

Improvements in several applications such as speech recognition BID0 , language modeling BID14 , and machine translation are a result of large Recurrent Neural Networks (RNNs) trained on large scale datasets.
As the datasets available to train these models have grown, so have model sizes.
Deployment of such large models is compute and memory intensive.Pruning weights of deep neural networks is an effective strategy to reduce the overall memory and compute requirements of these models BID9 .
However, these approaches induce random, unstructured sparsity in the weight matrices.
Speed-up obtained with unstructured sparsity on various hardware platforms are often lower than expected (as shown in ; ).
Sparse formats do not efficiently utilize the hardware resources due to storage overheads and irregular memory access.
Block sparsity can address these issues.
Saving indices of non-zero blocks instead of indices for non-zero elements reduces the storage overhead by a factor of block size.
Block-sparse formats store blocks contiguously in memory reducing irregular memory accesses.Another disadvantage of unstructured sparsity is that it cannot directly exploit array-data-paths in modern processors.
These include the 16×16 TensorCore units in the Volta GPU BID23 or the 256×256 hardware units in the Tensor Processing Unit (TPU) BID13 .
Structured sparsity in the form of two-dimensional blocks allows us to take advantage of these faster units.In order to induce block sparsity in RNNs, we propose a block pruning approach that zeros out blocks of weights in the matrix while the network is training.
At the end of training, the algorithm creates a block-sparse RNN.
In addition to this pruning technique, we examine the efficacy of group lasso regularization BID33 ) to induce block sparsity in the network.
We also combine group lasso regularization with block pruning.We demonstrate that block pruning and group lasso regularization with pruning are successful in creating block-sparse RNNs.
Inducing block sparsity with 4×4 blocks in vanilla RNNs and Gated Recurrent Units (GRUs) BID2 results in 9% to 17% loss in accuracy compared to the dense baseline.
Model size reduces by nearly 10×for speech recognition.
Block sizes can be scaled up to 32×32 with our approach.
We can also reduce accuracy loss by starting with a larger dense matrix than the baseline and then pruning it down while still reducing the number of parameters compared to the baseline.
We demonstrate that this approach works with Long Short Term Memory (LSTM) BID12 ) cells for Language Modelling as well.Our approach is agnostic to the optimization algorithm and does not require any hyper-parameter retuning (besides pruning and regularization hyper-parameters).
Furthermore, since our approach does not require re-training the model, training time remains constant.
We have demonstrated that using block pruning and group lasso combined with pruning during training can build block-sparse RNNs that are about as accurate as the dense baseline models.
The block-sparse models have significantly fewer parameters than the dense baselines reducing memory requirements.
Block-sparse models can take advantage of the underlying hardware efficiently.We would like to investigate if pruning can be performed even earlier in the training, thereby allowing us to train sparse models.
Training sparse models would allow us to reap the benefits of sparsity during training resulting in lesser compute and memory demands.
Further work remains to implement efficient block-sparse matrix multiplies for array-data-paths in modern processors that would provide increased speed-up during deployment.A 1 AND 1/2 REGULARIZATION Prior to our work with group lasso regularization, we considered 1 and 1/2 regularizers to induce sparsity in the network.
These regularizers act on individual weights and could aid in inducing unstructured sparsity in the network.
1 regularization is defined as: DISPLAYFORM0 where |w i | is the absolute value of a weight and k is the total number of weights.
Note the gradient expression for each weight w j : DISPLAYFORM1 As with the group lasso experiments described in 3.2, we explore 1 regularization with and without pruning.
The weight pruning (WP) algorithm from is used along with regularization.
The motivation is the same as group lasso block sparsity experiments: either to guide pruning or to produce sparsity directly.We also explore 1/2 regularization which is defined as: DISPLAYFORM2 Fan et al. FORMULA0 uses 1/2 regularization to produce sparsity directly.
The gradient for 1/2 regularization is 1 2 |w j | −1/2 .
This term is smaller for weights with larger magnitude.
Our expectation is that 1/2 will drive unimportant weights towards zero while leaving large weights relatively unaffected, thus avoiding the accuracy loss associated with excessive regularization.For our 1 and 1/2 experiments, we use the Deep Speech 2 Bidirectional RNN baseline model described in Section 4.
These models are trained for 25 epochs on our internal training dataset of 2000 hours.
The results are reported on a independent test set consisting of 2.9 hours.
Similar to group lasso experiments, 1 regularization experiments require a significantly higher λ to achieve high sparsity without any pruning.
We suspect that these regularizers would be more successful in inducing sparsity for models that overfit the training training dataset.
We show the RNNs can be pruned to induce block sparsity which improves speedup for sparse operations on existing hardware