SlowGuess/NAACL_2022_OCR huggingface dataset:
Zhuofeng Wu $^{1*}$  Sinong Wang $^{2}$  Jiatao Gu $^{2}$  Rui Hou $^{2}$  Yuxiao Dong $^{2,3\dagger}$  V.G.Vinod Vydiswaran $^{4,1}$  Hao Ma $^{2}$
$^{1}$ School of Information, University of Michigan  $^{2}$ Meta AI  $^{3}$ Tsinghua University
$^{4}$ Department of Learning Health Sciences, University of Michigan
{zhuofeng, vgvinodv}@umich.edu  
{sinongwang, jgu, rayhou, haom}@fb.com  
yuxiaod@tsinghua.edu.cn
Prompt tuning is a new, efficient NLP transfer learning paradigm that adds a task-specific prompt in each input instance during the model training stage. It freezes the pre-trained language model and only optimizes a few task-specific prompts. In this paper, we propose a conditional prompt generation method to generate prompts for each input instance, referred to as the Instance-Dependent Prompt Generation (IDPG). Unlike traditional prompt tuning methods that use a fixed prompt, IDPG introduces a lightweight and trainable component to generate prompts based on each input sentence. Extensive experiments on ten natural language understanding (NLU) tasks show that the proposed strategy consistently outperforms various prompt tuning baselines and is on par with other efficient transfer learning methods such as Compacter while tuning far fewer model parameters.
In recent years, pre-training a transformer model on a large corpus with language modeling tasks and fine-tuning it on different downstream tasks has become the primary transfer learning paradigm in natural language processing (Devlin et al., 2019). Notably, this paradigm requires updating and storing all the model parameters for each downstream task. As the model size proliferates (e.g., 330M parameters for BERT (Devlin et al., 2019) and 175B for GPT-3 (Brown et al., 2020)), it becomes computationally expensive and challenging to fine-tune the entire pre-trained language model (LM). Thus, it is natural to ask whether we can transfer the knowledge of a pre-trained LM to downstream tasks by keeping most of the parameters fixed and tuning only a small fraction of them.
Figure 1: Overall evaluation of competing approaches on ten NLU tasks, with parameters from classification heads excluded. Our method approaches RoBERTaFT's performance and uses fewer parameters than Adapter-based methods.
Previous studies have attempted to address this question from different perspectives. One line of research (Li and Liang, 2021) suggests augmenting the model with smaller, trainable modules and freezing the original transformer weights. Adapters (Houlsby et al., 2019; Pfeiffer et al., 2021, 2020), for example, insert a small set of additional modules between each transformer layer. Only these additional and task-specific modules are trained during fine-tuning, reducing the number of trainable parameters to  $\sim 1 - 3\%$  of the original transformer model per task. Compacter (Mahabadi et al., 2021) optimizes the training parameters further by designing a lightweight module to replace the bottleneck architecture in Adapters.
Another line of work focuses on prompting. The GPT-3 models (Brown et al., 2020; Schick and Schütze, 2021) find that, with proper manual prompts, a pre-trained LM can successfully match the fine-tuning performance of BERT models. LMBFF (Gao et al., 2021a), EFL (Wang et al., 2021), and AutoPrompt (Shin et al., 2020) extend this direction by inserting prompts in the input embedding
* Work partially done while interning at Meta AI.
† Work done when at Meta AI.
1Our code is publicly available at https://github. com/CSerxy/IDPG.
Human Language Technologies, pages 5507 - 5521
layer. However, these methods rely on grid-search for a natural language-based prompt from an ample search space, leading to optimization challenges.
This paper presents the instance-dependent prompt generation (IDPG) strategy for efficiently tuning large-scale LMs. Unlike traditional prompt-tuning methods that rely on a fixed prompt for each task, IDPG instead develops a conditional prompt generation model to generate prompts for each instance. Formally, the IDPG generator can be denoted as  $f(x; \mathbf{W})$ , where  $x$  is the instance representation and  $\mathbf{W}$  represents the trainable parameters. Note that by setting  $\mathbf{W}$  to a zero matrix and only training the bias, IDPG would degenerate into the traditional prompt tuning process (Lester et al., 2021). To further reduce the number of parameters in the generator  $f(x; \mathbf{W})$ , we propose to apply a lightweight bottleneck architecture (i.e., a two-layer perceptron) and then decompose it by a parameterized hypercomplex multiplication (PHM) layer (Zhang et al., 2021). To summarize, this work makes the following contributions:
- We introduce an input-dependent prompt generation method—IDPG—that only requires training 134K parameters per task, corresponding to  $\sim 0.04\%$  of a pre-trained LM such as RoBERTa-Large (Liu et al., 2019).
- Extensive evaluations on ten natural language understanding (NLU) tasks show that IDPG
consistently outperforms task-specific prompt tuning methods by 1.6-3.1 points. Additionally, it offers comparable performance to Adapter-based methods while using fewer parameters.
- We conduct substantial intrinsic studies, revealing how and why each component of the proposed model and the generated prompts could help the downstream tasks.
2.1 Manual Prompt
Manual prompt learning (Brown et al., 2020; Schick and Schütze, 2021) inserts a pre-defined label words in each input sentence. For example, it reformulates a sentence sentiment classification task with an input sentence  $S_{1}$  as
$$
x _ {i n} = [ \mathrm {C L S} ] P [ \mathrm {S E P} ] S _ {1} [ \mathrm {E O S} ],
$$
where  $P$  is the prompt such as "indicating the positive user sentiment". Using the pre-trained language model  $\mathbf{M}$ , we can obtain the sentence representation  $\mathbf{h}_{[CLS]} = \mathbf{M}(x_{in})$ , and train a task-specific head softmax( $\mathbf{Wh}_{[CLS]}$ ) to maximize the log-probability of the correct label. LM-BFF (Gao et al., 2021a) shows that adding a specifically designed prompt during fine-tuning can benefit the few-shot scenario. EFL (Wang et al., 2021) further suggests that reformulating the task as entailment can further improve the performance in both low-resource and high-resource scenarios.
Prompt tuning (Lester et al., 2021), prefix tuning (Li and Liang, 2021), and P-tuning (Liu et al., 2021a,b) methods propose to insert a trainable prefix in front of the input sequence. Specifically, they reformulate the input for single sentence tasks as
$$
x _ {i n} = \operatorname {c o n c a t} \left[ \mathbf {W} _ {p}, \mathbf {E} \left(\left[ \text {S E P} \right] S _ {2} [ \text {E O S} ]\right) \right]
$$
and for sentence pair tasks as
$$
x _ {i n} = \operatorname {c o n c a t} \left[ \mathbf {W} _ {p}, \mathbf {E} \left(\left[ \text {S E P} \right] S _ {2} \left[ \text {S E P} \right] S _ {3} \left[ \text {E O S} \right]\right) \right],
$$
where  $\mathbf{W}_p$  is the embedding table of the inserted prompt,  $S_{2}$  and  $S_{3}$  are input sentences, and  $\mathbf{E}$  denotes the operation of tokenization and extraction of embeddings. Apart from LM-BFF and EFL, there is no corresponding real text for the prompt as  $\mathbf{W}_p$  is a set of random-initialized tensors to represent the soft prompt.
(c) Instance-Dependent Prompt Generation
Figure 2: An illustration of (a) manual prompt; (b) prompt-tuning method; (c) our proposed method. The red block refers to the trainable module, while the blue block refers to the frozen module.
3 Instance-Dependent Prompt Generation (IDPG)
We now introduce our proposed method, IDPG, along with various model optimizations. The main procedure is illustrated in Figure 2.
3.1 Instance-Dependent Generation
Let us assume a task  $T$  with training data  $D_{train} = \{(x_i,y_i)\}_{i=1}^K$ . Following prompt tuning, we define the input  $x_i = \mathbf{E}\big([SEP]S_1[SEP]S_2[EOS]\big)$  for sentence-pair task or  $x_i = \mathbf{E}\big([SEP]S_1[EOS]\big)$  for single-sentence task, where  $\mathbf{E}(\cdot)$  is the token embedding for input sentences. Different from all previous works that only define a task-specific prompt  $\mathbf{W}_p(T) \in \mathbb{R}^{d \times t}$ , where  $t$  is the number of tokens in prompt representation and  $d$  is the hidden dimension, we propose an instance-dependent prompt generation method. Specifically, we suppose that the generation of prompt should not only depend on the task  $T$ , but also be affected by input sequence  $x_i$ . If  $\mathbf{M}(x_i) \in \mathbb{R}^d$  is a representation of the input se
quence  $x_{i}$  from same pre-trained LM M, we design a lightweight model  $\mathbf{G}$  to generate the prompt,
$$
\mathbf {W} _ {p} (T, x _ {i}) = \mathbf {G} (\mathbf {M} (x _ {i}), T), x _ {i} \in D _ {\text {t r a i n}} \tag {1}
$$
Then, we insert a prompt  $\mathbf{W}_p(T)$  together with input sequence  $x_{i}$  to infer  $y_{i}$  during fine-tuning. In this way, we have a unified template
$$
\operatorname {s o f t m a x} \left(\mathbf {W h} _ {[ C L S ]}\right) \tag {2}
$$
$$
\mathbf {h} _ {[ \mathrm {C L S} ]} = \mathbf {M} (\operatorname {c o n c a t} [ x _ {i}, \mathbf {W} _ {p} (T, x _ {i}) ]) \tag {3}
$$
where  $\mathbf{W}$  is the trainable LM classification head.
To reduce the number of trainable parameters in  $\mathbf{G}$ , we apply a lightweight bottleneck architecture (i.e., a two-layer perceptron) for generation. As illustrated in Figure 2 (c), the generator  $\mathbf{G}$  first projects the original  $d$ -dimensional sentence representation  $\mathbf{h}_i$  into  $m$  dimensions. After passing through a nonlinear function, generator  $\mathbf{G}$  projects the hidden representation back to a  $d$  dimensions
with  $t$  timestamps. The total number of parameters for generator  $\mathbf{G}$  is  $m(d + 1) + td(m + 1)$  (bias term included). This model can be regarded as the general version of prompt tuning: in the second layer of  $\mathbf{G}$ , the bias term  $td$  is a task-specific prompt, with preceding parts  $td \times m$  generating an instance-dependent prompt. The final prompt our method generated is a combination of both. In short, what we discussed here is to generate a  $t$ -length prompt for one Transformer layer. An optimization of multi-layer prompt generation will be introduced in Section 3.2.2.
We can control the added number of trainable parameters by setting  $m \ll d$ , but it is still expensive since hidden dimension  $d$  is usually large (1024 in BERT/RoBERTa-Large). In the sequel, we will introduce a parameter squeezing method to further reduce trainable parameters without sacrificing performance.
Note that our proposed method relies on the input sentence representation  $\mathbf{M}(x_i)$  to generate prompts. One caveat is that this method will have two forward passes of the pre-trained LM during inference time - first to generate  $\mathbf{M}(x_i)$  and then to generate classification results. However, the sentence representation  $\mathbf{M}(x_i)$  used in our method is task-agnostic. In practice, we can cache the prediction  $\mathbf{M}(x_i)$  and use it in various downstream tasks or rely on a lightweight sentence representation such as GloVe (Pennington et al., 2014) (Cf. Section 4.5.1).
We propose two optimization techniques to further improve our proposed method.
3.2.1 Parameterized Hypercomplex Multiplication (PHM) Layers
Inspired by the recent application of parameterized hypercomplex multiplication (PHM) layers (Zhang et al., 2021) in Compacter (Mahabadi et al., 2021), we leverage PHM layers to optimize our prompt generator,  $\mathbf{G}$ . Generally, the PHM layer is a fully-connected layer with form  $y = \mathbf{W}x + b$ , where  $x \in \mathbb{R}^d$  is the input feature,  $y \in \mathbb{R}^m$  is the output feature, and  $\mathbf{W} \in \mathbb{R}^{m \times d}$  and  $b \in \mathbb{R}^m$  are the trainable parameters. When  $m$  and  $d$  are large, the cost of learning  $\mathbf{W}$  becomes the main bottleneck. PHM replaces the matrix  $\mathbf{W}$  by a sum of Kronecker products of several small matrices. Given a user-defined hyperparameter  $n \in \mathbb{Z}^+$  that divides  $m$  and  $d$ ,  $\mathbf{W}$
can be calculated as follows:
$$
\mathbf {W} = \sum_ {i = 1} ^ {n} \mathbf {A} _ {i} \bigotimes \mathbf {B} _ {i} \tag {4}
$$
where  $\mathbf{A}_i\in \mathbb{R}^{n\times n}$ $\mathbf{B}_i\in \mathbb{R}^{\frac{m}{n}\times \frac{d}{n}}$  , and  $\otimes$  is Kronecker product. In this way, the number of trainable parameters is reduced to  $n\times (n\times n + \frac{m}{n}\times \frac{d}{n}) = n^3 +\frac{m\times d}{n}$  As  $n$  is usually much smaller than  $m$  and  $d$  , PHM reduces the amount of parameters by a factor of  $n$
Suppose that we have a two layer perceptron with down-sample projection  $\mathbf{W}_1\in \mathbb{R}^{m\times d}$  and upsample projection  $\mathbf{W}_2\in \mathbb{R}^{t\times d\times m}$ , where  $d$  is the input embedding dimension,  $m$  is the hidden layer dimension, and  $t$  is the number of tokens we generate. For example, we use RoBERTa-Large with hidden size  $d = 1024$ , generator hidden size  $m = 256$ ,  $n = 16$ , prompt length  $t = 5$ . By substituting the  $\mathbf{W}_1$  and  $\mathbf{W}_2$  by two PHM layers and letting  $A_{i}$  shared by both layers, we can reduce the number of parameters from 1.5M to 105K.
3.2.2 Multi-layer Prompt Tuning
Prompt tuning (Lester et al., 2021) and P-tuning (Liu et al., 2021b) both insert continuous prompts into the first transformer layer (cf. Figure 2(b)). While proven efficient in some specific settings, single layer prompt tuning has two main limitations: (i) Capturing deep contextual information: the impact of the first-layer prompts on final prediction is low when transformer goes deeper. (ii) Generalizing to long sequence tasks: it is unclear that prompt tuning can perform well in tasks with long input when only a limited number of parameters can be inserted in single layer.
Following Prefix tuning (Li and Liang, 2021) and P-tuning v2 (Liu et al., 2021a), we pretend our generated prompts at each transformer layer to address the above issues. However, simply generalizing our model (IDPG) to a multi-layer version (M-IDPG), will significantly increase the number of training parameters, since each layer requires an independent generator  $\mathbf{G}$ . Instead, we explore different architectures in Section 4.5.3 to balance the number of tuned parameters against model performance. In short, assuming each layer generator  $G_{i}$  has form  $y = \mathbf{W}x + b_{i}$ , we share the weight matrix  $\mathbf{W}$  across generators and set the bias term  $b_{i}\in \mathbb{R}^{m}$  to be layer-specific, where  $i = 1,\dots ,N$  is the layer index and  $N$  is the number of transformer layers.
Table 1: Main results of different transfer learning method. Each methods are evaluated on full test sets (dev sets for GLUE tasks). We report average results across 5 runs with different initialization. Bold marks the best result among all competing methods. Underline marks the best result among all prompt tuning methods. We report the average of accuracy and F1 for both MRPC and QQP, and average of Pearson and Spearman correlation coefficients for STS-B. For all the other tasks, we report accuracy.
Method	MPQA	Subj	CR	MR	SST-2	QNLI	RTE	MRPC	STS-B	QQP	Avg
Transformer Fine-tuning
RoBERTa	90.4±0.2	97.1±0.1	90.7±0.7	91.7±0.2	96.4±0.2	94.7±0.1	85.7±0.2	91.8±0.4	92.2±0.2	91.0±0.1	92.2
EFL	90.3±0.2	97.2±0.1	93.0±0.7	91.7±0.2	96.5±0.1	94.4±0.1	85.6±2.4	91.2±0.4	92.5±0.1	91.0±0.2	92.3
Adapter
Compacter	91.1±0.2	97.5±0.1	92.7±0.4	92.6±0.2	96.0±0.2	94.3±0.2	87.1±1.4	91.6±0.6	91.6±0.1	87.1±0.2	92.2
Adapter	90.8±0.2	97.5±0.1	92.8±0.3	92.5±0.1	96.1±0.1	94.8±0.2	88.1±0.4	91.8±0.6	92.1±0.1	89.9±0.1	92.6
Prompting
Prompt-tuning	90.3±0.2	95.5±0.4	91.2±1.1	91.0±0.2	94.2±0.3	86.0±0.3	87.0±0.4	84.3±0.3	87.2±0.2	81.6±0.1	88.8
Prompt-tuning-134	65.7±19	95.6±0.2	86.7±3.6	89.7±0.5	92.0±0.5	83.0±1.1	87.4±0.5	84.1±0.5	87.6±0.5	82.4±0.3	85.4
Ptuningv2	90.4±0.3	96.5±0.3	92.7±0.3	91.6±0.1	94.4±0.2	92.9±0.1	78.4±4.3	91.4±0.4	89.9±0.2	84.4±0.4	90.3
S-IDPG-PHM	89.6±0.3	94.4±0.3	90.3±0.2	89.3±0.4	94.7±0.2	90.7±0.3	89.2±0.2	84.3±0.8	84.7±0.9	82.5±0.2	89.0
S-IDPG-DNN	89.5±0.7	94.9±0.4	89.9±1.5	90.2±0.6	95.1±0.2	90.5±0.5	89.4±0.4	83.0±0.5	85.3±0.7	82.7±0.3	89.1
M-IDPG-PHM-GloVe	90.9±0.2	97.4±0.1	93.3±0.1	92.6±0.3	95.4±0.2	94.4±0.2	82.1±0.6	92.1±0.4	91.0±0.4	86.3±0.2	91.6
M-IDPG-PHM	91.2±0.2	97.5±0.1	93.2±0.3	92.6±0.3	96.0±0.3	94.5±0.1	83.5±0.7	92.3±0.2	91.4±0.4	86.2±0.1	91.9
M-IDPG-DNN	91.2±0.3	97.6±0.2	93.5±0.3	92.6±0.1	95.9±0.1	94.5±0.2	85.5±0.6	91.8±0.3	91.5±0.2	86.9±0.3	92.1
We evaluate on ten standard natural language understanding (NLU) datasets - MPQA (Wiebe et al., 2005), Subj (Pang and Lee, 2004), CR (Hu and Liu, 2004), MR (Pang and Lee, 2005), and six tasks from GLUE (Wang et al., 2019), viz. SST-2, QNLI, RTE, MRPC, STS-B (Cer et al., 2017) and QQP. We compare our proposed method with a wide range of methods, as follows:
Transformer fine-tuning: We instantiated two versions - a vanilla transformer fine-tuning (Liu et al., 2019) and the entailment-based finetuning (Wang et al., 2021).
Prompt tuning: We implemented two versions - standard prompt tuning (Lester et al., 2021) and multi-layer prompt tuning (Li and Liang, 2021; Liu et al., 2021a).
Adapter-based fine-tuning: This efficient transfer learning method inserts an adaptation module inside each transformer layer including Compactor (Mahabadi et al., 2021) and Adapter (Houlsby et al., 2019).
We compare these against two versions of single-layer instance-dependent generation methods: S-IDPG-DNN and S-IDPG-PhM. The first version is based on a 2-layer perceptron generator, which contains 1.5M parameters. The second one uses the PHM layer and only contains 105K parameters.
We also explore three versions of multi-layer instance-dependent generation methods: M-IDPG-DNN, M-IDPG-PHM, M-IDPG-PHM
GloVe. Again, the difference between the first two is in the prompt generator, while M-IDPG-PhM-GloVe uses GloVe to encode input sequences.
For a fair comparison, all the pre-trained LMs are 24-layer 16-head RoBERTa-Large models (Liu et al., 2019). Additional training details can be found in Appendix A.1. Notably, Prompt-tuning-134 uses 134 prompt lengths in Table 1, and it is set so to match the training parameters of the proposed method, M-IDPG-PHM.
4.2 Performance in high-resource scenario
Table 1 shows the results of all the methods on full datasets across 10 NLU tasks. We observe that: (i) Our proposed method M-IDPG-PHM consistently outperforms the prompt tuning method and Ptuning v2 by average 3.1pt and 1.6pt, respectively (except on the RTE dataset). (ii) Compared with other efficient transfer learning methods, IDPG performs slightly worse than the Compacter (Mahabadi et al., 2021) and Adapter (Houlsby et al., 2019), across the ten tasks. However, the gap is mostly from RTE and QQP. Note that IDPG uses 15K fewer parameters than the Compacter. M-IDPG-PHM is better than Compacter on four tasks and has the same performance on three tasks. (iii) The improvement of our method is more prominent in the single-sentence classification task. The four best results (MPQA, Subj, CR, MR) among all competing methods in single-sentence classification tasks are made by IDPG models. Specifically, M-IDPG-PHM performs 0.84pt and 0.36pt better than RoBERTa and EFL, respectively. (iv) PHM
based generator performs on par with the DNN-based generator while having a significantly lower number of trainable parameters. (v) GloVe-based sentence encoder also performs similar to LM-based sentence encoder, indicating the advancement of instance-dependent prompt generation does not rely on a robust contextual sentence encoder. (vi) When we fix the training parameters to be the same, the comparison between Prompt-tuning-134 and M-IDPG-PHM illustrates that our approach works better than prompt tuning not just because of using more parameters.
Table 2 lists the number of trainable parameters for different methods excluding the classification head. The general goal for efficient transfer learning is to train models with fewer parameters while achieving better performance. Traditional prompt-tuning method only requires training a token embedding table with a few thousand parameters. However, its performance is worse than a lightweight adapter model (e.g., Compacter with 149K parameters). Our proposed method, especially the M-IDPGPHM, falls in the gap between prompt-tuning and adapter model, since it only requires training 134K parameters and performs on par with Compacter.
Method	# Parameters
Transformer Fine-tune (Liu et al., 2019)	355M
Adapter (Houlsby et al., 2019)	1.55M
Compacter (Mahabadi et al., 2021)	149K
Prompt-tuning (Lester et al., 2021)	5K
Prompt-tuning-134 (Lester et al., 2021)	134K
P-Tuningv2 (Liu et al., 2021a)	120K
S-IDPG-PHM	105K
S-IDPG-DNN	1.5M
M-IDPG-PHM-GloVe	141K
M-IDPG-PHM	134K
M-IDPG-DNN	216K
Table 2: Number of trainable parameters of different methods. Note that we did not include the parameters from classification heads.
4.4 Performance in low-resource scenario
We further evaluate our proposed method in the low-resource scenario. Following the existing evaluation protocols in the few-shot setting (He et al., 2021), we sample a subset of the training data for each task with size  $K \in \{100,500,1000\}$  as our training data and another subset with size 1000 as a development set. We compare our proposed methods with all prompt tuning methods, one fine
tuning model (EFL), and one adapter tuning model (Compacter).
In the extreme low-resource case when  $K = 100$ , M-IDPG-PhM performs 2.5pt better than the traditional prompt tuning method and 0.5pt better than the multi-layer P-Tuning v2 method. This improvement illustrates that our method has better generalization in few-shot settings. When  $K$  becomes larger, IDPG-PhM still maintains good results with 1.9pt and 0.2pt improvement ( $K = 500$ ); and 2.0pt and 0.2pt improvement ( $K = 1000$ ) in accuracy with traditional prompt tuning and P-tuning v2 approaches, respectively. We also observe that sometimes when  $K$  is small, our method results have high variance (e.g., 4.6 on MPQA, when  $K = 100$ ). We suspect that this may be due to poor initialization leading the model to non-optimal parameters.
We also note that other state-of-the-art models, such as LM-BFF (Gao et al., 2021a), attempt to address the few-shot learning problem from a different perspective. We want to highlight that we are exploring a solution by training as few parameters as possible while maintaining good performance. Testing the limitation of our model without freezing any parameters would be an interesting investigation, but is not the main focus of this paper.
4.5 Intrinsic Study
We conduct several ablation studies including exploration of different generator architectures and impact of selecting different prompt positions.
4.5.1 Sentence Encoder: GloVe or LMs?
The proposed IDPG method relies on pre-trained LM to extract sentence representation, i.e., [CLS] token embedding. Obtaining contextualized transformer sentence embedding is often expensive if it is not pre-computed. One open question is to explore reliability on lightweight sentence representations such as GloVe embedding (Pennington et al., 2014) or token embedding of pre-trained language models.
To answer this question, we apply the pre-trained GloVe word vectors² to extract the sentence representation. Specifically, we take the average of word vectors as the sentence embeddings:
$$
\mathbf {M} \left(x _ {i}\right) = \frac {1}{k} \sum_ {j = 1} ^ {k} \mathrm {G l o V e} \left(t _ {j}\right), x _ {i} \in D _ {\text {t r a i n}} \tag {5}
$$
2Obtained from https://nlp.stanford.edu/ data/glove.6B.zip version glove.6b.300d.txt