albert_zh

使用 TensorFlow 实现 用于自监督学习语言表示的轻量级 BERT

ALBert 是在 BERT 的基础上进行了一些改进。它在主要基准测试中以减少 30% 参数量的情况下，达到了最先进的性能。

对于 albert_base_zh 模型而言，其参数量仅为原始 BERT 模型的十分之一，同时保持了较高的准确率。

目前已有适用于中文的 ALBERT 预训练模型的不同版本，包括 TensorFlow、PyTorch 和 Keras。

基于海量中文语料预训练的 ALBERT 模型：参数更少，效果更好。即使是小模型也能在 13 项 NLP 任务中取得优异成绩，ALBERT 的三大改进使其登顶 GLUE 基准。

clueai 工具包：三行代码，三分钟即可定制一个 NLP API（零样本学习）

一键运行 10 个数据集、9 个基线模型，并详细对比不同任务上的模型效果，请访问 CLUE 基准测试。

一键运行 CLUE 中文任务：6 个中文分类或句子对任务（新）

使用方式：
1、克隆项目
   git clone https://github.com/brightmart/albert_zh.git
2、运行一键运行脚本（GPU 方式）：会自动下载模型和所有任务数据并开始运行。
   bash run_classifier_clue.sh
   执行该一键运行脚本将会自动下载所有任务数据，并为所有任务找到最优模型，然后测试得到提交结果

模型下载 中文预训练模型下载

1、albert_tiny_zh, albert_tiny_zh（训练时间更长，累计学习了 20 亿个样本）, 文件大小 16M，参数量 4M

训练和推理预测速度提升约 10 倍，精度基本保持不变，模型大小仅为 BERT 的 1/25；在语义相似度数据集 LCQMC 测试集上达到 85.4%，相比 BERT_base 仅下降 1.5 个百分点。

lcqmc 训练使用如下参数： --max_seq_length=128 --train_batch_size=64   --learning_rate=1e-4   --num_train_epochs=5 

albert_tiny 使用同样的大规模中文语料数据，层数仅为 4 层，hidden size 等向量维度大幅减少；尝试使用如下学习率来获得更好效果：{2e-5, 6e-5, 1e-4} 

【使用场景】任务相对比较简单一些或实时性要求高的任务，如语义相似度等句子对任务、分类任务；比较难的任务如阅读理解等，可以使用其他大模型。

 例如，可以使用 [TensorFlow Lite](https://www.tensorflow.org/lite) 在移动端进行部署，本文 [随后](#use_tflite) 对此进行了介绍，包括如何把模型转换成 TensorFlow Lite 格式以及对其进行性能测试等。
 
 一键运行 albert_tiny_zh（Linux，lcqmc 任务）：
 1) git clone https://github.com/brightmart/albert_zh
 2) cd albert_zh
 3) bash run_classifier_lcqmc.sh

1.1、albert_tiny_google_zh（累计学习了 10 亿个样本，Google 版本）, 模型大小 16M，性能与 albert_tiny_zh 一致

1.2、albert_small_google_zh（累计学习了 10 亿个样本，Google 版本），

 速度比 BERT_base 快 4 倍；LCQMC 测试集上比 BERT 下降仅 0.9 个百分点；去掉 Adam 后模型大小 18.5M；使用方法，见 #下游任务 微调
 

2、albert_large_zh, 参数量多，层数 24，文件大小 64M

参数量和模型大小仅为 BERT_base 的六分之一；在口语化描述相似性数据集 LCQMC 的测试集上相比 BERT_base 提升 0.2 个百分点

3、albert_base_zh（额外训练了 1.5 亿个实例，即 36k 步骤 * batch_size 4096）; albert_base_zh（小模型体验版）, 参数量 12M，层数 12，大小 40M

参数量仅为 BERT_base 的十分之一，模型大小也仅为十分之一；在口语化描述相似性数据集 LCQMC 的测试集上相比 BERT_base 下降约 0.6~1 个百分点；
相比未预训练，albert_base 提升 14 个百分点

4、albert_xlarge_zh_177k ; albert_xlarge_zh_183k（优先尝试）参数量多，层数 24，文件大小 230M

参数量和模型大小仅为 BERT_base 的一半；需要一张大的显卡；完整测试对比将后续添加；batch_size 不可太小，否则可能影响精度

