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:

This paper proposes a Pruning in Training (PiT) framework of learning to reduce the parameter size of networks.
Different from existing works, our PiT framework employs the sparse penalties to train networks and thus help rank the importance of weights and filters.
Our PiT algorithms can directly prune the network without any fine-tuning.
The pruned networks can still achieve comparable performance to the original networks.
In particular, we introduce the (Group) Lasso-type Penalty (L-P /GL-P), and (Group) Split LBI Penalty (S-P / GS-P) to regularize the networks, and a pruning strategy proposed  is used in help prune the network.
We conduct the extensive experiments on MNIST, Cifar-10, and miniImageNet.
The results validate the efficacy of our proposed methods.
Remarkably, on MNIST dataset, our PiT framework can save 17.5% parameter size of LeNet-5, which achieves the 98.47% recognition accuracy.
The expressive power of Deep Convolutional Neural Networks (DNNs) comes from the millions of parameters, which are optimized by various algorithms such as Stochastic Gradient Descent (SGD), and Adam BID18 .
However, one has to strike a trade-off between the representation capability and computational cost, caused by the plenty of parameters in the real world applications, e.g., robotics, self-driving cars, and augmented reality.
Pruning significant number of parameters would be essential to reduce the computational complexity and thus facilitate a timely and efficient fashion on a resource-limited platform, e.g. devices of Internet of Things (IoT).
In addition, it has long been conjectured that the state-of-the-art DNNs may be too complicated for most specific tasks; and we may have the free lunch of "reducing 2× connections without losing accuracy and without retraining" BID7 .To
compress DNNs, recent efforts had been made on learning the DNNs of small size. They
either reduce the number and size of weights of parameters of original networks, and fine-tune the pruned networks BID0 ; BID32 , or distill the knowledge of large model , or directly learning the compact and lightweight small DNNs, such as ShuffleNet BID24 , MobileNet Howard et al. (2017) , and SqueezeNet BID13 . Note
that, (1) to efficiently learn the compressed DNNs, previous works had to introduce additional computational cost in fine-tuning, or training the updated networks; (2) it is not practical nor desirable to learn the tailored, or bespoke networks for any applications, beyond computer vision tasks.To this end, the center idea of this paper is to propose a Pruning in Training (PiT) framework that enables pruning networks in the training process. Particularly
, the sparsity regularizers, including lasso-type, and split LBI penalties are applied to train the networks. Such regularizers
not only encourage the sparsity of DNNs, i.e., fewer (sparse) connections with non-zero values, but also can accelerate the speed of DNNs convergence. Furthermore, in the
learning process, we can iteratively compute the regularization path of layer-wise parameters of DNNs. The parameters can
be ranked by the regularization path in a descending order, as BID3 . The parameters in
the high rank are in the high priority of not being pruned.More importantly, our PiT can learn the sparse structures of DNNs, and utilize the functionality of filters and connection weights (in fully connected layers). In the optimal cases
, the weights (or filters) of each layer should be learned fully orthogonal to each other and thus formulate an orthogonal basis. The orthogonal constraint
may be only enforced as the initialization (e.g., SVD Jia (2017) and BID26 ), or via the other regularization tricks, such as dropout preventing co-adaption BID27 , or batch normalization reducing the internal covariate shift of hidden layers BID14 . Therefore, our PiT can help
uncover redundant information in a network by compressing less important filters and weights, and facilitate pruning out more interpretable networks.
As the experiments shown in these three datasets, our PiT indeed can learn to prune networks without fine-tuning.
We give some further discussion and highlight the potential future works,
1. In all our experiments, our L-P / GL-P, and S-P / GS-P are applied to, at most, four layers in one network.
Theoretically, our PiT algorithms should be able to be directly applied to any layers of DNNs, since PiT only adds some sparse penalties in the loss functions.
However, in practice, we found that the network training algorithm, i.e., SGD in Alg.
3, is unstable, if we apply the sparse penalties more than four layers.
It will take much more time and training epochs to get the networks converged.
2. Essentially, our PiT presents a feature selection algorithm, which can dynamically learn the importance of weights and filters in the learning process; mostly importantly, we donot need any fine-tuning step, which, we believe, will destroy values and properties of selected weights and filters.
Therefore, it would be very interesting to analyze the statistical properties of selected features in each layer.
3. Theoretically, we can not guarantee the orthogonality of weights and filters in the trained model.
Empirically, we adapt some strategies.
For example, the weights and filters of each layer can be orthogonally initialized; and we apply the common regularization tricks, e.g., dropout, and batch normalization.
These can help decorrelate the learned parameters of the same layers.
Practically, our PiT framework works well in selecting the important parameters and prune the networks as shown in the experiments.
We also visualize the correlation between removed and none removed filters in the Appendix.
4. It is a conjecture that the capacity of DNNs may be too large to learn a small dataset;and it is essential to do network pruning.
However, it is also an open question as how to numerically measure the capacity of DNNs and the complexity of one dataset.
we propose an algorithm of learning to prune network by enforcing structure sparsity penalties