Deep and large pre-trained language models are the state-of-the-art for various natural language processing tasks. However, the huge size of these models could be a deterrent to using them in practice. Some recent works use knowledge distillation to compress these huge models into shallow ones. In this work we study knowledge distillation with a focus on multilingual Named Entity Recognition (NER). In particular, we study several distillation strategies and propose a stage-wise optimization scheme leveraging teacher internal representations, that is agnostic of teacher architecture, and show that it outperforms strategies employed in prior works. Additionally, we investigate the role of several factors like the amount of unlabeled data, annotation resources, model architecture and inference latency to name a few. We show that our approach leads to massive compression of teacher models like mBERT by upto 35 x in terms of parameters and 51 x in terms of latency for batch inference while retaining 95% of its F 1 -score for NER over 41 languages. Motivation: Pre-trained language models have shown state-of-the-art performance for various natural language processing applications like text classification, named entity recognition and question-answering. A significant challenge facing practitioners is how to deploy these huge models in practice. For instance, models like BERT Large (Devlin et al., 2019), GPT 2 (Radford et al., 2019), Megatron (Shoeybi et al., 2019) and T5 (Raffel et al., 2019) have 340 M , 1 . 5 B , 8 . 3 B and 11 B parameters respectively. Although these models are trained offline, during prediction we need to traverse the deep neural network architecture stack involving a large number of parameters. This significantly increases latency and memory requirements. Knowledge distillation (Hinton et al., 2015; Ba and Caruana, 2014) earlier used in computer vision provides one of the techniques to compress huge neural networks into smaller ones. In this, shallow models (called students) are trained to mimic the output of huge models (called teachers) based on a transfer set. Similar approaches have been recently adopted for language model distillation. Limitations of existing work: Recent works (Liu et al., 2019; Zhu et al., 2019; Tang et al., 2019; Turc et al., 2019) leverage soft logits from teachers as optimization targets for distilling students, with some notable exceptions from concurrent work. Sun et al. (2019); Sanh (2019); Aguilar et al. (2019); Zhao et al. (2019) additionally use internal teacher representations as additional signals. However, these methods are constrained by architectural considerations like embedding dimension in BERT and transformer architecture. This makes it difficult to massively compress models (without being able to reduce network width) or adopt alternate architecture. For instance, we observe BiLSTMS as students to be more accurate than Transformers for low latency configurations. Some concurrent works (Turc et al., 2019); (Zhao et al., 2019) adopt pre-training or dual training to distil students of arbitrary architecture. However, pre-training is expensive in terms of time and computational resources. Additionally, most of the above works are geared for distilling language models for GLUE tasks (Wang et al., 2018). There has been some limited exploration of such techniques for sequence tagging tasks like NER (Izsak et al., 2019; Shi et al., 2019) or multilingual tasks (Tsai et al., 2019). However, these works also suffer from similar drawbacks as mentioned before. XtremeDistil: Multilingual pre-TRainEd ModEl Distillation works and propose a new scheme outperforming prior ones. In this, we leverage teacher internal representations to transfer knowledge to the student. However, in contrast to prior work, we are not restricted by the choice of student architecture. This allows representation transfer from Transformer-based teacher model to BiLSTM-based student model with different embedding dimensions and disparate output spaces. We also propose a stagewise optimization scheme to sequentially transfer most general to task-specific information from teacher to student for better distillation. Overview of our task: Unlike prior works mostly focusing on GLUE tasks in a single language, we employ our techniques to study distillation for massive multilingual Named Entity Recognition (NER) over 41 languages. Prior work on multilingual transfer on the same (Rahimi et al., 2019) (MM-NER) requires knowledge of source and target language whereby they judiciously select pairs for effective transfer resulting in a customized model for each language. In our work, we adopt Multilingual Bidirectional Encoder Representations from Transformer (mBERT) as our teacher and show that it is possible to perform language-agnostic joint NER for all languages with a single model that has a similar performance but massively compressed in contrast to mBERT and MMNER. The closest one to this work is that of (Tsai et al., 2019) where mBERT is leveraged for multilingual NER. We discuss this in details and use their strategy as a baseline. We show our distillation strategy to be better leading to a higher compression and faster inference. We also investigate several unexplored dimensions of distillation like the impact of unlabeled transfer data and annotation resources, choice of multilingual word embeddings, architectural variations and inference latency. Our techniques obtain massive compression of teacher models like mBERT by upto 35 x in terms of parameters and 51 x in terms of latency for batch inference while retaining 95% of its performance for massive multilingual NER, and matching or outperforming it for classification tasks. Overall, our work makes the following contributions :  Method: We propose a distillation method leveraging internal representations and parameter projection that is agnostic of teacher architecture. Inference: To learn model parameters, we propose stage wise optimization schedule with gradual unfreezing outperforming prior schemes. Experiments: We perform distillation for multilingual NER on 41 languages with massive compression and comparable performance to huge models 1 . We also perform classification experiments on four datasets where our compressed models perform at par with significantly larger teachers. Study: We study the influence of several factors on distillation like the availability of annotation resources for different languages, model architecture, quality of multilingual word embeddings, memory footprint and inference latency. Problem Statement: Consider a sequence x = (cid:104) x k (cid:105) with K tokens and y = (cid:104) y k (cid:105) as the corresponding labels. Consider D l = {(cid:104) x k,l (cid:105) , (cid:104) y k,l (cid:105)} to be a set of n labeled instances with X = {(cid:104) x k,l (cid:105)} denoting the instances and Y = {(cid:104) y k,l (cid:105)} the corresponding labels. Consider D u = {(cid:104) x k,u (cid:105)} to be a transfer set of N unlabeled instances from the same domain where n (cid:28) N . Given a teacher T (  t ) , we want to train a student S (  s ) with  being trainable parameters such that |  s | (cid:28) |  t | and the student is comparable in performance to the teacher based on some evaluation metric. In the following section, the superscript t' always represents the teacher and s' denotes the student. Model compression and knowledge distillation: Prior works in the vision community dealing with huge architectures like AlexNet and ResNet have addressed this challenge in two ways. Works in model compression use quantization (Gong et al., 2014), low-precision training and pruning the network, as well as their combination (Han et al., 2016) to reduce the memory footprint. On the other hand, works in knowledge distillation leverage student teacher models. These approaches include using soft logits as targets (Ba and Caruana, 2014), increasing the temperature of the softmax to match that of the teacher (Hinton et al., 2015) as well as using teacher representations (Romero et al., 2015) (refer to (Cheng et al., 2017) for a survey). Recent and concurrent Works: Liu et al. (2019); Zhu et al. (2019); Clark et al. (2019) leverage en-sembling to distil knowledge from several multitask deep neural networks into a single model. Sun et al. (2019); Sanh (2019);Aguilar et al. (2019) train student models leveraging architectural knowledge 1 Code and resources available at: https://aka.ms/ XtremeDistil of the teacher models which adds architectural constraints (e.g., embedding dimension) on the student. In order to address this shortcoming, more recent works combine task-specific distillation with pre-training the student model with arbitrary embedding dimension but still relying on transformer architectures (Turc et al., 2019); (Jiao et al., 2019); (Zhao et al., 2019). Izsak et al. (2019); Shi et al. (2019) extend these for sequence tagging for Part-of-Speech (POS) tagging and Named Entity Recognition (NER) in English. The one closest to our work Tsai et al. (2019) extends the above for multilingual NER. Most of these works rely on general corpora for pre-training and task-specific labeled data for distillation. To harness additional knowledge, (Turc et al., 2019) leverage task-specific unlabeled data. (Tang et al., 2019; Jiao et al., 2019) use rule-and embedding-based data augmentation. The Student: The input to the model are E dimensional word embeddings for each token. To capture sequential information in the sentence, we use a single layer Bidirectional Long Short Term Memory Network (BiLSTM). Given a sequence of K tokens, a BiLSTM computes a set of K vectors h ( x k ) = [  h ( x k );  h ( x k )] as the concatenation of the states generated by a forward (  h ( x k )) and backward LSTM (  h ( x k )) . Assuming the number of hidden units in the LSTM to be H , each hidden state h ( x k ) is of dimension 2 H . Probability distribution for the token label at timestep k is given by: p ( s ) ( x k ) = softmax ( h ( x k )  W s ) (1) where W s  R 2 H.C and C is number of labels. Consider one-hot encoding of the token labels, such that y k,l,c = 1 for y k,l = c , and y k,l,c = 0 otherwise for c  C . The overall cross-entropy loss computed over each token obtaining a specific label in each sequence is given by: LCE =  (cid:88) x l ,y l  D l (cid:88) k (cid:88) c y k,c,l log p ( s ) c ( x k,l ) (2) We train the student model end-to-end minimizing the above cross-entropy loss over labeled data. The Teacher: Pre-trained language models like ELMO (Peters et al., 2018), BERT (Devlin et al., 2019) and GPT (Radford et al., 2018, 2019) have shown state-of-the-art performance for several tasks. We adopt BERT as the teacher  specifically, the multilingual version of BERT (mBERT) with 179 MM parameters trained over 104 languages with the largest Wikipedias. mBERT does not use any markers to distinguish languages during pre-training and learns a single language-agnostic model trained via masked language modeling over Wikipedia articles from all languages. Tokenization : Similar to mBERT, we use WordPiece tokenization with 110 K shared WordPiece vocabulary. We preserve casing, remove accents, split on punctuations and whitespace. Fine-tuning the Teacher : The pre-trained language models are trained for general language modeling objectives. In order to adapt them for the given task, the teacher is fine-tuned end-to-end with task-specific labeled data D l to learn parameters   t using cross-entropy loss as in Equation 2. 4 Distillation Features Teacher fine-tuning gives us access to task-specific representations for distilling the student. To this end, we use different kinds of teacher information. Logits as logarithms of predicted probabilities provide a better view of the teacher by emphasizing on the different relationships learned by it across different instances. Consider p t ( x k ) to be the classification probability of token x k as generated by the fine-tuned teacher with logit ( p t ( x k )) representing the corresponding logits. Our objective is to train a student model with these logits as targets. Given the hidden state representation h ( x k ) for token x k , we can obtain the corresponding classification score (since targets are logits) as: r s ( x k ) = W r  h ( x k ) + b r (3) where W r  RC  2 H and b r  RC are trainable parameters and C is the number of classes. We want to train the student neural network end-to-end by minimizing the element-wise mean-squared error between the classification scores given by the student and the target logits from the teacher as: LLL = 1 2 (cid:88) x u  D u (cid:88) k || r s ( x k,u )  logit ( p t ( x k,u ;   t )) || 2 (4) 4.2 Internal Teacher Representations Hidden representations: Recent works (Sun et al., 2019; Romero et al., 2015) have shown the hidden state information from the teacher to be helpful as a hint-based guidance for the student. Given a large collection of task-specific unlabeled data, we can transfer the teacher's knowledge to the student via its hidden representations. However, this poses a challenge in our setting as the teacher and student models have different architectures with disparate output spaces. Consider h s ( x k ) and z tl ( x k ;   t ) to be the representations generated by the student and the l th deep layer of the fine-tuned teacher respectively for a token x k . Consider x u  D u to be the set of unlabeled instances. We will later discuss the choice of the teacher layer l and its impact on distillation. Projection: To make all output spaces compatible, we perform a non-linear projection of the parameters in student representation h s to have same shape as teacher representation z tl for each token x k :  z s ( x k ) = Gelu ( W f  h s ( x k ) + b f ) (5) where W f  R | z tl | 2 H is the projection matrix, b f  R | z tl | is the bias, and Gelu (Gaussian Error Linear Unit) (Hendrycks and Gimpel, 2016) is the non-linear projection function. | z tl | represents the embedding dimension of the teacher. This transformation aligns the output spaces of the student and teacher and allows us to accommodate arbitrary student architecture. Also note that the projections (and therefore the parameters) are shared across tokens at different timepoints. Multilingual word embeddings: A large number of parameters reside in the word embeddings. For mBERT a shared multilingual WordPiece vocabulary of V = 110 K tokens and embedding dimension of D = 768 leads to 92 MM parameters. To have massive compression, we cannot directly incorporate mBERT embeddings in our model. Since we use the same WordPiece vocabulary, we are likely to benefit more from these embeddings than from Glove (Pennington et al., 2014) or FastText (Bojanowski et al., 2016). We use a dimensionality reduction algorithm like Singular Value Decomposition (SVD) to project the mBERT word embeddings to a lower dimensional space. Given mBERT word embedding ma-Algorithm 1: Multi-stage distillation. trix of dimension V  D , SVD finds the best E dimensional representation that minimizes sum of squares of the projections (of rows) to the subspace. We want to optimize the loss functions for representation LRL , logits LLL and cross-entropy LCE These optimizations can be scheduled differently to obtain different training regimens as follows. In this, we optimize the following losses jointly: 1 | D l | (cid:88) { x l ,y l } D l   LCE ( x l , y l )+ 1 | D u | (cid:88) { x u ,y u } D u (cid:18)  L RL ( x u , y u )+  L LL ( x u , y u ) (cid:19) (7) where ,  and  weigh the contribution of different losses. A high value of  makes the student focus more on easy targets; whereas a high value of  leads focus to the difficult ones. The above loss is computed over two different task-specific data segments. The first part involves cross-entropy loss over labeled data, whereas the second part involves representation and logit loss over unlabeled data. Instead of optimizing all loss functions jointly, we propose a stage-wise scheme to gradually transfer most general to task-specific representations from teacher to student. In this, we first train the student to mimic teacher representations from its l th layer by optimizing RRL on unlabeled data. The student learns the parameters for word embeddings (  w ), BiLSTM (  b ) and projections (cid:104) W f , b f (cid:105) . In the second stage, we optimize for the cross-entropy RCE and logit loss RLL jointly on both labeled and unlabeled data respectively to learn the corresponding parameters W s and (cid:104) W r , b r (cid:105) . The above can be further broken down in two stages, where we sequentially optimize logit loss RLL on unlabeled data and then optimize cross-entropy loss RCE on labeled data. Every stage learns parameters conditioned on those learned in previous stage followed by end-to-end fine-tuning. One potential drawback of end-to-end fine-tuning for stage-wise optimization is catastrophic forget-ting' (Howard and Ruder, 2018) where the model forgets information learned in earlier stages. To address this, we adopt gradual unfreezing  where we tune the model one layer at a time starting from the configuration at the end of previous stage. We start from the top layer that contains the most task-specific information and allow the model to configure the task-specific layer first while others remain frozen. The latter layers are gradually unfrozen one by one and the model trained till convergence. Once a layer is unfrozen, it maintains the state. When the last layer (word embeddings) is unfrozen, the entire network is trained end-to-end. The order of this unfreezing scheme (top-to-bottom) is reverse of that in (Howard and Ruder, 2018) and we find this to work better in our setting with the following intuition. At the end of the first stage on optimizing RRL , the student learns to generate representations similar to that of the l th layer of the teacher. Now, we need to add only a few task-specific parameters ( (cid:104) W r , b r (cid:105) ) to optimize for logit loss RLL with all others frozen. Next, we gradually give the student more flexibility to optimize for task-specific loss by tuning the layers below where the number of parameters increases with depth ( |(cid:104) W r , b r (cid:105)| (cid:28) |  b | (cid:28) |  w | ). loss on a held-out set. Therefore, the model retains best possible performance from any iteration. Algorithm 1 shows overall processing scheme. Dataset Description: We evaluate our model XtremeDistil for multilingual NER on 41 languages and same setting as in (Rahimi et al., 2019). This data is derived from WikiAnn NER corpus (Pan et al., 2017) and partitioned into training, development and test sets. All NER results are reported in this test set for a fair comparison between existing works. We report the average F 1 -score (  ) and standard deviation  between scores across 41 languages for phrase-level evaluation. Refer to Figure 2 for language codes and corresponding distribution of training labels. We also perform experiments with data from four other domains (refer to Table 1): IMDB (Maas et al., 2011), SST-2 (Socher et al., 2013) and Elec (McAuley and Leskovec, 2013) for sentiment analysis for movie and electronics product reviews, DbPedia (Zhang et al., 2015) and Ag News (Zhang et al., 2015) for topic classification of Wikipedia and news articles. NER Tags: The NER corpus uses IOB2 tagging strategy with entities like LOC, ORG and PER. Following mBERT, we do not use language markers and share these tags across all languages. We Strategy Features Transfer = 0.7MM Transfer = 1.4MM Transfer = 7.2MM D0 Labels per lang. use additional syntactic markers like { CLS, SEP, PAD } and X' for marking segmented wordpieces contributing a total of 11 tags (with shared O'). Baselines: A trivial baseline (D0) is to learn models one per language using only corresponding labels for learning. This can be improved by merging all instances and sharing information across all languages (D0-S). Most of the concurrent and recent works (refer to Table 2 for an overview) leverage logits as optimization targets for distillation (D1). A few exceptions also use teacher internal representations along with soft logits (D2). For our model we consider multi-stage distillation, where we first optimize representation loss followed by jointly optimizing logit and cross-entropy loss (D3.1) and further improving it by gradual unfreezing of neural network layers (D3.2). Finally, we optimize the loss functions sequentially in three stages (D4.1) and improve it further by unfreezing mechanism (D4.2). We further compare all strategies while varying the amount of unlabeled transfer data for distillation (hyper-parameter settings in Appendix). Results: From Table 3, we observe all strategies that share information across languages to work better (D0-S vs. D0) with soft logits adding more value than hard targets (D1 vs. D0-S). Interestingly, we observe simply combining representation loss with logits (D3.1 vs. D2) hurts the model. We observe this strategy to be vulnerable to the hyper-parameters ( , ,  in Eqn. 7) used to combine multiple loss functions. We vary hyper-parameters in multiples of 10 and report best numbers. Stage-wise optimizations remove these hyper-parameters and improve performance. We also observe the gradual unfreezing scheme to improve both stage-wise distillation strategies significantly. Focusing on the data dimension, we observe all models to improve as more and more unlabeled data is used for transferring teacher knowledge to student. However, we also observe the improvement to slow down after a point where additional unlabeled data does not yield significant benefits. Table 4 shows the gradual performance improvement in XtremeDistil after every stage and unfreezing various neural network layers. Performance: We observe XtremeDistil in Table 5 to perform competitively with other models. mBERT-single models are fine-tuned per language with corresponding labels, whereas mBERT is fine-tuned with data across all languages. MMNER results are reported from Rahimi et al. (2019). Figure 2 shows the variation in F 1 -score across different languages with variable amount of training data for different models. We observe all the models to follow the general trend with some aber-(50,100) (50,200) (50,400) (50,600) (100,100)(100,200) (100,400) (100,600) (200,100) (200,200)(200,400)(200,600) (300,100) (300,200)(300,400)(300,600) 0 5 10 15 20 25 30 35 40 84 84.5 85 85.5 86 86.5 87 87.5 88 88.5 89 P a r a m e t e r C o m pr e ss i o n F1 Measure Figure 1b shows the variation in F 1 -scores of XtremeDistil and inference speedup against mBERT with different (linked) parameter configurations as before. As expected, the performance degrades with gradual speedup. We observe that parameter compression does not necessarily lead to an inference speedup. Reduction in the word embedding dimension leads to massive model compression, however, it does not have a similar effect on the latency. The BiLSTM hidden states, on the other hand, constitute the real latency bottleneck. One of the best configurations leads to 35 x compression, 51 x speedup over mBERT retaining nearly 95% of its performance. Parameter compression: XtremeDistil performs at par with MMNER in terms of F 1 -score while obtaining at least 41 x compression. Given L languages, MMNER learns ( L  1 ) ensembled and distilled models, one for each target language. Each of the MMNER language-specific models is comparable in size to our single multilingual model. We learn a single model for all languages, thereby, obtaining a compression factor of at least L = 41 . Figure 1a shows the variation in F 1 -scores of XtremeDistil and compression against mBERT with different configurations corresponding to the embedding dimension ( E ) and number of BiLSTM hidden states ( 2  H ). We observe that reducing the embedding dimension leads to great compression with minimal performance loss. Whereas, reducing the BiLSTM hidden states impacts the performance more and contributes less to the compression. Inference speedup: We compare the runtime inference efficiency of mBERT and our model in a single P100 GPU for batch inference (batch size = 32) on 1000 queries of sequence length 32 . We average the time taken for predicting labels for all the queries for each model aggregated over 100 runs. Compared to batch inference, the speedups are less for online inference (batch size = 1) at 17 x on Intel(R) Xeon(R) CPU (E5-2690 v4 @2.60GHz) (refer to Appendix for details). Models in all prior experiments are trained on 705 K labeled instances across all languages. In this setting, we consider only 100 labeled samples for each language with a total of 4 . 1 K instances. From Table 6, we observe mBERT to outperform MMNER by more than 17 percentage points with XtremeDistil closely following suit. Furthermore, we observe our model's performance to improve with the transfer set size depicting the importance of unlabeled transfer data for knowledge distillation. As before, a lot of additional data has marginal contribution. From Table 7 we observe randomly initialized word embeddings to work quite well. Multilingual FastText embeddings (Bojanowski et al., 2016) lead to minor improvement due to 38% overlap between FastText tokens and mBERT wordpieces. English Glove does much better. We experiment with dimensionality reduction techniques and find SVD to work better leading to marginal improvement over mBERT embeddings before reduction. As expected, fine-tuned mBERT embeddings perform better than that from pre-trained checkpoints. Which teacher layer to distil from? The topmost teacher layer captures more task-specific knowledge. However, it may be difficult for a shallow student to capture this knowledge given its limited capacity. On the other hand, the less-deep representations at the middle of teacher model are easier to mimic by shallow student. From Table 8 we observe the student to benefit most from distilling the 6 th or 7 th layer of the teacher. Comparison of student architecture. Recent works leverage both BiLSTM and Transformer as students. In this experiment, we vary the embedding dimension and hidden states for BiLSTM-, and embedding dimension and depth for Transformer-based students to obtain configurations with similar inference latency. Each of 13 configurations in Figure 3 depict F 1 -scores obtained (50,100) (200,100) (300,100) (50,200) (300,200) (50,400) (200,400) (100,400) (300,400) (50,600)(100,600)(200,600) (300,600) (48,2) (144,1) (72,2) (96,2)(132,2) (204,2)(228,2) (240,2) (252,2) (228,3)(240,3)(252,3)(276,3) 0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2 72 74 76 78 80 82 84 86 1 2 3 4 5 6 7 8 9 10 11 12 13 BiLSTM F-score Transformer Fscore BiLSTM Latency Transformer Latency Figure 3: BiLSTM and Transformer F 1 -score (left y-axis) vs. inference latency (right y-axis) in 13 different settings with corresponding embedding dimension and width / depth of the student as ( E, W/D ) . by students of different architecture but similar latency (refer to Table 15 in Appendix for statistics)  for strategy D0-S in Table 3. We observe that for low-latency configurations BiLSTMs with hidden states { 2  100 , 2  200 } work better than 2 -layer Transformers. Whereas, the latter starts performing better with more than 3 -layers although with a higher latency compared to the aforementioned BiLSTM configurations. We switch gear and focus on classification tasks. In contrast to sequence tagging, we use the last hidden state of the BiLSTM as the final sentence representation for projection, regression and softmax. Table 9 shows the distillation performance of XtremeDistil with different teachers on four benchmark text classification datasets. We observe the student to almost match the teacher performance for all of the datasets. The performance also improves with a better teacher, although the improvement is marginal as the student capacity saturates. Table 10 shows the distillation performance with only 500 labeled samples per class. The distilled student improves over the non-distilled version by 19 . 4 percent and matches the teacher performance for all of the tasks demonstrating the impact of distillation for low-resource settings. Comparison with other distillation techniques: SST-2 (Socher et al., 2013) from GLUE (Wang et al., 2018) has been used as a test bed for other distillation techniques for single instance classification tasks (as in this work). Table 11 shows the accuracy comparison of such methods reported in SST-2 development set with the same teacher. We extract 11 . 7 MM sentences from all IMDB movie reviews in Table 1 to form the unlabeled transfer set for distillation. We obtain the best performance on distilling with BERT Large (uncased, whole word masking model) than BERT Base  demonstrating a better student performance with a better teacher and outperforming other methods. Teacher hidden representation and distillation schedule: Internal teacher representations help in distillation, although a naive combination hurts the student model. We show that a distillation schedule with stagewise optimization, gradual unfreezing with a cosine learning rate scheduler (D4.1 + D4.2 in Table 3) obtains the best performance. We also show that the middle layers of the teacher are easier to distil by shallow students and result in the best performance (Table 8). Additionally, the student performance improves with bigger and better teachers (Tables 9 and 11). Student architecture: We compare different student architectures like BiLSTM and Transformer in terms of configuration and performance (Figure 3, Table 15 in Appendix), and observe BiLSTM to perform better at low-latency configurations, whereas the Transformer outperforms the former with more depth and higher latency budget. Unlabeled transfer data: We explored data dimension in Tables 3 and 6 and observed unlabeled data to be the key for knowledge transfer from pre-trained teachers to shallow students and bridge the performance gap. We observed a moderate amount of unlabeled transfer samples (0.7-1.5 MM) lead to the best student, whereas larger amounts of transfer data does not result in significant gains. This is particularly helpful for low-resource NER (with only 100 labeled samples per language as in Table 6). Performance trade-off: Parameter compression does not necessarily reduce inference latency, and vice versa. We explored model performance with parameter compression, inference latency and F 1 to show trade-off in Fig. 1 and Table 16 in Appendix. Multilingual word embeddings: Random initialization of word embeddings work well. A better initialization, which is also parameter-efficient, is given by Singular Value Decomposition (SVD) over fine-tuned mBERT word embeddings with the best performance for downstream task (Table 7). Generalization: The outlined distillation techniques and strategies are model-, architecture-, and language-agnostic and can be easily extended to arbitrary tasks and languages, although we only focus on NER and classification in this work. Massive compression: Our techniques demonstrate massive compression ( 35 x for parameters) and inference speedup ( 51 x for latency) while retaining 95% of the teacher performance allowing deep pre-trained models to be deployed in practice. We develop XtremeDistil for massive multi-lingual NER and classification that performs close to huge pre-trained models like MBERT but with massive compression and inference speedup. Our distillation strategy leveraging teacher representations agnostic of its architecture and stage-wise optimization schedule outperforms existing ones. We perform extensive study of several distillation dimensions like the impact of unlabeled transfer set, embeddings and student architectures, and make interesting observations outlined in summary.
abstain abstain abstain method objective objective result abstain abstain abstain abstain abstain method abstain abstain abstain abstain abstain abstain abstain abstain result abstain abstain abstain abstain abstain abstain abstain abstain objective abstain objective method abstain objective abstain method result objective result objective objective method method method abstain abstain abstain method abstain other other other other other other other other abstain other other other abstain method abstain abstain abstain abstain other abstain method abstain method method abstain method method abstain abstain abstain abstain other abstain abstain abstain abstain abstain method abstain abstain abstain abstain abstain abstain method method abstain abstain method abstain method abstain abstain abstain abstain abstain abstain abstain abstain method method abstain abstain method abstain abstain abstain abstain abstain abstain method method abstain abstain abstain abstain abstain abstain abstain abstain other abstain abstain abstain abstain abstain abstain abstain abstain abstain result abstain result result result abstain abstain result result result abstain result abstain abstain abstain result abstain abstain result abstain abstain abstain abstain abstain abstain result abstain result abstain abstain abstain abstain abstain abstain abstain result result abstain result abstain abstain result abstain abstain abstain abstain abstain result abstain abstain result other result abstain abstain abstain abstain result abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain objective result method