快速加载

依托于 Huggingface-Transformers 2.2.2，可轻松调用以上模型。

tokenizer = AutoTokenizer.from_pretrained("MODEL_NAME")
model = AutoModel.from_pretrained("MODEL_NAME")

其中 MODEL_NAME 对应列表如下：

模型名	MODEL_NAME
albert_tiny_google_zh	voidful/albert_chinese_tiny
albert_small_google_zh	voidful/albert_chinese_small
albert_base_zh（来自 Google）	voidful/albert_chinese_base
albert_large_zh（来自 Google）	voidful/albert_chinese_large
albert_xlarge_zh（来自 Google）	voidful/albert_chinese_xlarge
albert_xxlarge_zh（来自 Google）	voidful/albert_chinese_xxlarge

更多通过 transformers 使用 albert 的 示例

预训练 预训练

生成特定格式的文件（tfrecords） 生成 tfrecords 文件

运行以下命令即可。项目自动了一个示例的文本文件（data/news_zh_1.txt）

   bash create_pretrain_data.sh

如果你有很多文本文件，可以通过传入参数的方式，生成多个特定格式的文件（tfrecords）

支持英语和其他非中文语言：

如果你正在为英语或其他非中文语言进行预训练，
你应该在 create_pretraining_data.py 中将 non_chinese 参数设置为 True；否则，默认情况下是使用中文全词掩码进行中文预训练。

使用命令执行预训练 GPU/TPU 上的预训练

GPU（brightmart 版，tiny 模型）：
export BERT_BASE_DIR=./albert_tiny_zh
nohup python3 run_pretraining.py --input_file=./data/tf*.tfrecord  \
--output_dir=./my_new_model_path --do_train=True --do_eval=True --bert_config_file=$BERT_BASE_DIR/albert_config_tiny.json \
--train_batch_size=4096 --max_seq_length=512 --max_predictions_per_seq=51 \
--num_train_steps=125000 --num_warmup_steps=12500 --learning_rate=0.00176    \
--save_checkpoints_steps=2000 --init_checkpoint=$BERT_BASE_DIR/albert_model.ckpt &

GPU（Google 版，small 模型）：
export BERT_BASE_DIR=./albert_small_zh_google
nohup python3 run_pretraining_google.py --input_file=./data/tf*.tfrecord --eval_batch_size=64 \
--output_dir=./my_new_model_path --do_train=True --do_eval=True --albert_config_file=$BERT_BASE_DIR/albert_config_small_google.json  --export_dir=./my_new_model_path_export \
--train_batch_size=4096 --max_seq_length=512 --max_predictions_per_seq=20 \
--num_train_steps=125000 --num_warmup_steps=12500 --learning_rate=0.00176   \
--save_checkpoints_steps=2000 --init_checkpoint=$BERT_BASE_DIR/albert_model.ckpt

TPU，需添加类似以下内容：
    --use_tpu=True  --tpu_name=grpc://10.240.1.66:8470 --tpu_zone=us-central1-a
    
注：如果你从头开始训练，可以不指定 init_checkpoint；
如果你从现有的模型基础上训练，指定一下 BERT_BASE_DIR 的路径，并确保 bert_config_file 和 init_checkpoint 两个参数的值能对应到相应的文件上；
领域上的预训练，根据数据的大小，可以不用训练特别久。

环境 环境

使用 Python3 + Tensorflow 1.x

例如 Tensorflow 1.4 或 1.5

下游任务 下游任务微调

使用 TensorFlow：

以使用 albert_base 做 LCQMC 任务为例。LCQMC 任务是在口语化描述的数据集上做文本的相似性预测。

我们将使用 LCQMC 数据集进行微调，这是一个口语语言语料库，用于训练和预测一对句子之间的语义相似性。

下载 LCQMC 数据集，包含训练、验证和测试集，训练集包含 24 万句口语化的中文句子对，标签为 1 或 0。1 表示句子语义相似，0 表示语义不相似。

通过运行下列命令做LCQMC数据集上的fine-tuning:

1. 克隆该项目：
      
      git clone https://github.com/brightmart/albert_zh.git
      
