 TensorFlow.org에서보기 |  구글 Colab에서 실행 |  GitHub의에서 소스보기 |  다운로드 노트북 |
이 예에서 우리는 tensorflow-모델 PIP 패키지를 사용하여 미세 조정을 통해 BERT 모델을 작동합니다.
이 튜토리얼의 기반이되는 pretrained BERT 모델도 볼 수 있습니다 TensorFlow 허브 는 참조 사용하는 방법을보고, 허브 부록
설정
TensorFlow 모델 정원 핍 패키지를 설치
-
tf-models-nightly매일 자동으로 생성 야간 모델 가든 패키지입니다. - 핍은 자동으로 모든 모델과 종속성을 설치합니다.
pip install -q tf-nightlypip install -q tf-models-nightly
수입
import os
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
import tensorflow_hub as hub
import tensorflow_datasets as tfds
tfds.disable_progress_bar()
from official.modeling import tf_utils
from official import nlp
from official.nlp import bert
# Load the required submodules
import official.nlp.optimization
import official.nlp.bert.bert_models
import official.nlp.bert.configs
import official.nlp.bert.run_classifier
import official.nlp.bert.tokenization
import official.nlp.data.classifier_data_lib
import official.nlp.modeling.losses
import official.nlp.modeling.models
import official.nlp.modeling.networks
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow_addons/utils/ensure_tf_install.py:44: UserWarning: You are currently using a nightly version of TensorFlow (2.3.0-dev20200623). TensorFlow Addons offers no support for the nightly versions of TensorFlow. Some things might work, some other might not. If you encounter a bug, do not file an issue on GitHub. UserWarning,
자원
이 디렉토리 구성, 어휘,이 튜토리얼에 사용되는 사전 교육을받은 검사 점을 포함 :
gs_folder_bert = "gs://cloud-tpu-checkpoints/bert/keras_bert/uncased_L-12_H-768_A-12"
tf.io.gfile.listdir(gs_folder_bert)
['bert_config.json', 'bert_model.ckpt.data-00000-of-00001', 'bert_model.ckpt.index', 'vocab.txt']
여기 TensorFlow 허브에서 사전 교육을받은 BERT 인코더를 얻을 수 있습니다 :
hub_url_bert = "https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/2"
자료
예를 들어 우리가 사용 TFDS에서 GLUE MRPC 데이터 세트를 .
이 집합이 섹션은 또한, 필요한 전처리를 처리하므로 그것이 직접적 BERT 모델에 공급 될 수 있도록 설정하지 않는다.
TensorFlow 데이터 집합에서 데이터 세트를 가져옵니다
마이크로 소프트 리서치 의역 코퍼스 (고언 & Brockett, 2005)는 한 쌍의 문장이 의미 적으로 동일 여부에 대한 인간의 주석을 자동으로 온라인 뉴스 소스로부터 추출 된 문장 쌍의 코퍼스이다.
- 라벨 수 : 2.
- 훈련 데이터 세트의 크기 : 3668.
- 평가 데이터 세트의 크기 : 408.
- 교육 및 평가 데이터 세트의 최대 시퀀스 길이 : 128.
glue, info = tfds.load('glue/mrpc', with_info=True,
# It's small, load the whole dataset
batch_size=-1)
Downloading and preparing dataset glue/mrpc/1.0.0 (download: 1.43 MiB, generated: Unknown size, total: 1.43 MiB) to /home/kbuilder/tensorflow_datasets/glue/mrpc/1.0.0... /usr/lib/python3/dist-packages/urllib3/connectionpool.py:860: InsecureRequestWarning: Unverified HTTPS request is being made. Adding certificate verification is strongly advised. See: https://urllib3.readthedocs.io/en/latest/advanced-usage.html#ssl-warnings InsecureRequestWarning) /usr/lib/python3/dist-packages/urllib3/connectionpool.py:860: InsecureRequestWarning: Unverified HTTPS request is being made. Adding certificate verification is strongly advised. See: https://urllib3.readthedocs.io/en/latest/advanced-usage.html#ssl-warnings InsecureRequestWarning) /usr/lib/python3/dist-packages/urllib3/connectionpool.py:860: InsecureRequestWarning: Unverified HTTPS request is being made. Adding certificate verification is strongly advised. See: https://urllib3.readthedocs.io/en/latest/advanced-usage.html#ssl-warnings InsecureRequestWarning) Shuffling and writing examples to /home/kbuilder/tensorflow_datasets/glue/mrpc/1.0.0.incomplete1RTRDK/glue-train.tfrecord Shuffling and writing examples to /home/kbuilder/tensorflow_datasets/glue/mrpc/1.0.0.incomplete1RTRDK/glue-validation.tfrecord Shuffling and writing examples to /home/kbuilder/tensorflow_datasets/glue/mrpc/1.0.0.incomplete1RTRDK/glue-test.tfrecord Dataset glue downloaded and prepared to /home/kbuilder/tensorflow_datasets/glue/mrpc/1.0.0. Subsequent calls will reuse this data.
list(glue.keys())
['test', 'train', 'validation']
info 객체는 데이터 집합을 설명하고는 기능입니다 :
info.features
FeaturesDict({
'idx': tf.int32,
'label': ClassLabel(shape=(), dtype=tf.int64, num_classes=2),
'sentence1': Text(shape=(), dtype=tf.string),
'sentence2': Text(shape=(), dtype=tf.string),
})
두 클래스는 다음과 같습니다
info.features['label'].names
['not_equivalent', 'equivalent']
여기에 훈련 세트에서 하나의 예입니다 :
glue_train = glue['train']
for key, value in glue_train.items():
print(f"{key:9s}: {value[0].numpy()}")
idx : 1680 label : 0 sentence1: b'The identical rovers will act as robotic geologists , searching for evidence of past water .' sentence2: b'The rovers act as robotic geologists , moving on six wheels .'
BERT 토크 나이
미세 조정에 대한 사전 교육을받은 모델은 당신은 당신이 훈련 도중 사용되는 동일 토큰 화, 어휘, 인덱스 매핑을 사용하고 있는지 확인해야합니다.
이 튜토리얼에 사용 된 BERT 토크 나이는 (그것은 TensorFlow 작전의 내장 아니에요) 순수 파이썬으로 작성된 것입니다. 그래서 당신은 단지로 모델에 연결 할 수 keras.layer 당신이 할 수처럼 preprocessing.TextVectorization .
다음 코드는 기본 모델에 사용 된 토크 나이를 재 구축 :
# Set up tokenizer to generate Tensorflow dataset
tokenizer = bert.tokenization.FullTokenizer(
vocab_file=os.path.join(gs_folder_bert, "vocab.txt"),
do_lower_case=True)
print("Vocab size:", len(tokenizer.vocab))
Vocab size: 30522
문장을 토큰 화 :
tokens = tokenizer.tokenize("Hello TensorFlow!")
print(tokens)
ids = tokenizer.convert_tokens_to_ids(tokens)
print(ids)
['hello', 'tensor', '##flow', '!'] [7592, 23435, 12314, 999]
미리 처리 데이터
섹션 수동 모델에 의해 예상되는 형식으로 데이터 집합을 전처리.
전처리 메모리에 빠르고 쉽게 수행 할 수 있도록이 데이터 세트는 작습니다. 큰 데이터 세트의 경우 tf_models 라이브러리는 전처리 및 데이터 집합을 다시 직렬화에 대한 몇 가지 도구가 포함되어 있습니다. 참조 부록 : 큰 데이터 세트 재 인코딩 자세한 내용을.
문장을 인코딩
이 모델은 두 개의 입력 문장이 서로 연결될 수 것으로 기대하고있다. 이 입력이 시작할 것으로 예상된다 [CLS] 토큰 "이 분류 문제", 각 문장이 끝나야 [SEP] "분리기"토큰 :
tokenizer.convert_tokens_to_ids(['[CLS]', '[SEP]'])
[101, 102]
추가하면서 모든 문장을 인코딩하여 시작 [SEP] 토큰, 및 울퉁불퉁-텐서로 포장 :
def encode_sentence(s):
tokens = list(tokenizer.tokenize(s.numpy()))
tokens.append('[SEP]')
return tokenizer.convert_tokens_to_ids(tokens)
sentence1 = tf.ragged.constant([
encode_sentence(s) for s in glue_train["sentence1"]])
sentence2 = tf.ragged.constant([
encode_sentence(s) for s in glue_train["sentence2"]])
print("Sentence1 shape:", sentence1.shape.as_list())
print("Sentence2 shape:", sentence2.shape.as_list())
Sentence1 shape: [3668, None] Sentence2 shape: [3668, None]
이제 붙일 [CLS] 토큰 번의 형성 비정형 텐서을 연결 input_word_ids 각 예 텐서. RaggedTensor.to_tensor() 가장 긴 시퀀스 제로 패드.
cls = [tokenizer.convert_tokens_to_ids(['[CLS]'])]*sentence1.shape[0]
input_word_ids = tf.concat([cls, sentence1, sentence2], axis=-1)
_ = plt.pcolormesh(input_word_ids.to_tensor())
마스크와 입력 형식
이 모델은 두 개의 추가 입력을 기대한다 :
- 입력 마스크
- 입력 형식
마스크는 내용과 패딩 사이에 명확하게 구분하기 위해 모델을 할 수 있습니다. 마스크는 동일한 형상 가진다 input_word_ids 하고 포함 1 어디든지 input_word_ids 패딩되지 않습니다.
input_mask = tf.ones_like(input_word_ids).to_tensor()
plt.pcolormesh(input_mask)
<matplotlib.collections.QuadMesh at 0x7f82246c0cf8>
"입력 타입"의 동일한 형상을 가지고 있지만, 비 패딩 영역 안에하는 포함 된 0 또는 1 토큰의 일부인 문장 나타낸다.
type_cls = tf.zeros_like(cls)
type_s1 = tf.zeros_like(sentence1)
type_s2 = tf.ones_like(sentence2)
input_type_ids = tf.concat([type_cls, type_s1, type_s2], axis=-1).to_tensor()
plt.pcolormesh(input_type_ids)
<matplotlib.collections.QuadMesh at 0x7f8224668438>
모두 함께 넣어
하나의 함수로 상기 텍스트를 구문 분석 코드를 수집하여 각각의 분할에 적용 glue/mrpc 세트.
def encode_sentence(s, tokenizer):
tokens = list(tokenizer.tokenize(s))
tokens.append('[SEP]')
return tokenizer.convert_tokens_to_ids(tokens)
def bert_encode(glue_dict, tokenizer):
num_examples = len(glue_dict["sentence1"])
sentence1 = tf.ragged.constant([
encode_sentence(s, tokenizer)
for s in np.array(glue_dict["sentence1"])])
sentence2 = tf.ragged.constant([
encode_sentence(s, tokenizer)
for s in np.array(glue_dict["sentence2"])])
cls = [tokenizer.convert_tokens_to_ids(['[CLS]'])]*sentence1.shape[0]
input_word_ids = tf.concat([cls, sentence1, sentence2], axis=-1)
input_mask = tf.ones_like(input_word_ids).to_tensor()
type_cls = tf.zeros_like(cls)
type_s1 = tf.zeros_like(sentence1)
type_s2 = tf.ones_like(sentence2)
input_type_ids = tf.concat(
[type_cls, type_s1, type_s2], axis=-1).to_tensor()
inputs = {
'input_word_ids': input_word_ids.to_tensor(),
'input_mask': input_mask,
'input_type_ids': input_type_ids}
return inputs
glue_train = bert_encode(glue['train'], tokenizer)
glue_train_labels = glue['train']['label']
glue_validation = bert_encode(glue['validation'], tokenizer)
glue_validation_labels = glue['validation']['label']
glue_test = bert_encode(glue['test'], tokenizer)
glue_test_labels = glue['test']['label']
데이터의 각 부분 집합은 기능의 사전, 라벨의 집합으로 변환되었습니다. 입력 사전의 각 기능은 동일한 모양을 가지고 있으며, 라벨의 수는 일치해야합니다 :
for key, value in glue_train.items():
print(f'{key:15s} shape: {value.shape}')
print(f'glue_train_labels shape: {glue_train_labels.shape}')
input_word_ids shape: (3668, 103) input_mask shape: (3668, 103) input_type_ids shape: (3668, 103) glue_train_labels shape: (3668,)
모델
모델 구축
첫 번째 단계는 사전 훈련 모델의 구성을 다운로드하는 것입니다.
import json
bert_config_file = os.path.join(gs_folder_bert, "bert_config.json")
config_dict = json.loads(tf.io.gfile.GFile(bert_config_file).read())
bert_config = bert.configs.BertConfig.from_dict(config_dict)
config_dict
{'attention_probs_dropout_prob': 0.1,
'hidden_act': 'gelu',
'hidden_dropout_prob': 0.1,
'hidden_size': 768,
'initializer_range': 0.02,
'intermediate_size': 3072,
'max_position_embeddings': 512,
'num_attention_heads': 12,
'num_hidden_layers': 12,
'type_vocab_size': 2,
'vocab_size': 30522}
config 코어의 출력을 예측하는 모델이다 Keras BERT 모델 정의 num_classes 최대 시퀀스 길이와 입력으로부터 max_seq_length .
이 기능은 인코더와 분류를 모두 반환합니다.
bert_classifier, bert_encoder = bert.bert_models.classifier_model(
bert_config, num_labels=2)
분류기는 3 개 개의 입력과 하나 개의 출력을 갖는다 :
tf.keras.utils.plot_model(bert_classifier, show_shapes=True, dpi=48)
데이터 트레이닝 세트에서 10 예 시험 배치에 그것을 실행합니다. 출력은 두 클래스의 logits이다 :
glue_batch = {key: val[:10] for key, val in glue_train.items()}
bert_classifier(
glue_batch, training=True
).numpy()
array([[ 0.05488977, -0.26042116],
[ 0.11358108, -0.09727937],
[ 0.14350253, -0.2465629 ],
[ 0.2775127 , -0.09028438],
[ 0.3606584 , -0.17138724],
[ 0.3287397 , -0.14672714],
[ 0.18621178, -0.13080403],
[ 0.21898738, 0.10716071],
[ 0.18413854, -0.13491377],
[ 0.20307963, -0.05396855]], dtype=float32)
TransformerEncoder 분류의 중앙에 위입니다 bert_encoder .
인코더를 검사, 우리는 자사의 스택 참조 Transformer 층이 그 같은 3 개 개의 입력에 연결 :
tf.keras.utils.plot_model(bert_encoder, show_shapes=True, dpi=48)
인코더 가중치를 복원
내장 때 인코더는 무작위로 초기화됩니다. 체크 포인트에서 인코더의 가중치를 복원
checkpoint = tf.train.Checkpoint(model=bert_encoder)
checkpoint.restore(
os.path.join(gs_folder_bert, 'bert_model.ckpt')).assert_consumed()
<tensorflow.python.training.tracking.util.CheckpointLoadStatus at 0x7f8242dadc88>
최적화 설정
BERT 체중 붕괴 (일명 "와 아담 최적화 채택 AdamW을 "). 또한 다음 먼저 0에서 따뜻하게 위로하고 0으로 붕괴하는 학습 속도 일정을 고용하고있다.
# Set up epochs and steps
epochs = 3
batch_size = 32
eval_batch_size = 32
train_data_size = len(glue_train_labels)
steps_per_epoch = int(train_data_size / batch_size)
num_train_steps = steps_per_epoch * epochs
warmup_steps = int(epochs * train_data_size * 0.1 / batch_size)
# creates an optimizer with learning rate schedule
optimizer = nlp.optimization.create_optimizer(
2e-5, num_train_steps=num_train_steps, num_warmup_steps=warmup_steps)
이 다시 표시 AdamWeightDecay 학습 속도를 일정 세트 최적화 :
type(optimizer)
official.nlp.optimization.AdamWeightDecay
최적화 및 그것의 일정을 사용자 정의하는 방법의 예를 보려면 참조 최적화 일정 부록 .
모델 기차
메트릭 정확성 그리고 우리는 손실로 스파 스 범주 교차 엔트로피를 사용합니다.
metrics = [tf.keras.metrics.SparseCategoricalAccuracy('accuracy', dtype=tf.float32)]
loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
bert_classifier.compile(
optimizer=optimizer,
loss=loss,
metrics=metrics)
bert_classifier.fit(
glue_train, glue_train_labels,
validation_data=(glue_validation, glue_validation_labels),
batch_size=32,
epochs=epochs)
Epoch 1/3 115/115 [==============================] - 25s 218ms/step - loss: 0.7047 - accuracy: 0.6101 - val_loss: 0.5219 - val_accuracy: 0.7181 Epoch 2/3 115/115 [==============================] - 24s 210ms/step - loss: 0.5068 - accuracy: 0.7560 - val_loss: 0.5047 - val_accuracy: 0.7794 Epoch 3/3 115/115 [==============================] - 24s 209ms/step - loss: 0.3812 - accuracy: 0.8332 - val_loss: 0.4839 - val_accuracy: 0.8137 <tensorflow.python.keras.callbacks.History at 0x7f82107c8cf8>
이제 작동하는지 확인하기 위해 사용자 정의 예에 미세 조정 모델을 실행합니다.
일부 문장 쌍을 인코딩하여 시작합니다 :
my_examples = bert_encode(
glue_dict = {
'sentence1':[
'The rain in Spain falls mainly on the plain.',
'Look I fine tuned BERT.'],
'sentence2':[
'It mostly rains on the flat lands of Spain.',
'Is it working? This does not match.']
},
tokenizer=tokenizer)
이 모델은 클래스보고해야합니다 1 첫 번째 예제와 클래스 "일치" 0 두 번째는 "불일치"
result = bert_classifier(my_examples, training=False)
result = tf.argmax(result).numpy()
result
array([1, 0])
np.array(info.features['label'].names)[result]
array(['equivalent', 'not_equivalent'], dtype='<U14')
모델 저장
종종 모델을 훈련의 목표는 뭔가를 사용하므로 모델을 내 보낸 다음 확인 작동하는지로 복원하는 것입니다.
export_dir='./saved_model'
tf.saved_model.save(bert_classifier, export_dir=export_dir)
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/tracking/tracking.py:111: Model.state_updates (from tensorflow.python.keras.engine.training) is deprecated and will be removed in a future version. Instructions for updating: This property should not be used in TensorFlow 2.0, as updates are applied automatically. Warning:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/tracking/tracking.py:111: Model.state_updates (from tensorflow.python.keras.engine.training) is deprecated and will be removed in a future version. Instructions for updating: This property should not be used in TensorFlow 2.0, as updates are applied automatically. Warning:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/tracking/tracking.py:111: Layer.updates (from tensorflow.python.keras.engine.base_layer) is deprecated and will be removed in a future version. Instructions for updating: This property should not be used in TensorFlow 2.0, as updates are applied automatically. Warning:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/tracking/tracking.py:111: Layer.updates (from tensorflow.python.keras.engine.base_layer) is deprecated and will be removed in a future version. Instructions for updating: This property should not be used in TensorFlow 2.0, as updates are applied automatically. INFO:tensorflow:Assets written to: ./saved_model/assets INFO:tensorflow:Assets written to: ./saved_model/assets
reloaded = tf.saved_model.load(export_dir)
reloaded_result = reloaded([my_examples['input_word_ids'],
my_examples['input_mask'],
my_examples['input_type_ids']], training=False)
original_result = bert_classifier(my_examples, training=False)
# The results are (nearly) identical:
print(original_result.numpy())
print()
print(reloaded_result.numpy())
[[-1.1238481 0.92107666] [ 0.35722053 -0.4061358 ]] [[-1.1238478 0.9210764 ] [ 0.35722044 -0.40613574]]
부록
큰 데이터 집합을 다시 인코딩
당신이이 튜토리얼 명확성을 위해, 메모리에 데이터 집합을 다시는 인코딩.
때문 만 가능했던 glue/mrpc 매우 작은 데이터 세트입니다. 더 큰 데이터 세트를 처리하기 위해 tf_models 라이브러리 것은 처리하고 효율적인 교육을위한 데이터 집합을 재 인코딩을위한 몇 가지 도구가 포함되어 있습니다.
첫 번째 단계는 데이터 세트의 기능은 변환되어야하는 설명한다 :
processor = nlp.data.classifier_data_lib.TfdsProcessor(
tfds_params="dataset=glue/mrpc,text_key=sentence1,text_b_key=sentence2",
process_text_fn=bert.tokenization.convert_to_unicode)
그런 다음 새 TFRecord 파일을 생성하는 변환을 적용합니다.
# Set up output of training and evaluation Tensorflow dataset
train_data_output_path="./mrpc_train.tf_record"
eval_data_output_path="./mrpc_eval.tf_record"
max_seq_length = 128
batch_size = 32
eval_batch_size = 32
# Generate and save training data into a tf record file
input_meta_data = (
nlp.data.classifier_data_lib.generate_tf_record_from_data_file(
processor=processor,
data_dir=None, # It is `None` because data is from tfds, not local dir.
tokenizer=tokenizer,
train_data_output_path=train_data_output_path,
eval_data_output_path=eval_data_output_path,
max_seq_length=max_seq_length))
마지막으로 만들 tf.data 그 TFRecord 파일에서 입력 파이프 라인 :
training_dataset = bert.run_classifier.get_dataset_fn(
train_data_output_path,
max_seq_length,
batch_size,
is_training=True)()
evaluation_dataset = bert.run_classifier.get_dataset_fn(
eval_data_output_path,
max_seq_length,
eval_batch_size,
is_training=False)()
그 결과 tf.data.Datasets 반환 (features, labels) 쌍에 의해 예상대로 keras.Model.fit :
training_dataset.element_spec
({'input_word_ids': TensorSpec(shape=(32, 128), dtype=tf.int32, name=None),
'input_mask': TensorSpec(shape=(32, 128), dtype=tf.int32, name=None),
'input_type_ids': TensorSpec(shape=(32, 128), dtype=tf.int32, name=None)},
TensorSpec(shape=(32,), dtype=tf.int32, name=None))
교육 및 평가를 위해 tf.data.Dataset 만들기
여기에 데이터 로딩을 수정해야하는 경우 당신이 시작하는 몇 가지 코드는 다음과 같습니다
def create_classifier_dataset(file_path, seq_length, batch_size, is_training):
"""Creates input dataset from (tf)records files for train/eval."""
dataset = tf.data.TFRecordDataset(file_path)
if is_training:
dataset = dataset.shuffle(100)
dataset = dataset.repeat()
def decode_record(record):
name_to_features = {
'input_ids': tf.io.FixedLenFeature([seq_length], tf.int64),
'input_mask': tf.io.FixedLenFeature([seq_length], tf.int64),
'segment_ids': tf.io.FixedLenFeature([seq_length], tf.int64),
'label_ids': tf.io.FixedLenFeature([], tf.int64),
}
return tf.io.parse_single_example(record, name_to_features)
def _select_data_from_record(record):
x = {
'input_word_ids': record['input_ids'],
'input_mask': record['input_mask'],
'input_type_ids': record['segment_ids']
}
y = record['label_ids']
return (x, y)
dataset = dataset.map(decode_record,
num_parallel_calls=tf.data.experimental.AUTOTUNE)
dataset = dataset.map(
_select_data_from_record,
num_parallel_calls=tf.data.experimental.AUTOTUNE)
dataset = dataset.batch(batch_size, drop_remainder=is_training)
dataset = dataset.prefetch(tf.data.experimental.AUTOTUNE)
return dataset
# Set up batch sizes
batch_size = 32
eval_batch_size = 32
# Return Tensorflow dataset
training_dataset = create_classifier_dataset(
train_data_output_path,
input_meta_data['max_seq_length'],
batch_size,
is_training=True)
evaluation_dataset = create_classifier_dataset(
eval_data_output_path,
input_meta_data['max_seq_length'],
eval_batch_size,
is_training=False)
training_dataset.element_spec
({'input_word_ids': TensorSpec(shape=(32, 128), dtype=tf.int64, name=None),
'input_mask': TensorSpec(shape=(32, 128), dtype=tf.int64, name=None),
'input_type_ids': TensorSpec(shape=(32, 128), dtype=tf.int64, name=None)},
TensorSpec(shape=(32,), dtype=tf.int64, name=None))
TFHub에 TFModels BERT
당신은 얻을 수 BERT 모델 에서 기성품 TFHub을 . 이 위에 분류 헤드를 추가 할 어렵지 않을 것 hub.KerasLayer
# Note: 350MB download.
import tensorflow_hub as hub
hub_encoder = hub.KerasLayer(hub_url_bert, trainable=True)
print(f"The Hub encoder has {len(hub_encoder.trainable_variables)} trainable variables")
The Hub encoder has 199 trainable variables
테스트 데이터의 배치에서 실행합니다 :
result = hub_encoder(
inputs=[glue_train['input_word_ids'][:10],
glue_train['input_mask'][:10],
glue_train['input_type_ids'][:10],],
training=False,
)
print("Pooled output shape:", result[0].shape)
print("Sequence output shape:", result[1].shape)
Pooled output shape: (10, 768) Sequence output shape: (10, 103, 768)
이 시점에서 분류 머리를 직접 추가하는 간단한 것입니다.
bert_models.classifier_model 기능은 TensorFlow 허브에서 인코더 상에 분류기를 구축 할 수 있습니다 :
hub_classifier, hub_encoder = bert.bert_models.classifier_model(
# Caution: Most of `bert_config` is ignored if you pass a hub url.
bert_config=bert_config, hub_module_url=hub_url_bert, num_labels=2)
TFHub에서이 모델을로드에 하나의 단점은 내부 keras 층의 구조가 복원되지 않는다는 것이다. 더 어렵다 그래서 검사 또는 모델을 수정합니다. TransformerEncoder 모델은 이제 단일 층 :
tf.keras.utils.plot_model(hub_classifier, show_shapes=True, dpi=64)
try:
tf.keras.utils.plot_model(hub_encoder, show_shapes=True, dpi=64)
assert False
except Exception as e:
print(f"{type(e).__name__}: {e}")
AttributeError: 'KerasLayer' object has no attribute 'layers'
낮은 수준의 모델 구축
당신이 모델의 건축을 통해 좀 더 컨트롤을해야하는 경우 있음을 지적 그것의 가치 classifier_model 기능은 이전에 사용 정말 이상 단지 얇은 래퍼 nlp.modeling.networks.TransformerEncoder 및 nlp.modeling.models.BertClassifier 클래스. 그냥 당신이 아키텍처를 수정 시작하면 처음부터 재교육해야합니다 있도록이 사전에 훈련 된 검사 점을 다시로드 할 올바른 또는 가능하지 않을 수 있음을 기억하십시오.
인코더를 구축 :
transformer_config = config_dict.copy()
# You need to rename a few fields to make this work:
transformer_config['attention_dropout_rate'] = transformer_config.pop('attention_probs_dropout_prob')
transformer_config['activation'] = tf_utils.get_activation(transformer_config.pop('hidden_act'))
transformer_config['dropout_rate'] = transformer_config.pop('hidden_dropout_prob')
transformer_config['initializer'] = tf.keras.initializers.TruncatedNormal(
stddev=transformer_config.pop('initializer_range'))
transformer_config['max_sequence_length'] = transformer_config.pop('max_position_embeddings')
transformer_config['num_layers'] = transformer_config.pop('num_hidden_layers')
transformer_config
{'hidden_size': 768,
'intermediate_size': 3072,
'num_attention_heads': 12,
'type_vocab_size': 2,
'vocab_size': 30522,
'attention_dropout_rate': 0.1,
'activation': <function official.modeling.activations.gelu.gelu(x)>,
'dropout_rate': 0.1,
'initializer': <tensorflow.python.keras.initializers.initializers_v2.TruncatedNormal at 0x7f81145cb3c8>,
'max_sequence_length': 512,
'num_layers': 12}
manual_encoder = nlp.modeling.networks.TransformerEncoder(**transformer_config)
가중치를 복원
checkpoint = tf.train.Checkpoint(model=manual_encoder)
checkpoint.restore(
os.path.join(gs_folder_bert, 'bert_model.ckpt')).assert_consumed()
<tensorflow.python.training.tracking.util.CheckpointLoadStatus at 0x7f813c336fd0>
테스트 실행 :
result = manual_encoder(my_examples, training=True)
print("Sequence output shape:", result[0].shape)
print("Pooled output shape:", result[1].shape)
Sequence output shape: (2, 23, 768) Pooled output shape: (2, 768)
분류 자에 랩 :
manual_classifier = nlp.modeling.models.BertClassifier(
bert_encoder,
num_classes=2,
dropout_rate=transformer_config['dropout_rate'],
initializer=tf.keras.initializers.TruncatedNormal(
stddev=bert_config.initializer_range))
manual_classifier(my_examples, training=True).numpy()
array([[-0.22512403, 0.07213479],
[-0.21233292, 0.1311737 ]], dtype=float32)
최적화 및 일정
모델을 훈련하는 데 사용되는 최적화는 사용하여 만든 nlp.optimization.create_optimizer 기능 :
optimizer = nlp.optimization.create_optimizer(
2e-5, num_train_steps=num_train_steps, num_warmup_steps=warmup_steps)
학습 속도 일정 및 최적화 설정 래퍼 그 높은 수준.
여기에 사용되는 기본 학습 속도 일정은 교육 실행을 통해 제로로 선형 감쇠입니다 :
epochs = 3
batch_size = 32
eval_batch_size = 32
train_data_size = len(glue_train_labels)
steps_per_epoch = int(train_data_size / batch_size)
num_train_steps = steps_per_epoch * epochs
decay_schedule = tf.keras.optimizers.schedules.PolynomialDecay(
initial_learning_rate=2e-5,
decay_steps=num_train_steps,
end_learning_rate=0)
plt.plot([decay_schedule(n) for n in range(num_train_steps)])
[<matplotlib.lines.Line2D at 0x7f8115ab5320>]
이것은, 차례로 래핑되는 WarmUp 직선 훈련의 처음 10 % 이상을 목표 값으로 학습 속도를 증가 시킨다는 일정 :
warmup_steps = num_train_steps * 0.1
warmup_schedule = nlp.optimization.WarmUp(
initial_learning_rate=2e-5,
decay_schedule_fn=decay_schedule,
warmup_steps=warmup_steps)
# The warmup overshoots, because it warms up to the `initial_learning_rate`
# following the original implementation. You can set
# `initial_learning_rate=decay_schedule(warmup_steps)` if you don't like the
# overshoot.
plt.plot([warmup_schedule(n) for n in range(num_train_steps)])
[<matplotlib.lines.Line2D at 0x7f81150c27f0>]
그런 다음 생성 nlp.optimization.AdamWeightDecay BERT 모델 구성한 일정을 사용하여 :
optimizer = nlp.optimization.AdamWeightDecay(
learning_rate=warmup_schedule,
weight_decay_rate=0.01,
epsilon=1e-6,
exclude_from_weight_decay=['LayerNorm', 'layer_norm', 'bias'])