bert
1.0.0
***** 2020 년 3 월 11 일 : 작은 버트 모델 *****
이것은 잘 읽은 학생들에게 언급 된 24 개의 작은 버트 모델 (영어만으로, uncased, Word Piece Masking으로 훈련 된)의 출시입니다.
우리는 표준 BERT 레시피 (모델 아키텍처 및 교육 목표 포함)가 Bert-Base 및 Bert-Large를 넘어 광범위한 모델 크기에 효과적임을 보여주었습니다. 작은 버트 모델은 제한된 계산 자원이있는 환경을위한 것입니다. 원래 버트 모델과 같은 방식으로 미세 조정할 수 있습니다. 그러나 지식 증류의 맥락에서 가장 효과적이며, 미세 조정 라벨은 더 크고 정확한 교사가 생성합니다.
우리의 목표는 계산 자원이 적은 기관의 연구를 가능하게하고 커뮤니티가 모델 용량 증가에 대한 혁신 방향을 찾도록 장려하는 것입니다.
여기에서 또는 아래 표에서 개별적으로 24 개를 모두 다운로드 할 수 있습니다.
| H = 128 | H = 256 | H = 512 | H = 768 | |
|---|---|---|---|---|
| l = 2 | 2/128 (Bert-Tiny) | 2/256 | 2/512 | 2/768 |
| l = 4 | 4/128 | 4/256 (Bert-Mini) | 4/512 (Bert-Small) | 4/768 |
| l = 6 | 6/128 | 6/256 | 6/512 | 6/768 |
| l = 8 | 8/128 | 8/256 | 8/512 (Bert-Medium) | 8/768 |
| l = 10 | 10/128 | 10/256 | 10/512 | 10/768 |
| l = 12 | 12/128 | 12/256 | 12/512 | 12/768 (Bert-Base) |
이 릴리스의 Bert-Base 모델은 완전성에 대해서만 포함됩니다. 그것은 원래 모델과 동일한 정권하에 재 훈련되었습니다.
테스트 세트의 해당 접착제 점수는 다음과 같습니다.
| 모델 | 점수 | 콜라 | SST-2 | MRPC | STS-B | QQP | mnli-m | mnli-mm | QNLI (v2) | RTE | wnli | 도끼 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Bert-Tiny | 64.2 | 0.0 | 83.2 | 81.1/71.1 | 74.3/73.6 | 62.2/83.4 | 70.2 | 70.3 | 81.5 | 57.2 | 62.3 | 21.0 |
| 버트 미니 | 65.8 | 0.0 | 85.9 | 81.1/71.8 | 75.4/73.3 | 66.4/86.2 | 74.8 | 74.3 | 84.1 | 57.9 | 62.3 | 26.1 |
| Bert-small | 71.2 | 27.8 | 89.7 | 83.4/76.2 | 78.8/77.0 | 68.1/87.0 | 77.6 | 77.0 | 86.4 | 61.8 | 62.3 | 28.6 |
| 베르트-메디움 | 73.5 | 38.0 | 89.6 | 86.6/81.6 | 80.4/78.4 | 69.6/87.9 | 80.0 | 79.1 | 87.7 | 62.2 | 62.3 | 30.5 |
각 작업마다 아래 목록에서 최고의 미세 조정 하이퍼 파라미터를 선택하고 4 개의 Epochs를 위해 교육을 받았습니다.
이 모델을 사용하는 경우 다음 논문을 인용하십시오.
@article{turc2019,
title={Well-Read Students Learn Better: On the Importance of Pre-training Compact Models},
author={Turc, Iulia and Chang, Ming-Wei and Lee, Kenton and Toutanova, Kristina},
journal={arXiv preprint arXiv:1908.08962v2 },
year={2019}
}
***** 새로운 2019 년 5 월 31 일 : 전체 단어 마스킹 모델 *****
이것은 사전 처리 코드를 개선 한 결과 인 몇 가지 새로운 모델의 릴리스입니다.
원래 사전 처리 코드에서 마스크 할 WordPiece 토큰을 무작위로 선택합니다. 예를 들어:
Input Text: the man jumped up , put his basket on phil ##am ##mon ' s head Original Masked Input: [MASK] man [MASK] up , put his [MASK] on phil [MASK] ##mon ' s head
새로운 기술을 전체 단어 마스킹이라고합니다. 이 경우, 우리는 항상 단어에 해당하는 모든 토큰을 한 번에 마스킹합니다. 전체 마스킹 속도는 동일하게 유지됩니다.
Whole Word Masked Input: the man [MASK] up , put his basket on [MASK] [MASK] [MASK] ' s head
훈련은 동일합니다. 우리는 여전히 각 마스크 된 단어 토큰을 독립적으로 예측합니다. 개선은 원래 예측 과제가 여러 워드 피스로 나뉘어 진 단어에 대해 너무 '쉽다'는 사실에서 비롯됩니다.
이것은 깃발을 전달하여 데이터 생성 중에 활성화 될 수 있습니다 --do_whole_word_mask=True create_pretraining_data.py 에 true.
전체 단어 마스킹이있는 미리 훈련 된 모델은 다음과 같습니다. 데이터와 교육은 그렇지 않으면 동일했으며 모델은 원래 모델과 동일한 구조와 어휘를 가지고 있습니다. 우리는 Bert-Large 모델 만 포함합니다. 이 모델을 사용할 때는 논문에서 Bert-Large의 전체 단어 마스킹 변형을 사용하고 있음을 분명히하십시오.
BERT-Large, Uncased (Whole Word Masking) : 24 계층, 1024- 히든, 16 개의 헤드, 340m 매개 변수
BERT-Large, Cased (Whole Word Masking) : 24 계층, 1024- 히든, 16 헤드, 340m 매개 변수
| 모델 | 분대 1.1 F1/EM | 다중 NLI 정확도 |
|---|---|---|
| Bert-Large, Uncased (원본) | 91.0/84.3 | 86.05 |
| Bert-large, uncased (전체 단어 마스킹) | 92.8/86.7 | 87.07 |
| Bert-Large, Cased (원본) | 91.5/84.8 | 86.09 |
| Bert-Large, Cased (전체 단어 마스킹) | 92.9/86.7 | 86.46 |
***** 2019 년 2 월 7 일 : TFHUB 모듈 *****
Bert는 Tensorflow Hub에 업로드되었습니다. TF 허브 모듈을 사용하는 방법의 예는 run_classifier_with_tfhub.py 참조하거나 Colab의 브라우저에서 예제를 실행하십시오.
***** 새로운 2018 년 11 월 23 일 : 정규화되지 않은 다국어 모델 + 태국어 몽골 *****
입력에 대한 정규화를 수행 하지 않는 새로운 다국어 모델 (하위 케이싱, 악센트 스트리핑 또는 유니 코드 정규화 없음)을 업로드했으며 또한 태국어와 몽골어를 포함합니다.
다국어 모델, 특히 라틴이 아닌 알파벳 언어 에서이 버전을 사용하는 것이 좋습니다.
코드 변경이 필요하지 않으며 여기에서 다운로드 할 수 있습니다.
BERT-Base, Multilingual Cased : 104 개의 언어, 12 층, 768- 히든, 12- 헤드, 110m 매개 변수***** 새로운 2018 년 11 월 15 일 : Sota Squad 2.0 시스템 *****
우리는 코드 변경을 발표하여 83% F1 Squad 2.0 시스템을 재현하여 현재 리더 보드에서 1 위입니다. 자세한 내용은 ReadMe의 Squad 2.0 섹션을 참조하십시오.
***** 새로운 2018 년 11 월 5 일 : Bert의 타사 파이 토치 및 체인 버전 사용 가능 *****
Huggingf Sosuke Kobayashi는 또한 Pytorch 구현의 생성 또는 유지 보수에 관여하지 않았으므로 그 저장소의 저자에게 질문을 지시하십시오.
***** 2018 년 11 월 3 일 : 다국어 및 중국 모델 이용 가능 *****
우리는 두 가지 새로운 버트 모델을 사용할 수있었습니다.
BERT-Base, Multilingual (권장하지 않음, 대신 Multilingual Cased 사용) : 102 언어, 12 층, 768- 히든, 12- 헤드, 110m 매개 변수BERT-Base, Chinese : 중국 단순화 및 전통, 12 계층, 768-Hidden, 12-Heads, 110m 매개 변수 우리는 중국어에 대한 캐릭터 기반 토큰 화와 다른 모든 언어에 대한 워드 피스 토큰 화를 사용합니다. 두 모델 모두 코드 변경 없이는 상자 밖으로 작동해야합니다. 중국어 토큰 화를 지원하기 위해 tokenization.py 에서 BasicTokenizer 의 구현을 업데이트 했으므로 포기한 경우 업데이트하십시오. 그러나 우리는 토큰 화 API를 변경하지 않았습니다.
자세한 내용은 다국어 readme를 참조하십시오.
***** 새로운 정보 종료 *****
BERT 또는 B ransformers 의 BERTERECTERE NCODER REPRESENTATIONS 는 NLP (Natural Language Processing) 작업에 대한 최첨단 결과를 얻는 언어 표현을 사전 훈련하는 새로운 방법입니다.
BERT를 자세히 설명하고 여러 작업에 대한 전체 결과를 제공하는 학업 논문은 여기에서 찾을 수 있습니다 : https://arxiv.org/abs/1810.04805.
몇 가지 숫자를 주려면 분대 v1.1 질문 답변 과제에 대한 결과는 다음과 같습니다.
| 분대 v1.1 리더 보드 (2018 년 10 월 8 일) | 테스트 em | 테스트 f1 |
|---|---|---|
| 1 위 앙상블 - 버트 | 87.4 | 93.2 |
| 2 위 앙상블 -NLNET | 86.0 | 91.7 |
| 1 위 단일 모델 - 버트 | 85.1 | 91.8 |
| 2 위 단일 모델 -NLNET | 83.5 | 90.1 |
그리고 여러 자연어 추론 작업 :
| 체계 | 멀티 | 질문 nli | 꽃잎 장식 |
|---|---|---|---|
| 버트 | 86.7 | 91.1 | 86.3 |
| Openai Gpt (Prev. Sota) | 82.2 | 88.1 | 75.0 |
또한 다른 많은 작업.
또한, 이러한 결과는 모두 작업 별 신경망 아키텍처 설계없이 거의 얻지 못했습니다.
Bert가 무엇인지 이미 알고 있고 시작하고 싶다면 미리 훈련 된 모델을 다운로드하고 몇 분 안에 최첨단 미세 조정을 실행할 수 있습니다.
Bert는 언어 표현을 사전 훈련하는 방법으로, 우리는 큰 텍스트 코퍼스 (Wikipedia와 같은)에서 일반적인 목적 "언어 이해"모델을 훈련시킨 다음 해당 모델을 사용하여 우리가 관심있는 다운 스트림 NLP 작업에 해당 모델을 사용한다는 것을 의미합니다. 응답). Bert는 이전의 방법이 NLP를 사전 훈련하기위한 최초의 감독되지 않은 깊은 양방향 시스템이기 때문에 성능이 우수합니다.
감독되지 않은 것은 Bert가 일반 텍스트 코퍼스 만 사용하여 교육을 받았음을 의미합니다. 이는 많은 양의 일반 텍스트 데이터가 여러 언어로 공개적으로 공개되기 때문에 중요합니다.
사전 훈련 된 표현은 또한 상황에 맞지 않거나 상황에 맞을 수 있으며, 맥락 표현은 더 단방향 또는 양방향 일 수 있습니다. Word2Vec 또는 Glove와 같은 컨텍스트가없는 모델은 어휘의 각 단어에 대한 단일 "Word Embedding"표현을 생성하므로 bank bank deposit 및 river bank 에서 동일한 표현을 가질 것입니다. 대신 문맥 모델은 문장의 다른 단어를 기반으로하는 각 단어의 표현을 생성합니다.
Bert는 반 감독 시퀀스 학습, 생성 사전 훈련, 엘모 및 ULMFIT를 포함하여 사전 훈련 상황 표현의 최근 연구에서 구축되었지만 결정적으로 이러한 모델은 모두 단방향 또는 얕은 양방향 입니다. 이것은 각 단어가 왼쪽 (또는 오른쪽)에있는 단어를 사용하여 문맥 화된다는 것을 의미합니다. 예를 들어, 문장에서 은행 deposit bank I made a bank deposit I made a 일부 이전 작업은 별도의 왼쪽 컨텍스트 및 오른쪽 컨텍스트 모델의 표현을 결합하지만 "얕은"방식으로 만 결합합니다. Bert는 왼쪽 및 오른쪽 컨텍스트를 모두 사용하여 "은행"을 나타냅니다. 깊은 신경 네트워크의 바닥에서 시작하여 I made a ... deposit 으므로 깊은 양방향 입니다.
Bert는 간단한 접근 방식을 사용합니다. 입력에서 단어의 15%를 마스킹하고 깊은 양방향 변압기 인코더를 통해 전체 시퀀스를 실행 한 다음 마스크 된 단어 만 예측합니다. 예를 들어:
Input: the man went to the [MASK1] . he bought a [MASK2] of milk.
Labels: [MASK1] = store; [MASK2] = gallon
문장 사이 B 관계를 B 위해, 우리는 또한 단일 단단한 코퍼스에서 생성 될 A 있는 A 과제를 훈련시킵니다. ?
Sentence A: the man went to the store .
Sentence B: he bought a gallon of milk .
Label: IsNextSentence
Sentence A: the man went to the store .
Sentence B: penguins are flightless .
Label: NotNextSentence
그런 다음 오랫동안 큰 코퍼스 (Wikipedia + Bookcorpus)에서 큰 모델 (12 층에서 24 계층 변압기)을 오랫동안 훈련시킵니다 (1m 업데이트 단계).
Bert 사용에는 사전 훈련 과 미세 조정의 두 단계가 있습니다.
사전 훈련 은 상당히 비싸지 만 (4 ~ 16 개의 클라우드 TPU는 4 일) 각 언어에 대한 일회성 절차입니다 (현재 모델은 영어 전용이지만 다국어 모델은 가까운 시일 내에 출시 될 것입니다). 우리는 Google에서 미리 훈련 된 논문에서 미리 훈련 된 여러 모델을 출시하고 있습니다. 대부분의 NLP 연구자들은 자신의 모델을 처음부터 사전 훈련 할 필요가 없습니다.
미세 조정은 저렴합니다. 용지의 모든 결과는 단일 클라우드 TPU에서 최대 1 시간 안에 또는 동일한 예비 훈련 된 모델에서 시작하여 GPU에서 몇 시간 동안 복제 할 수 있습니다. 예를 들어, 분대는 단일 클라우드 TPU에서 약 30 분 안에 훈련을받을 수 있으며, 이는 단일 시스템 최신 시스템 인 Dev F1 점수 91.0%를 달성 할 수 있습니다.
Bert의 또 다른 중요한 측면은 많은 유형의 NLP 작업에 매우 쉽게 조정될 수 있다는 것입니다. 논문에서, 우리는 문장 수준 (예 : SST-2), 문장-쌍 수준 (예 : multinli), Word 레벨 (예 : NER) 및 스팬 레벨에 대한 최첨단 결과를 보여줍니다. (예 : 분대) 작업 별 수정이 거의없는 작업.
우리는 다음을 출시하고 있습니다.
BERT-Base 및 BERT-Large 의 소문자 및 케이스 버전 모두에 대한 미리 훈련 된 체크 포인트.이 저장소의 모든 코드는 CPU, GPU 및 Cloud TPU와 함께 제공됩니다.
우리는 논문에서 BERT-Base 및 BERT-Large 모델을 공개하고 있습니다. Uncased Wordpiece Tokenization 이전에 텍스트가 낮게 사용되었음을 의미합니다. 예를 들어 John Smith john smith 됩니다. Uncased 모델은 또한 악센트 마커를 제거합니다. Cased 실제 케이스 및 악센트 마커가 보존되었음을 의미합니다. 일반적으로 Uncased 정보가 귀하의 작업에 중요하다는 것을 알지 못하면 (예 : 엔티티 인식 또는 부품 태그)가 아니라면 더 좋습니다.
이 모델은 모두 소스 코드 (APACHE 2.0)와 동일한 라이센스로 출시됩니다.
다국어 및 중국 모델에 대한 자세한 내용은 다국어 readme를 참조하십시오.
케이스 모델을 사용하는 경우 --do_lower=False 훈련 스크립트에 전달하십시오. (또는 자신의 스크립트를 사용하는 경우 do_lower_case=False FullTokenizer 에 직접 거짓을 전달합니다.)
모델에 대한 링크는 여기에 있습니다 (이름의 '링크를 저장 링크 ...') :
BERT-Large, Uncased (Whole Word Masking) : 24 계층, 1024- 히든, 16 개의 헤드, 340m 매개 변수BERT-Large, Cased (Whole Word Masking) : 24 계층, 1024- 히든, 16 헤드, 340m 매개 변수BERT-Base, Uncased : 12 층, 768- 히든, 12- 헤드, 110m 매개 변수BERT-Large, Uncased : 24 층, 1024- 히든, 16 개의 헤드, 340m 매개 변수BERT-Base, Cased : 12 층, 768-hidden, 12-heads, 110m 매개 변수BERT-Large, Cased : 24 계층, 1024- 히든, 16 개의 헤드, 340m 매개 변수BERT-Base, Multilingual Cased (New, recommended) : 104 개의 언어, 12 층, 768- 히드 덴, 12- 헤드, 110m 매개 변수BERT-Base, Multilingual Uncased (Orig, not recommended) (권장하지 않음, 대신 Multilingual Cased 사용) : 102 언어, 12 층, 768-Hidden, 12-Heads, 110m 매개 변수BERT-Base, Chinese : 중국 단순화 및 전통, 12 계층, 768-Hidden, 12-Heads, 110m 매개 변수각 .zip 파일에는 세 가지 항목이 있습니다.
bert_model.ckpt ).vocab.txt ).bert_config.json ). 중요 : 종이의 모든 결과는 64GB의 RAM이있는 단일 클라우드 TPU에서 미세 조정되었습니다. 메모리에 들어갈 수있는 최대 배치 크기가 너무 작기 때문에 12GB-16GB RAM이있는 GPU를 사용하여 종이의 대부분의 BERT-Large 결과를 다시 생산할 수 없습니다. 우리는이 저장소에 코드를 추가하여 GPU에서 훨씬 더 큰 효과적인 배치 크기를 허용합니다. 자세한 내용은 메모리 외 문제에 대한 섹션을 참조하십시오.
이 코드는 Tensorflow 1.11.0으로 테스트되었습니다. Python2 및 Python3로 테스트되었습니다 (그러나 Python2에서는 더 철저히 Google에서 사용되기 때문에).
BERT-Base 사용하는 미세 조정 예는 주어진 과파 리터를 사용하여 12GB 이상의 RAM을 갖는 GPU에서 실행할 수 있어야합니다.
아래의 대부분의 예는 Titan X 또는 GTX 1080과 같은 GPU를 사용하여 로컬 컴퓨터에서 교육/평가를 실행할 것이라고 가정합니다.
그러나 훈련하려는 클라우드 TPU에 액세스 할 수있는 경우 run_classifier.py 또는 run_squad.py 에 다음 플래그를 추가하십시오.
--use_tpu=True
--tpu_name=$TPU_NAME
클라우드 TPU 사용 방법은 Google Cloud TPU 자습서를 참조하십시오. 또는 Google Colab 노트북 "Cloud TPU를 사용하여 Bert Finetuning"을 사용할 수 있습니다.
클라우드 TPU에서는 사전에 사전 된 모델과 출력 디렉토리가 Google 클라우드 스토리지에 있어야합니다. 예를 들어, some_bucket 이라는 버킷이있는 경우 다음 플래그를 대신 사용할 수 있습니다.
--output_dir=gs://some_bucket/my_output_dir/
압축되지 않은 미리 훈련 된 모델 파일은 Google Cloud Storage 폴더 gs://bert_models/2018_10_18 에서도 찾을 수 있습니다. 예를 들어:
export BERT_BASE_DIR=gs://bert_models/2018_10_18/uncased_L-12_H-768_A-12
이 예제를 실행하기 전에이 스크립트를 실행하여 접착제 데이터를 다운로드하고 일부 디렉토리 $GLUE_DIR 로 포장을 풀어야합니다. 다음으로 BERT-Base Checkpoint를 다운로드하여 일부 디렉토리 $BERT_BASE_DIR 로 압축하십시오.
이 예제는 Microsoft Research Paraphrase Corpus (MRPC) 코퍼스에서 BERT-Base 미세 조정합니다. 여기에는 3,600 개의 예제 만 포함되어 있으며 대부분의 GPU에서 몇 분 안에 미세 조정할 수 있습니다.
export BERT_BASE_DIR=/path/to/bert/uncased_L-12_H-768_A-12
export GLUE_DIR=/path/to/glue
python run_classifier.py
--task_name=MRPC
--do_train=true
--do_eval=true
--data_dir= $GLUE_DIR /MRPC
--vocab_file= $BERT_BASE_DIR /vocab.txt
--bert_config_file= $BERT_BASE_DIR /bert_config.json
--init_checkpoint= $BERT_BASE_DIR /bert_model.ckpt
--max_seq_length=128
--train_batch_size=32
--learning_rate=2e-5
--num_train_epochs=3.0
--output_dir=/tmp/mrpc_output/다음과 같은 출력이 표시됩니다.
***** Eval results *****
eval_accuracy = 0.845588
eval_loss = 0.505248
global_step = 343
loss = 0.505248
이는 개발자 세트 정확도가 84.55%임을 의미합니다. MRPC와 같은 작은 세트는 동일한 사전 훈련 체크 포인트에서 시작하더라도 DEV 세트 정확도의 차이가 높습니다. 여러 번 다시 실행되면 (다른 output_dir 가리키도록) 84%에서 88% 사이의 결과가 표시됩니다.
다른 미리 훈련 된 모델은 run_classifier.py 에서 상용 외부로 구현되므로 단일 문장 또는 문장 쌍 분류 작업에 BERT를 사용하기 위해 해당 예제를 따라 간단해야합니다.
참고 : Running train on CPU 메시지가 표시 될 수 있습니다. 이것은 실제로 GPU를 포함하는 클라우드 TPU 이외의 제품에서 실행되고 있음을 의미합니다.
분류기를 훈련 한 후에는 -do_predict = true 명령을 사용하여 추론 모드에서 사용할 수 있습니다. 입력 폴더에 test.tsv라는 파일이 있어야합니다. 출력은 출력 폴더의 test_results.tsv라는 파일로 작성됩니다. 각 라인에는 각 샘플에 대한 출력이 포함되어 있으며 열은 클래스 확률입니다.
export BERT_BASE_DIR=/path/to/bert/uncased_L-12_H-768_A-12
export GLUE_DIR=/path/to/glue
export TRAINED_CLASSIFIER=/path/to/fine/tuned/classifier
python run_classifier.py
--task_name=MRPC
--do_predict=true
--data_dir= $GLUE_DIR /MRPC
--vocab_file= $BERT_BASE_DIR /vocab.txt
--bert_config_file= $BERT_BASE_DIR /bert_config.json
--init_checkpoint= $TRAINED_CLASSIFIER
--max_seq_length=128
--output_dir=/tmp/mrpc_output/ 스탠포드 질문 답변 데이터 세트 (Squad)는 벤치 마크 데이터 세트에 대한 인기있는 질문입니다. Bert (릴리스 당시)는 작업 별 네트워크 아키텍처 수정 또는 데이터 증강이 거의없는 분대에서 최첨단 결과를 얻습니다. 그러나 (a) 분대 컨텍스트 단락의 가변 길이 특성 및 (b) 분대 훈련에 사용되는 문자 수준의 답변 주석을 다루기 위해 반 복잡한 데이터 사전 처리 및 후 처리가 필요합니다. 이 처리는 run_squad.py 에서 구현 및 문서화됩니다.
분대에서 실행하려면 먼저 데이터 세트를 다운로드해야합니다. 분대 웹 사이트는 더 이상 v1.1 데이터 세트에 링크되지 않은 것처럼 보이지만 필요한 파일은 여기에서 찾을 수 있습니다.
이것들을 일부 디렉토리로 다운로드하십시오. $SQUAD_DIR .
메모리 제약으로 인해 현재이 논문의 최신 분대 결과는 12GB-16GB GPU에서 재현 할 수 없습니다 (실제로 배치 크기 1조차 BERT-Large 사용하여 12GB GPU에 맞지 않는 것 같습니다). 그러나, 합리적으로 강한 BERT-Base 모델은 이들과 파라미터로 GPU에서 훈련 될 수 있습니다.
python run_squad.py
--vocab_file= $BERT_BASE_DIR /vocab.txt
--bert_config_file= $BERT_BASE_DIR /bert_config.json
--init_checkpoint= $BERT_BASE_DIR /bert_model.ckpt
--do_train=True
--train_file= $SQUAD_DIR /train-v1.1.json
--do_predict=True
--predict_file= $SQUAD_DIR /dev-v1.1.json
--train_batch_size=12
--learning_rate=3e-5
--num_train_epochs=2.0
--max_seq_length=384
--doc_stride=128
--output_dir=/tmp/squad_base/ DEV 세트 예측은 output_dir 에서 predictions.json 이라는 파일로 저장됩니다.
python $SQUAD_DIR /evaluate-v1.1.py $SQUAD_DIR /dev-v1.1.json ./squad/predictions.json다음과 같은 출력을 생성해야합니다.
{ " f1 " : 88.41249612335034, " exact_match " : 81.2488174077578} BERT-Base 에 대한 논문에보고 된 88.5%와 유사한 결과가 보일 것입니다.
클라우드 TPU에 액세스 할 수있는 경우 BERT-Large 로 훈련 할 수 있습니다. 다음은 분대에서만 훈련 된 약 90.5% -91.0% F1 단일 시스템을 일관되게 얻는 초반 (종이와 약간 다름) 세트입니다.
python run_squad.py
--vocab_file= $BERT_LARGE_DIR /vocab.txt
--bert_config_file= $BERT_LARGE_DIR /bert_config.json
--init_checkpoint= $BERT_LARGE_DIR /bert_model.ckpt
--do_train=True
--train_file= $SQUAD_DIR /train-v1.1.json
--do_predict=True
--predict_file= $SQUAD_DIR /dev-v1.1.json
--train_batch_size=24
--learning_rate=3e-5
--num_train_epochs=2.0
--max_seq_length=384
--doc_stride=128
--output_dir=gs://some_bucket/squad_large/
--use_tpu=True
--tpu_name= $TPU_NAME예를 들어, 이러한 매개 변수로 하나의 랜덤 실행은 다음과 같은 dev 점수를 생성합니다.
{ " f1 " : 90.87081895814865, " exact_match " : 84.38978240302744}이 전에 Triviaqa에서 하나의 에포크를 미세 조정하면 결과가 더 나을 것이지만 Triviaqa를 Squad JSON 형식으로 변환해야합니다.
이 모델은 또한 run_squad.py 에서 구현 및 문서화됩니다.
Squad 2.0에서 실행하려면 먼저 데이터 세트를 다운로드해야합니다. 필요한 파일은 여기에서 찾을 수 있습니다.
이것들을 일부 디렉토리로 다운로드하십시오. $SQUAD_DIR .
Cloud TPU에서는 다음과 같이 Bert-Large로 실행할 수 있습니다.
python run_squad.py
--vocab_file= $BERT_LARGE_DIR /vocab.txt
--bert_config_file= $BERT_LARGE_DIR /bert_config.json
--init_checkpoint= $BERT_LARGE_DIR /bert_model.ckpt
--do_train=True
--train_file= $SQUAD_DIR /train-v2.0.json
--do_predict=True
--predict_file= $SQUAD_DIR /dev-v2.0.json
--train_batch_size=24
--learning_rate=3e-5
--num_train_epochs=2.0
--max_seq_length=384
--doc_stride=128
--output_dir=gs://some_bucket/squad_large/
--use_tpu=True
--tpu_name= $TPU_NAME
--version_2_with_negative=True출력 디렉토리에서 ./squad/라는 로컬 디렉토리에 이르기까지 모든 것을 복사했다고 가정합니다. 초기 개발 세트 예측은 ./squad/predictions.json에있을 것입니다. 답변이없는 점수 ( "")와 각 질문에 대한 가장 좋은 답변의 차이는 파일에 있습니다 ./squad/null_odds.json.
이 스크립트를 실행하여 NULL 대 NULL 답변을 예측하기위한 임계 값을 조정하십시오.
python $ squad_dir/evaluate-v2.0.py $ squad_dir/dev-v2.0.json ./squad/predictions.json -na-prob-file ./squad/null_odds.json
스크립트가 "best_f1_thresh"를 출력한다고 가정합니다. (일반적인 값은 -1.0에서 -5.0 사이입니다). 이제 모델을 다시 실행하여 파생 임계 값으로 예측을 생성하거나 대안으로 ./squad/nbest_predictions.json에서 적절한 답변을 추출 할 수 있습니다.
python run_squad.py
--vocab_file= $BERT_LARGE_DIR /vocab.txt
--bert_config_file= $BERT_LARGE_DIR /bert_config.json
--init_checkpoint= $BERT_LARGE_DIR /bert_model.ckpt
--do_train=False
--train_file= $SQUAD_DIR /train-v2.0.json
--do_predict=True
--predict_file= $SQUAD_DIR /dev-v2.0.json
--train_batch_size=24
--learning_rate=3e-5
--num_train_epochs=2.0
--max_seq_length=384
--doc_stride=128
--output_dir=gs://some_bucket/squad_large/
--use_tpu=True
--tpu_name= $TPU_NAME
--version_2_with_negative=True
--null_score_diff_threshold= $THRESH논문의 모든 실험은 64GB의 장치 RAM을 가진 클라우드 TPU에서 미세 조정되었습니다. 따라서 12GB-16GB의 RAM이있는 GPU를 사용할 때 논문에 설명 된 동일한 초 파라미터를 사용하는 경우 메모리 외 문제가 발생할 수 있습니다.
메모리 사용에 영향을 미치는 요인은 다음과 같습니다.
max_seq_length : 릴리스 된 모델은 최대 512의 시퀀스 길이로 훈련되었지만 최대 시퀀스 길이가 짧아서 상당한 메모리를 절약 할 수 있습니다. 이 예제 코드의 max_seq_length 플래그에 의해 제어됩니다.
train_batch_size : 메모리 사용량은 배치 크기에도 직접 비례합니다.
모델 유형, BERT-Base vs. BERT-Large : BERT-Large 모델은 BERT-Base 보다 훨씬 더 많은 메모리가 필요합니다.
OPTIMIZER : BERT의 기본 최적화기는 Adam이며 m 및 v 벡터를 저장하려면 많은 추가 메모리가 필요합니다. 더 메모리 효율적인 옵티마이저로 전환하면 메모리 사용량을 줄일 수 있지만 결과에도 영향을 줄 수 있습니다. 우리는 미세 조정을 위해 다른 최적화기를 실험하지 않았습니다.
기본 교육 스크립트 ( run_classifier.py 및 run_squad.py )를 사용하여 Tensorflow 1.11.0을 사용하여 단일 Titan X GPU (12GB RAM)의 최대 배치 크기를 벤치마킹했습니다.
| 체계 | 서열 길이 | 최대 배치 크기 |
|---|---|---|
BERT-Base | 64 | 64 |
| ... | 128 | 32 |
| ... | 256 | 16 |
| ... | 320 | 14 |
| ... | 384 | 12 |
| ... | 512 | 6 |
BERT-Large | 64 | 12 |
| ... | 128 | 6 |
| ... | 256 | 2 |
| ... | 320 | 1 |
| ... | 384 | 0 |
| ... | 512 | 0 |
불행히도, BERT-Large 의 이러한 최대 배치 크기는 너무 작아서 사용 된 학습 속도에 관계없이 실제로 모델 정확도에 해를 끼칠 것입니다. 우리는이 저장소에 코드를 추가하기 위해 노력하고있어 GPU에서 훨씬 더 큰 효과적인 배치 크기를 사용할 수 있습니다. 코드는 다음 기술 중 하나 (또는 둘 다)를 기반으로합니다.
그라디언트 축적 : 미니 배트의 샘플은 전형적으로 구배 계산과 관련하여 독립적입니다 (여기서 사용되지 않는 배치 정규화 제외). 이는 무게 업데이트를 수행하기 전에 여러 개의 작은 미니 봇트의 구배가 축적 될 수 있음을 의미하며, 이는 단일 더 큰 업데이트와 정확히 동일합니다.
그라디언트 체크 포인팅 : DNN 훈련 중 GPU/TPU 메모리의 주요 사용은 뒤로 패스에서 효율적인 계산에 필요한 순방향 패스에서 중간 활성화를 캐싱하는 것입니다. "Gradient CheckPointing"은 활성화를 지능적으로 다시 컴퓨팅하여 계산 시간을 위해 메모리를 거래합니다.
그러나 이것은 현재 릴리스에서 구현되지 않습니다.
경우에 따라, 전체 미리 훈련 된 모델 엔드 투 엔드를 미세 조정하는 대신, 사전 훈련 된 상황에 맞는 임베딩을 얻는 것이 유리할 수 있으며, 이는 사전의 숨겨진 층으로부터 생성 된 각 입력 토큰의 고정 된 맥락 표현입니다. -훈련 된 모델. 이것은 또한 대부분의 메모리 외 문제를 완화해야합니다.
예를 들어, 우리는 다음과 같이 사용할 수있는 스크립트 extract_features.py 포함합니다.
# Sentence A and Sentence B are separated by the ||| delimiter for sentence
# pair tasks like question answering and entailment.
# For single sentence inputs, put one sentence per line and DON'T use the
# delimiter.
echo ' Who was Jim Henson ? ||| Jim Henson was a puppeteer ' > /tmp/input.txt
python extract_features.py
--input_file=/tmp/input.txt
--output_file=/tmp/output.jsonl
--vocab_file= $BERT_BASE_DIR /vocab.txt
--bert_config_file= $BERT_BASE_DIR /bert_config.json
--init_checkpoint= $BERT_BASE_DIR /bert_model.ckpt
--layers=-1,-2,-3,-4
--max_seq_length=128
--batch_size=8 이렇게하면 layers 으로 지정된 각 변압기 층으로부터 BERT 활성화를 포함하는 JSON 파일 (입력 한 줄 당 1 행)이 생성됩니다 (-1은 변압기의 최종 숨겨진 계층 등).
이 스크립트는 매우 큰 출력 파일을 생성합니다 (기본적으로 모든 입력 토큰에 대해 약 15KB).
원본과 토큰 화 된 단어 (훈련 라벨을 투영) 사이의 정렬을 유지 해야하는 경우 아래 토큰 화 섹션을 참조하십시오.
참고 : Could not find trained model in model_dir: /tmp/tmpuB5g5c, running initialization to predict. 이 메시지는 저장된 모델 API 대신 init_from_checkpoint() API를 사용하고 있음을 의미합니다. 체크 포인트를 지정하지 않거나 잘못된 체크 포인트를 지정하지 않으면이 스크립트가 불평합니다.
문장 수준 작업 (또는 문장 쌍) 작업의 경우 토큰 화가 매우 간단합니다. run_classifier.py 및 extract_features.py 의 예제 코드를 따르십시오. 문장 수준 작업의 기본 절차는 다음과 같습니다.
tokenizer = tokenization.FullTokenizer 인스턴스를 인스턴스화하십시오
tokens = tokenizer.tokenize(raw_text) 로 원시 텍스트를 토큰 화하십시오.
최대 시퀀스 길이로 잘라냅니다. (최대 512 년까지 사용할 수는 있지만 메모리와 속도의 이유로 가능한 경우 더 짧게 사용하고 싶을 것입니다.)
올바른 장소에 [CLS] 및 [SEP] 토큰을 추가하십시오.
단어 수준 및 스팬 레벨 작업 (예 : Squad 및 NER)은 입력 텍스트와 출력 텍스트 간의 정렬을 유지하여 교육 레이블을 투사 할 수 있도록해야하므로 더 복잡합니다. 입력 라벨은 문자 기반이며 분대 단락은 종종 최대 시퀀스 길이보다 길기 때문에 분대는 특히 복잡한 예입니다. 이를 처리하는 방법을 보여 주려면 run_squad.py 의 코드를 참조하십시오.
단어 수준의 작업을 처리하기위한 일반적인 레시피를 설명하기 전에 토큰 화기가 정확히 무엇을하는지 이해하는 것이 중요합니다. 세 가지 주요 단계가 있습니다.
텍스트 정규화 : 모든 공백 문자를 공백으로 변환하고 ( Uncased 모델의 경우) 입력 및 악센트 마커를 제거하십시오. 예 : John Johanson's, → john johanson's,
구두점 분할 : 모든 구두점 문자를 양쪽에 나눕니다 (즉, 모든 구두점 문자 주위에 공백을 추가). 구두점 문자는 (a) P* unicode 클래스가있는 $ 정의됩니다. 예 : john johanson's, → john johanson ' s ,
워드 피스 토큰 화 : 위의 절차의 출력에 공백 토큰 화를 적용하고 각 토큰에 별도로 워드 피스 토큰 화를 적용하십시오. (우리의 구현은 링크 된 tensor2tensor 의 구현을 직접 기반으로합니다). 예 : john johanson ' s , → john johan ##son ' s ,
이 체계의 장점은 대부분의 기존 영어 토큰 화제와 "호환"한다는 것입니다. 예를 들어, 다음과 같이 보이는 부분적으로 태그 태깅 작업이 있다고 상상해보십시오.
Input: John Johanson 's house
Labels: NNP NNP POS NN
토큰 화 된 출력은 다음과 같습니다.
Tokens: john johan ##son ' s house
결정적으로, 이것은 원시 텍스트가 John Johanson's house 것처럼 같은 출력 일 것입니다 ( 's 공간이 없음).
단어 수준의 주석으로 사전 고정 된 표현이있는 경우 각 입력 단어를 독립적으로 토큰 화하고 원래 대신 정렬을 결정적으로 유지할 수 있습니다.
### Input
orig_tokens = [ "John" , "Johanson" , "'s" , "house" ]
labels = [ "NNP" , "NNP" , "POS" , "NN" ]
### Output
bert_tokens = []
# Token map will be an int -> int mapping between the `orig_tokens` index and
# the `bert_tokens` index.
orig_to_tok_map = []
tokenizer = tokenization . FullTokenizer (
vocab_file = vocab_file , do_lower_case = True )
bert_tokens . append ( "[CLS]" )
for orig_token in orig_tokens :
orig_to_tok_map . append ( len ( bert_tokens ))
bert_tokens . extend ( tokenizer . tokenize ( orig_token ))
bert_tokens . append ( "[SEP]" )
# bert_tokens == ["[CLS]", "john", "johan", "##son", "'", "s", "house", "[SEP]"]
# orig_to_tok_map == [1, 2, 4, 6] 이제 orig_to_tok_map 사용하여 labels 토큰 화 된 표현에 투사 할 수 있습니다.
버트가 미리 훈련 된 방법 사이에 약간의 불일치가 발생하는 일반적인 영어 토큰 화 체계가 있습니다. 예를 들어, 입력 토큰 화이 do n't 와 같은 수축을 분리하면 불일치가 발생합니다. 그렇게 할 수 있다면, 데이터를 사전 처리하여 이러한 데이터를 원시 텍스트로 변환해야하지만 불가능한 경우이 불일치는 큰 문제가되지 않을 수 있습니다.
우리는 임의의 텍스트 코퍼스에서 "마스킹 LM"및 "다음 문장 예측"을 수행하도록 코드를 발표하고 있습니다. 이는 논문에 사용 된 정확한 코드가 아니지만 (원래 코드는 C ++로 작성되었으며 추가 복잡성이 있었음),이 코드는 논문에 설명 된대로 사전 훈련 데이터를 생성합니다.
데이터 생성을 실행하는 방법은 다음과 같습니다. 입력은 한 줄 당 한 문장이있는 일반 텍스트 파일입니다. (이것들은 "다음 문장 예측"과제에 대한 실제 문장이라는 것이 중요합니다). 문서는 빈 줄로 구분됩니다. 출력은 TFRecord 파일 형식으로 직렬화 된 tf.train.Example s 세트입니다.
Spacy와 같은 상용 NLP 툴킷으로 문장 세분화를 수행 할 수 있습니다. create_pretraining_data.py 스크립트는 패딩에서 계산 폐기물을 최소화하기 위해 최대 시퀀스 길이에 도달 할 때까지 세그먼트를 연결합니다 (자세한 내용은 스크립트 참조). 그러나 미세 조정 중에 입력 데이터에 약간의 소음을 추가하여 미세 조정 중에는 비 소용돌이 입력에보다 강력하게 만들기 위해 의도적으로 약간의 노이즈를 추가 할 수 있습니다.
이 스크립트는 전체 입력 파일에 대한 모든 예제를 메모리에 저장하므로 대형 데이터 파일의 경우 입력 파일을 제공하고 스크립트를 여러 번 호출해야합니다. (glob를 run_pretraining.py , 예를 들어, tf_examples.tf_record* 로 전달할 수 있습니다.)
max_predictions_per_seq 는 시퀀스 당 마스킹 된 LM 예측의 최대 수입니다. 이것을 max_seq_length * masked_lm_prob 주위에 설정해야합니다 (정확한 값을 두 스크립트로 전달해야하기 때문에 스크립트는 자동으로 수행되지 않습니다).
python create_pretraining_data.py
--input_file=./sample_text.txt
--output_file=/tmp/tf_examples.tfrecord
--vocab_file= $BERT_BASE_DIR /vocab.txt
--do_lower_case=True
--max_seq_length=128
--max_predictions_per_seq=20
--masked_lm_prob=0.15
--random_seed=12345
--dupe_factor=5 사전 훈련을 실행하는 방법은 다음과 같습니다. 처음부터 사전 훈련을하는 경우 init_checkpoint 포함하지 마십시오. 모델 구성 (어휘 크기 포함)은 bert_config_file 에 지정됩니다. 이 데모 코드는 적은 수의 단계 (20)에 대한 사전 트레인 만 있지만 실제로는 num_train_steps 10000 단계 이상으로 설정하려고 할 것입니다. max_seq_length 및 max_predictions_per_seq 매개 변수는 run_pretraining.py 로 전달 된 매개 변수는 create_pretraining_data.py 와 동일해야합니다.
python run_pretraining.py
--input_file=/tmp/tf_examples.tfrecord
--output_dir=/tmp/pretraining_output
--do_train=True
--do_eval=True
--bert_config_file= $BERT_BASE_DIR /bert_config.json
--init_checkpoint= $BERT_BASE_DIR /bert_model.ckpt
--train_batch_size=32
--max_seq_length=128
--max_predictions_per_seq=20
--num_train_steps=20
--num_warmup_steps=10
--learning_rate=2e-5이것은 다음과 같은 출력을 생성합니다.
***** Eval results *****
global_step = 20
loss = 0.0979674
masked_lm_accuracy = 0.985479
masked_lm_loss = 0.0979328
next_sentence_accuracy = 1.0
next_sentence_loss = 3.45724e-05
sample_text.txt 파일이 매우 작기 때문에이 예제 교육은 해당 데이터를 몇 단계 만 과잉으로 적합하고 비현실적으로 높은 정확도 숫자를 생성합니다.
bert_config.json 에서 vocab_size 변경하십시오. 이것을 변경하지 않고 더 큰 어휘를 사용하는 경우, 확인되지 않은 외부 액세스로 인해 GPU 또는 TPU에 대한 교육을받을 때 NANS를 얻을 수 있습니다.max_seq_length 의 다른 값으로 데이터를 두 번 생성해야합니다.BERT-Base 를 사전 훈련하는 것입니다. . 용지에 사용 된 것과 비교하여 단일 클라우드 TPU에 대한 훈련 만 할 때 배치 크기를 확장해야합니다. TPU 메모리에 맞는 가장 큰 배치 크기를 사용하는 것이 좋습니다. 논문에 사용 된 사전 처리 된 데이터 세트를 출시 할 수 없습니다 . Wikipedia의 경우 권장되는 사전 프로세싱은 최신 덤프를 다운로드하고 WikiExtractor.py 로 텍스트를 추출한 다음 필요한 청소를 적용하여 일반 텍스트로 변환하는 것입니다.
불행히도 BookCorpus를 수집 한 연구원들은 더 이상 공개 다운로드 할 수 없습니다. 프로젝트 Guttenberg 데이터 세트는 공개 도메인 인 오래된 책의 다소 작은 (200m 단어) 컬렉션입니다.
Common Crawl은 또 다른 매우 큰 텍스트 모음이지만 사전 훈련 버트를위한 사용 가능한 코퍼스를 추출하기 위해 상당한 사전 프로세싱 및 정리를 수행해야 할 것입니다.
이 저장소에는 새로운 워드 피스 어휘 학습을 위한 코드가 포함되어 있지 않습니다. The reason is that the code used in the paper was implemented in C++ with dependencies on Google's internal libraries. For English, it is almost always better to just start with our vocabulary and pre-trained models. For learning vocabularies of other languages, there are a number of open source options available. However, keep in mind that these are not compatible with our tokenization.py library:
Google's SentencePiece library
tensor2tensor's WordPiece generation script
Rico Sennrich's Byte Pair Encoding library
If you want to use BERT with Colab, you can get started with the notebook "BERT FineTuning with Cloud TPUs". At the time of this writing (October 31st, 2018), Colab users can access a Cloud TPU completely for free. Note: One per user, availability limited, requires a Google Cloud Platform account with storage (although storage may be purchased with free credit for signing up with GCP), and this capability may not longer be available in the future. Click on the BERT Colab that was just linked for more information.
Yes, all of the code in this repository works out-of-the-box with CPU, GPU, and Cloud TPU. However, GPU training is single-GPU only.
See the section on out-of-memory issues for more information.
There is no official PyTorch implementation. However, NLP researchers from HuggingFace made a PyTorch version of BERT available which is compatible with our pre-trained checkpoints and is able to reproduce our results. We were not involved in the creation or maintenance of the PyTorch implementation so please direct any questions towards the authors of that repository.
There is no official Chainer implementation. However, Sosuke Kobayashi made a Chainer version of BERT available which is compatible with our pre-trained checkpoints and is able to reproduce our results. We were not involved in the creation or maintenance of the Chainer implementation so please direct any questions towards the authors of that repository.
Yes, we plan to release a multi-lingual BERT model in the near future. We cannot make promises about exactly which languages will be included, but it will likely be a single model which includes most of the languages which have a significantly-sized Wikipedia.
BERT-Large be released? So far we have not attempted to train anything larger than BERT-Large . It is possible that we will release larger models if we are able to obtain significant improvements.
All code and models are released under the Apache 2.0 license. 자세한 내용은 LICENSE 파일을 참조하십시오.
For now, cite the Arxiv paper:
@article{devlin2018bert,
title={BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding},
author={Devlin, Jacob and Chang, Ming-Wei and Lee, Kenton and Toutanova, Kristina},
journal={arXiv preprint arXiv:1810.04805},
year={2018}
}
If we submit the paper to a conference or journal, we will update the BibTeX.
This is not an official Google product.
For help or issues using BERT, please submit a GitHub issue.
For personal communication related to BERT, please contact Jacob Devlin ( [email protected] ), Ming-Wei Chang ( [email protected] ), or Kenton Lee ( [email protected] ).