2. 运行以下命令进行微调。
    brightmart版本的tiny模型
    export BERT_BASE_DIR=./albert_tiny_zh
    export TEXT_DIR=./lcqmc
    nohup python3 run_classifier.py   --task_name=lcqmc_pair   --do_train=true   --do_eval=true   --data_dir=$TEXT_DIR   --vocab_file=./albert_config/vocab.txt  \
    --bert_config_file=./albert_config/albert_config_tiny.json --max_seq_length=128 --train_batch_size=64   --learning_rate=1e-4  --num_train_epochs=5 \
    --output_dir=./albert_lcqmc_checkpoints --init_checkpoint=$BERT_BASE_DIR/albert_model.ckpt &
    
    google版本的small模型
    export BERT_BASE_DIR=./albert_small_zh
    export TEXT_DIR=./lcqmc
    nohup python3 run_classifier_sp_google.py --task_name=lcqmc_pair   --do_train=true   --do_eval=true   --data_dir=$TEXT_DIR   --vocab_file=./albert_config/vocab.txt  \
    --albert_config_file=./$BERT_BASE_DIR/albert_config_small_google.json --max_seq_length=128 --train_batch_size=64   --learning_rate=1e-4   --num_train_epochs=5 \
    --output_dir=./albert_lcqmc_checkpoints --init_checkpoint=$BERT_BASE_DIR/albert_model.ckpt &

注意事项/注：
    1) 你需要下载预训练的中文ALBERT模型，并将LCQMC数据集也下载到项目目录中，假设模型目录名为albert_tiny_zh；数据集目录名为lcqmc。

    2) 在微调过程中，你可以尝试在albert_config_xxx.json文件中调整attention_probs_dropout_prob和hidden_dropout_prob参数，加入少量的dropout（例如0.1）。默认情况下，我们没有设置dropout。

    3) 为了获得更好的性能，可以尝试不同的学习率{2e-5, 6e-5, 1e-4}。

更新

******* 2019年11月3日：新增Google版本的albert_small和albert_tiny；

同时提供了一种方法，可将albert_tiny部署到移动设备上，对于序列长度为128的输入，推理时间仅需0.1秒，内存占用仅为60M *******

***** 2019年10月30日：添加了关于如何将模型转换为TensorFlow Lite以便边缘部署的简单指南 *****

***** 2019年10月15日：albert_tiny_zh的训练和推理速度是bert base的10倍，且保持了较高的准确率 *****

***** 2019年10月7日：增加了更多ALBERT模型 *****

新增albert_xlarge_zh；albert_base_zh_additional_steps，使用更多实例进行训练。

***** 2019年10月4日：支持了ALBERT的PyTorch和Keras版本 *****

a. 转换为PyTorch版本，并通过albert_pytorch完成你的任务。

b. 使用keras加载预训练模型，只需一行代码，通过bert4keras即可实现。

c. 使用TensorFlow 2.0中的ALBERT：通过bert-for-tf2使用或加载预训练模型。

10月6日发布了albert_xlarge。

***** 2019年10月2日：albert_large_zh和albert_base_zh *****

发布了albert_base_zh，其参数量仅为bert_base的10%，是一个小型模型（40M），训练速度非常快。

同时发布了albert_large_zh，其参数量仅为bert_base的16%（64M）。

***** 2019年9月28日：代码和测试函数 *****

为ALBERT相对于BERT的三项主要改动添加了代码和测试函数。

ALBERT模型介绍 Introduction of ALBERT

ALBERT模型是BERT的改进版，与最近其他State of the art的模型不同的是，这次是预训练小模型，效果更好、参数更少。

它对BERT进行了三个改造 Three main changes of ALBert from Bert：

1）词嵌入向量参数的因式分解 Factorized embedding parameterization

 O(V * H) to O(V * E + E * H)
 
 如以ALBert_xxlarge为例，V=30000, H=4096, E=128
   
 那么原先参数为V * H= 30000 * 4096 = 1.23亿个参数，现在则为V * E + E * H = 30000*128+128*4096 = 384万 + 52万 = 436万，
   
 词嵌入相关的参数变化前是变换后的28倍。

2）跨层参数共享 Cross-Layer Parameter Sharing

 参数共享能显著减少参数。共享可以分为全连接层、注意力层的参数共享；注意力层的参数对效果的减弱影响小一点。

3）段落连续性任务 Inter-sentence coherence loss.

 使用段落连续性任务。正例，使用从一个文档中连续的两个文本段落；负例，使用从一个文档中连续的两个文本段落，但位置调换了。
 
 避免使用原有的NSP任务，原有的任务包含隐含了预测主题这类过于简单的任务。

  We maintain that inter-sentence modeling is an important aspect of language understanding, but we propose a loss 
  based primarily on coherence. That is, for ALBERT, we use a sentence-order prediction (SOP) loss, which avoids topic 
  prediction and instead focuses on modeling inter-sentence coherence. The SOP loss uses as positive examples the 
  same technique as BERT (two consecutive segments from the same document), and as negative examples the same two 
  consecutive segments but with their order swapped. This forces the model to learn finer-grained distinctions about
  discourse-level coherence properties. 

其他变化，还有 Other changes：

1）去掉了dropout Remove dropout to enlarge capacity of model.
    最大的模型，训练了1百万步后，还是没有过拟合训练数据。说明模型的容量还可以更大，就移除了dropout
    （dropout可以认为是随机的去掉网络中的一部分，同时使网络变小一些）
    We also note that, even after training for 1M steps, our largest models still do not overfit to their training data. 
    As a result, we decide to remove dropout to further increase our model capacity.
    其他型号的模型，在我们的实现中我们还是会保留原始的dropout的比例，防止模型对训练数据的过拟合。
    
2）为加快训练速度，使用LAMB做为优化器 Use LAMB as optimizer, to train with big batch size
  使用了大的batch_size来训练(4096)。 LAMB优化器使得我们可以训练，特别大的批次batch_size，如高达6万。

3）使用n-gram(uni-gram,bi-gram, tri-gram）来做遮蔽语言模型 Use n-gram as make language model
   即以不同的概率使用n-gram，uni-gram的概率最大，bi-gram其次，tri-gram概率最小。
   本项目中目前使用的是在中文上做whole word mask，稍后会更新一下与n-gram mask的效果对比。n-gram从spanBERT中来。

训练语料/训练配置 Training Data & Configuration

30g中文语料，超过100亿汉字，包括多个百科、新闻、互动社区。

预训练序列长度sequence_length设置为512，批次batch_size为4096，训练产生了3.5亿个训练数据(instance)；每一个模型默认会训练125k步，albert_xxlarge将训练更久。

作为比较，roberta_zh预训练产生了2.5亿个训练数据、序列长度为256。由于albert_zh预训练生成的训练数据更多、使用的序列长度更长，

我们预计albert_zh会有比roberta_zh更好的性能表现，并且能更好处理较长的文本。

训练使用TPU v3 Pod，我们使用的是v3-256，它包含32个v3-8。每个v3-8机器，含有128G的显存。

模型性能与对比(英文) Performance and Comparision

中文任务集上效果对比测试 Performance on Chinese datasets

问题匹配语任务：LCQMC（句子对匹配）

模型	开发集(Dev)	测试集(Test)
BERT	89.4(88.4)	86.9(86.4)
ERNIE	89.8 (89.6)	87.2 (87.0)
BERT-wwm	89.4 (89.2)	87.0 (86.8)
BERT-wwm-ext	-	-
RoBERTa-zh-base	88.7	87.0
RoBERTa-zh-Large	89.9(89.6)	87.2(86.7)
RoBERTa-zh-Large(20w_steps)	89.7	87.0
ALBERT-zh-tiny	--	85.4
ALBERT-zh-small	--	86.0
ALBERT-zh-small(Pytorch)	--	86.8
ALBERT-zh-base-additional-36k-steps	87.8	86.3
ALBERT-zh-base	87.2	86.3
ALBERT-large	88.7	87.1
ALBERT-xlarge	87.3	87.7

注：只跑了一次ALBERT-xlarge，效果还可能提升

自然语言推断：XNLI 的中文版

模型	开发集	测试集
BERT	77.8 (77.4)	77.8 (77.5)
ERNIE	79.7 (79.4)	78.6 (78.2)
BERT-wwm	79.0 (78.4)	78.2 (78.0)
BERT-wwm-ext	79.4 (78.6)	78.7 (78.3)
XLNet	79.2	78.7
RoBERTa-zh-base	79.8	78.8
RoBERTa-zh-Large	80.2 (80.0)	79.9 (79.5)
ALBERT-base	77.0	77.1
ALBERT-large	78.0	77.5
ALBERT-xlarge	?	?

注：BERT-wwm-ext来自于这里；XLNet来自于这里; RoBERTa-zh-base，指12层RoBERTa中文模型

阅读理解任务：CRMC2018

语言模型、文本段预测准确性、训练时间 Mask Language Model Accuarcy & Training Time

Model	MLM eval acc	SOP eval acc	Training(Hours)	Loss eval
albert_zh_base	79.1%	99.0%	6h	1.01
albert_zh_large	80.9%	98.6%	22.5h	0.93
albert_zh_xlarge	?	?	53h(预估)	?
albert_zh_xxlarge	?	?	106h(预估)	?

注：? 将很快替换

模型参数和配置 Configuration of Models

代码实现和测试 Implementation and Code Testing

通过运行以下命令测试主要的改进点，包括但不限于词嵌入向量参数的因式分解、跨层参数共享、段落连续性任务等。

python test_changes.py

使用TensorFlow Lite(TFLite)在移动端进行部署:

这里我们主要介绍TFLite模型格式转换和性能测试。转换成TFLite模型后，对于如何在移 动端使用该模型，可以参考TFLite提供的Android/iOS应用完整开发案例教程页面。 该页面目前已经包含了文本分类， 文本问答两个Android案例。

下面以albert_tiny_zh 为例来介绍TFLite模型格式转换和性能测试：

1. Freeze graph from the checkpoint

Ensure to have >=1.14 1.x installed to use the freeze_graph tool as it is removed from 2.x distribution

pip install tensorflow==1.15

freeze_graph --input_checkpoint=./albert_model.ckpt \
  --output_graph=/tmp/albert_tiny_zh.pb \
  --output_node_names=cls/predictions/truediv \
  --checkpoint_version=1 --input_meta_graph=./albert_model.ckpt.meta --input_binary=true

2. Convert to TFLite format

We are going to use the new experimental tf->tflite converter that's distributed with the Tensorflow nightly build.

pip install tf-nightly

tflite_convert --graph_def_file=/tmp/albert_tiny_zh.pb \
  --input_arrays='input_ids,input_mask,segment_ids,masked_lm_positions,masked_lm_ids,masked_lm_weights' \
  --output_arrays='cls/predictions/truediv' \
  --input_shapes=1,128:1,128:128:1,128:1,128:1,128 \
  --output_file=/tmp/albert_tiny_zh.tflite \
  --enable_v1_converter --experimental_new_converter

3. Benchmark the performance of the TFLite model

See here for details about the performance benchmark tools in TFLite. For example: after building the benchmark tool binary for an Android phone, do the following to get an idea of how the TFLite model performs on the phone

adb push /tmp/albert_tiny_zh.tflite /data/local/tmp/
adb shell /data/local/tmp/benchmark_model_performance_options --graph=/data/local/tmp/albert_tiny_zh.tflite --perf_options_list=cpu

On an Android phone w/ Qualcomm's SD845 SoC, via the above benchmark tool, as of 2019/11/01, the inference latency is ~120ms w/ this converted TFLite model using 4 threads on CPU, and the memory usage is ~60MB for the model during inference. Note the performance will improve further with future TFLite implementation optimizations.

使用PyTorch版本:

download pre-trained model, and convert to PyTorch using:
 
  python convert_albert_tf_checkpoint_to_pytorch.py     
 

using albert_pytorch

使用Keras加载:

bert4keras 适配albert，能成功加载albert_zh的权重，只需要在load_pretrained_model函数里加上albert=True

load pre-trained model with bert4keras

使用tf2.0加载:

bert-for-tf2

使用案例-基于用户输入预测文本相似性 Use Case-Text Similarity Based on User Input

功能说明：用户可以通过本例了解如何加载训训练集实现基于用户输入的短文本相似度判断。可以基于该代码将程序灵活地拓展为后台服务或增加文本分类等示例。

涉及代码：similarity.py、args.py

步骤：

1、使用本模型进行文本相似性训练，保存模型文件至相应目录下

2、根据实际情况，修改args.py中的参数，参数说明如下：

#模型目录，存放ckpt文件
model_dir = os.path.join(file_path, 'albert_lcqmc_checkpoints/')

#config文件，存放模型的json文件
config_name = os.path.join(file_path, 'albert_config/albert_config_tiny.json')

#ckpt文件名称
ckpt_name = os.path.join(model_dir, 'model.ckpt')

#输出文件目录，训练时的模型输出目录
output_dir = os.path.join(file_path, 'albert_lcqmc_checkpoints/')

#vocab文件目录
vocab_file = os.path.join(file_path, 'albert_config/vocab.txt')

#数据目录，训练使用的数据集存放目录
data_dir = os.path.join(file_path, 'data/')

本例中的文件结构为：

|__args.py

|__similarity.py

|__data

|__albert_config

|__albert_lcqmc_checkpoints

|__lcqmc

3、修改用户输入单词

打开similarity.py，最底部如下代码：

if __name__ == '__main__':
    sim = BertSim()
    sim.start_model()
    sim.predict_sentences([("我喜欢妈妈做的汤", "妈妈做的汤我很喜欢喝")])

其中sim.start_model()表示加载模型，sim.predict_sentences的输入为一个元组数组，元组中包含两个元素分别为需要判定相似的句子。

4、运行python文件：similarity.py

支持的序列长度与批次大小的关系,12G显存 Trade off between batch Size and sequence length

System	Seq Length	Max Batch Size
albert-base	64	64
...	128	32
...	256	16
...	320	14
...	384	12
...	512	6
albert-large	64	12
...	128	6
...	256	2
...	320	1
...	384	0
...	512	0
albert-xlarge	-	-

Albert_zh xlarge 的训练损失学习曲线

Albert_xlarge 的所有参数

技术交流与问题讨论QQ群: 836811304 加入我们的QQ群

如果您有任何疑问，可以提交一个问题，或者发送邮件至：brightmart@hotmail.com；

目前使用 PyTorch 版本的 Albert 尚不明确，如果您知道如何操作，请随时发邮件给我们或提交一个问题。

您也可以提交 Pull Request，报告您在特定任务上的性能表现，或者添加关于如何加载 PyTorch 模型的方法等内容。

如果您有关于训练出最佳性能中文预训练模型的想法，也欢迎告知我们。

研究得到了来自 Google TensorFlow Research Cloud (TFRC) 的 Cloud TPU 支持

引用我们

Bright Liang Xu, albert_zh, (2019), GitHub 仓库, https://github.com/brightmart/albert_zh

参考文献

1、ALBERT: 一种用于语言表示自监督学习的轻量级 BERT

2、BERT: 面向语言理解的深度双向 Transformer 预训练

3、SpanBERT: 通过表示和预测跨度提升预训练效果

4、RoBERTa: 一种鲁棒优化的 BERT 预训练方法

5、面向深度学习的大批量优化：76 分钟内完成 BERT 训练（LAMB）

6、LAMB 优化器，TensorFlow 版本

7、预训练小模型也能拿下 13 项 NLP 任务，ALBERT 三大改造登顶 GLUE 基准

8、 albert_pytorch

9、使用 Keras 加载 Albert

10、使用 TF 2.0 加载 Albert

11、Google 官方的 Albert 仓库

12、chineseGLUE-中文任务基准测评：公开可用多个任务、基线模型、广泛测评与效果对比

albert_zh 快速上手指南

albert_zh 是基于 BERT 改进的轻量级中文预训练模型项目。它在大幅减少参数量（仅为 BERT 的 10%~50%）的同时，保持了优异的 NLP 任务性能，特别适合资源受限或对推理速度有要求的场景。

1. 环境准备

本项目主要基于 Python 3 和 TensorFlow 1.x 开发。

• 操作系统: Linux (推荐), macOS, Windows
• Python 版本: Python 3.6+
• 核心依赖:
  • TensorFlow 1.4 ~ 1.15 (官方示例基于 TF 1.x)
  • Git
• 硬件要求:
  • 训练/微调: 建议使用 NVIDIA GPU (支持 CUDA)。
  • 推理: CPU 即可运行 Tiny/Small 版本模型；大模型建议配备 GPU。

注意: 虽然项目原生支持 TensorFlow 1.x，但你也可以通过 Huggingface Transformers 或 bert4keras 等库在 TensorFlow 2.x 或 PyTorch 环境中加载这些预训练权重（详见“基本使用”部分）。

2. 安装步骤

第一步：克隆项目

使用 Git 将代码仓库下载到本地：

git clone https://github.com/brightmart/albert_zh.git
cd albert_zh

第二步：下载预训练模型

根据任务需求选择合适的模型版本。以下是常用模型的下载链接（直接下载解压到项目根目录）：

模型版本	特点	文件大小	下载链接
albert_tiny_zh	极速，参数量极少 (4M)，适合移动端或简单任务	16M	下载 albert_tiny_zh
albert_base_zh	平衡版，参数量为 BERT 的 1/10，通用性强	40M	下载 albert_base_zh
albert_large_zh	高性能，参数量为 BERT 的 1/6	64M	下载 albert_large_zh

下载后请确保目录结构正确，例如 albert_tiny_zh/ 文件夹下应包含 albert_model.ckpt 和 albert_config_tiny.json 等文件。

第三步：安装 Python 依赖

确保已安装 TensorFlow 1.x 环境：

pip install tensorflow-gpu==1.15.0  # 如有 GPU
# 或者
pip install tensorflow==1.15.0      # 仅 CPU

3. 基本使用

方式一：一键运行示例任务 (原生 TensorFlow)

项目提供了脚本，可自动下载数据并运行经典的 LCQMC (句子语义相似度) 任务。以下以 albert_tiny 模型为例：

# 1. 设置模型路径环境变量
export BERT_BASE_DIR=./albert_tiny_zh

# 2. 运行分类任务脚本 (会自动下载 LCQMC 数据集并开始训练/评估)
bash run_classifier_lcqmc.sh

注：该脚本会在后台运行 (nohup)，日志输出在当前目录。如需自定义参数（如学习率、batch_size），可编辑对应的 .sh 文件或参考 README 中的详细命令。

方式二：通过 Huggingface Transformers 快速加载 (推荐)

如果你习惯使用 transformers 库，可以直接一行代码加载中文 ALBERT 模型，无需手动下载权重文件。

前置安装：

pip install transformers torch tensorflow

Python 代码示例：

from transformers import AutoTokenizer, AutoModel

# 选择模型名称 (对应不同的 albert_zh 版本)
# 可选: voidful/albert_chinese_tiny, voidful/albert_chinese_base, voidful/albert_chinese_large 等
model_name = "voidful/albert_chinese_tiny"

# 加载分词器和模型
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModel.from_pretrained(model_name)

# 简单测试
text = "ALBERT 模型非常轻量且高效"
inputs = tokenizer(text, return_tensors="tf") # 或 return_tensors="pt" 用于 PyTorch

outputs = model(**inputs)
print("最后隐藏层状态形状:", outputs.last_hidden_state.shape)

支持的 Huggingface 模型标识符：

本地模型名	Huggingface Model Name
albert_tiny_google_zh	voidful/albert_chinese_tiny
albert_small_google_zh	voidful/albert_chinese_small
albert_base_zh	voidful/albert_chinese_base
albert_large_zh	voidful/albert_chinese_large
albert_xlarge_zh	voidful/albert_chinese_xlarge

方式三：自定义下游任务微调

若要针对自己的数据集进行微调，需准备 TFRecord 格式数据（或使用项目提供的转换脚本 create_pretrain_data.sh 生成），然后运行分类脚本：

export BERT_BASE_DIR=./albert_base_zh
export TEXT_DIR=./your_custom_data_dir

python3 run_classifier.py \
  --task_name=your_task \
  --do_train=true \
  --do_eval=true \
  --data_dir=$TEXT_DIR \
  --vocab_file=./albert_config/vocab.txt \
  --bert_config_file=$BERT_BASE_DIR/albert_config_base.json \
  --max_seq_length=128 \
  --train_batch_size=32 \
  --learning_rate=2e-5 \
  --num_train_epochs=3 \
  --output_dir=./output_checkpoints \
  --init_checkpoint=$BERT_BASE_DIR/albert_model.ckpt

提示: 对于中文任务，建议尝试的学习率范围为 {2e-5, 6e-5, 1e-4}。