bert
1.0.0
***** Новый 11 марта 2020 года: меньшие модели Bert *****
Это выпуск 24 более мелких моделей BERT (только английский, неработаемый, обученный с маскировкой слов), упомянутые хорошо читаемыми студентами, учатся лучше: о важности компактных моделей перед тренировкой.
Мы показали, что стандартный рецепт BERT (включая модельную архитектуру и цель обучения) эффективен на широком диапазоне размеров модели, за пределами BERT-базой и BERT-Large. Меньшие модели BERT предназначены для среда с ограниченными вычислительными ресурсами. Они могут быть точно настроены так же, как и оригинальные модели BERT. Тем не менее, они наиболее эффективны в контексте дистилляции знаний, где тонкие метки производятся более крупным и более точным учителем.
Наша цель состоит в том, чтобы позволить исследованиям в учреждениях с меньшим количеством вычислительных ресурсов и побудить сообщество искать направления инновационных альтернативы повышению модели.
Вы можете скачать все 24 отсюда или индивидуально из таблицы ниже:
| H = 128 | H = 256 | H = 512 | H = 768 | |
|---|---|---|---|---|
| L = 2 | 2/128 (Берт-Тини) | 2/256 | 2/512 | 2/768 |
| L = 4 | 4/128 | 4/256 (Берт-Мини) | 4/512 (Берт-Смалл) | 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-базы в этом выпуске включена только для полноты; Он был повторно обучен под тем же режимом, что и оригинальная модель.
Вот соответствующие оценки клея на тестовом наборе:
| Модель | Счет | Кола | SST-2 | MRPC | STS-B | QQP | Mnli-m | Mnli-Mm | Qnli (v2) | Rte | Wnli | Топор |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Берт-Нижний | 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 |
| Берт-Смалл | 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 эпох:
Если вы используете эти модели, пожалуйста, укажите следующую статью:
@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}
}
***** Новый 31 мая 2019 года: модели маскировки целого слова *****
Это выпуск нескольких новых моделей, которые стали результатом улучшения кода предварительной обработки.
В исходном коде предварительной обработки мы случайным образом выбираем токены Wordsiece для маскировки. Например:
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 to create_pretraining_data.py .
Предварительно обученные модели с маскированием всего слов связаны ниже. Данные и обучение были в противном случае идентичны, и модели имеют идентичную структуру и словар для исходных моделей. Мы включаем только модели Bert-Large. При использовании этих моделей, пожалуйста, дайте понять в статье, что вы используете весь вариант маскировки слова Bert-Large.
BERT-Large, Uncased (Whole Word Masking) : 24-слойный, 1024 скрытый, 16 голов, параметры 340 м
BERT-Large, Cased (Whole Word Masking) : 24-слойный, 1024 скрытый, 16 голов, параметры 340 м
| Модель | Отряд 1.1 F1/EM | Multi NLI Точность |
|---|---|---|
| Bert-Large, Uncasted (Original) | 91.0/84,3 | 86.05 |
| Bert-Large, Uncasted (целое слово маскирование) | 92,8/86,7 | 87.07 |
| Bert-Large, Cassed (Original) | 91,5/84,8 | 86.09 |
| Bert-Large, обсадный (маскировка всего слова) | 92,9/86,7 | 86.46 |
***** Новый 7 февраля 2019 года: модуль tfhub *****
Берт был загружен в Tensorflow Hub. См. run_classifier_with_tfhub.py для примера того, как использовать модуль Hub TF, или запустите пример в браузере на Colab.
***** Новый 23 ноября 2018 года: не наносимая многоязычная модель + Thai + Mongolian *****
Мы загрузили новую многоязычную модель, которая не выполняет никакой нормализации на входе (без более низкого корпуса, укрепления акцента или нормализации юникода), а также включает в себя тайский и монгольский.
Рекомендуется использовать эту версию для разработки многоязычных моделей, особенно на языках с нелатиновыми алфавитами.
Это не требует никаких изменений кода и может быть загружено здесь:
BERT-Base, Multilingual Cased : 104 языка, 12-слойный, 768 скрытый, 12 голов, 110 м. Параметры***** Новый 15 ноября 2018 года: SOTA Squad 2.0 System *****
Мы выпустили изменения кода, чтобы воспроизвести нашу 83% систему F1 Squad 2.0, которая в настоящее время занимает первое место в таблице лидеров на 3%. См. Раздел Squad 2.0 Readme для деталей.
***** Новый 5 ноября 2018 года: сторонние версии BERT и цепочки BERT.
Исследователи НЛП из HuggingFace сделали Pytorch, которая доступна BERT, которая совместима с нашими предварительно обученными контрольно-пропускными пунктами и способна воспроизводить наши результаты. Sosuke Kobayashi также сделал доступную цепочку Bert (спасибо!) Мы не были вовлечены в создание или поддержание реализации Pytorch, поэтому, пожалуйста, направьте любые вопросы по отношению к авторам этого хранилища.
***** Новый 3 ноября 2018 года: многоязычные и китайские модели доступны *****
Мы сделали две новые модели BERT:
BERT-Base, Multilingual (не рекомендуется, вместо этого используйте Multilingual Cased ) : 102 языка, 12-слойные, 768 скрытых, 12 голов, параметры 110 м.BERT-Base, Chinese : китайский упрощенный и традиционный, 12-слойный, 768 скрытый, 12 голов, параметры 110 м. Мы используем токенизацию на основе символов для китайского и токенизацию слов для всех других языков. Обе модели должны работать без каких-либо изменений кода. Мы обновили реализацию BasicTokenizer в tokenization.py , чтобы поддержать токенизацию китайского персонажа, поэтому, пожалуйста, обновите, если вы его разделили. Тем не менее, мы не изменили API токенизации.
Для получения дополнительной информации см. Многоязычный Readme.
***** Конец новой информации *****
Bert , или Bertectional Encoder Resentations от T -Ransformers, представляет собой новый метод представления языка предварительного обучения, который получает самые современные результаты по широкому спектру задач обработки естественного языка (NLP).
Наш академический документ, который подробно описывает BERT и дает полные результаты по ряду задач, можно найти здесь: https://arxiv.org/abs/1810.04805.
Чтобы дать несколько чисел, вот результаты на задаче ответа на вопрос от команды v1.1:
| Squad v1.1 Sobder Leaders (8 октября 2018 г.) | Тест Эм | Тест F1 |
|---|---|---|
| 1 -е место ансамбль - Берт | 87.4 | 93.2 |
| 2 -е место ансамбль - nlnet | 86.0 | 91.7 |
| 1 -е место для одиночной модели - Bert | 85,1 | 91.8 |
| 2 -е место для одиночной модели - NLNET | 83,5 | 90.1 |
И несколько задач по выводу естественного языка:
| Система | Multinli | Вопрос NLI | РАСКАЧИВАТЬСЯ |
|---|---|---|---|
| БЕРТ | 86.7 | 91.1 | 86.3 |
| OpenAI GPT (Prev. SOTA) | 82.2 | 88.1 | 75.0 |
Плюс много других задач.
Более того, все эти результаты были получены практически без задачи, специфичной для конкретной задачи дизайна архитектуры нейронной сети.
Если вы уже знаете, что такое Bert, и вы просто хотите начать, вы можете скачать предварительно обученные модели и запустить современную точную настройку всего за несколько минут.
Берт-это метод предварительного обучения языковых представлений, означающий, что мы обучаем общего назначения «понимание языка» на большом текстовом корпусе (например, Википедия), а затем используем эту модель для нижестоящих задач NLP, которые нас волнуют (например, вопрос Ответ). BERT превосходит предыдущие методы, потому что это первая неконтролируемая , глубоко двунаправленная система для предварительного обучения NLP.
Неконтролируемый означает, что Берт был обучен с использованием только простого текстового корпуса, что важно, потому что огромное количество простых текстовых данных общедоступно в Интернете на многих языках.
Предварительно обученные представления также могут быть либо контекстными, либо контекстными , а контекстные представления могут быть более однонаправленными или двунаправленными . Контекстные модели, такие как Word2VEC или Glove, генерируют единственное представление «Enceding» для каждого слова в словарном запасе, поэтому bank будет иметь одинаковое представление в bank deposit и river bank . Вместо этого контекстные модели генерируют представление каждого слова, основанное на других словах в предложении.
BERT был построен на недавней работе по предварительному обучению контекстуальных представлений, включая полузащиленное обучение последовательности, генеративное предварительное обучение, ELMO и Ulmfit, но, что особенно важно, все эти модели являются однонаправленными или мелко двунаправленными . Это означает, что каждое слово только контекстуализируется с использованием слов слева (или справа). Например, в предложении I made a bank deposit однонаправленное представление bank основано только на том, I made a но не deposit . Некоторая предыдущая работа объединяет представления из отдельных моделей левого контекста и правого контекста, но только в «мелком» манере. Берт представляет «банк», используя как его левый, так и правый контекст - I made a ... deposit - начиная с самого дна глубокой нейронной сети, поэтому он глубоко двунаправлен .
Берт использует простой подход для этого: мы замаскируем 15% слов на входе, запускаем всю последовательность через глубокий двунаправленный трансформатор, а затем предсказываем только маскированные слова. Например:
Input: the man went to the [MASK1] . he bought a [MASK2] of milk.
Labels: [MASK1] = store; [MASK2] = gallon
Чтобы изучить отношения между предложениями, мы также тренируемся с простой задачей, которая может быть получена из любого моноязычного корпуса: учитывая два предложения A и B , является B -фактическим следующим предложением, которое поступает 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
Затем мы тренируем большую модель (от 12 слоя до 24-слойного трансформатора) на большом корпусе (Wikipedia + BookCorpus) в течение длительного времени (1 млн обновления), и это Берт.
Использование BERT имеет два этапа: предварительное обучение и тонкая настройка .
Предварительное обучение довольно дорого (четыре дня на 4-16 облачных TPU), но является единовременной процедурой для каждого языка (текущие модели только на английском языке, но в ближайшем будущем будут выпущены многоязычные модели). Мы выпускаем ряд предварительно обученных моделей из статьи, которые были предварительно обучены в Google. Большинству исследователей НЛП никогда не понадобится предварительно готовить свою собственную модель с нуля.
Точная настройка недорогая. Все результаты в статье могут быть воспроизведены не более 1 часа на одном облачном TPU или на несколько часов на графическом процессоре, начиная с той же самой предварительно обученной модели. Например, команда может быть обучена примерно через 30 минут на одном облачном TPU для достижения балла Dev F1 91,0%, что является современной системой.
Другим важным аспектом BERT является то, что он может быть очень легко адаптирован ко многим типам задач NLP. В статье мы демонстрируем самые современные результаты по уровню предложения (например, SST-2), на уровне паиров (например, Multinli), уровне слов (например, NER) и уровня SPAN (Например, команда) Задачи практически без каких-либо модификаций.
Мы выпускаем следующее:
BERT-Base и BERT-Large из бумаги.Весь код в этом репозитории работает без коробки с процессором, графическим процессором и облачным TPU.
Мы выпускаем модели BERT-Base и BERT-Large из бумаги. Uncased означает, что текст был снижен до токенизации слова, например, John Smith становится john smith . Uncased модель также выделяет любые маркеры акцента. Cased означает, что истинный случай и маркеры акцента сохраняются. Как правило, модель Uncased лучше, если вы не знаете, что информация о случаях важна для вашей задачи (например, распознавание сущности или тегинга с речи).
Все эти модели выпускаются по той же лицензии, что и исходный код (Apache 2.0).
Информацию о многоязычной и китайской модели, см. Многоязычную Readme.
При использовании модели CASE, обязательно пройдите --do_lower=False в обучающие сценарии. (Или пройти do_lower_case=False напрямую в FullTokenizer если вы используете свой собственный сценарий.)
Ссылки на модели здесь (щелкните правой кнопкой мыши «Сохраните ссылку как ...» на имя):
BERT-Large, Uncased (Whole Word Masking) : 24-слойный, 1024 скрытый, 16 голов, параметры 340 мBERT-Large, Cased (Whole Word Masking) : 24-слойный, 1024 скрытый, 16 голов, параметры 340 мBERT-Base, Uncased : 12-слойный, 768 скрытый, 12 голов, параметры 110 м.BERT-Large, Uncased : 24-слойный, 1024 скрытый, 16 голов, параметры 340 мBERT-Base, Cased : 12-слойный, 768 скрытый, 12 голов, параметры 110 м.BERT-Large, Cased : 24-слойный, 1024 скрытый, 16 голов, параметры 340 мBERT-Base, Multilingual Cased (New, recommended) : 104 языки, 12-слойные, 768 скрытых, 12 голов, параметры 110 м.BERT-Base, Multilingual Uncased (Orig, not recommended) (вместо этого не рекомендуется, используйте Multilingual Cased ) : 102 языки, 12-слойные, 768 скрытых, 12 голов, параметры 110 м.BERT-Base, Chinese : китайский упрощенный и традиционный, 12-слойный, 768 скрытый, 12 голов, параметры 110 м.Каждый файл .zip содержит три элемента:
bert_model.ckpt ), содержащая предварительно обученные веса (что на самом деле 3 файла).vocab.txt ) для карты Wordiece с идентификатором Word.bert_config.json ), который указывает гиперпараметры модели. ВАЖНО : Все результаты на бумаге были точно настроены на одном облачном TPU, который имеет 64 ГБ оперативной памяти. В настоящее время невозможно повторно производить большинство результатов BERT-Large на бумаге, используя графический процессор с 12 ГБ-16 ГБ оперативной памяти, потому что максимальный размер партии, который может соответствовать в памяти, слишком мал. Мы работаем над добавлением кода в этот репозиторий, который обеспечивает гораздо больший эффективный размер партии на графическом процессоре. См. Раздел по вопросам вне памяти для более подробной информации.
Этот код был протестирован с помощью TensorFlow 1.11.0. Он был протестирован с помощью Python2 и Python3 (но более тщательно с Python2, поскольку это то, что используется внутри Google).
Примеры тонкой настройки, в которых используется BERT-Base должны быть в состоянии работать на GPU, который имеет не менее 12 ГБ оперативной памяти, используя приведенные гиперпараметры.
Большинство приведенных ниже примеров предполагают, что вы будете проводить обучение/оценку на своей локальной машине, используя графический процессор, такой как Titan X или GTX 1080.
Однако, если у вас есть доступ к облачной TPU, на котором вы хотите тренироваться, просто добавьте следующие флаги в run_classifier.py или run_squad.py :
--use_tpu=True
--tpu_name=$TPU_NAME
Пожалуйста, смотрите учебник Google Cloud TPU для использования Cloud TPU. В качестве альтернативы, вы можете использовать ноутбук Google Colab «Bert Manetuning с облачными TPU».
На облачных TPU предварительно подготовленная модель и выходной каталог должны быть в Google Cloud Storage. Например, если у вас есть ведро с именем 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, запустив этот сценарий и распаковать его в какой -то каталог $GLUE_DIR . Затем загрузите контрольную точку BERT-Base и расстегните ее в какой-то каталог $BERT_BASE_DIR .
В этом примере Code Fine-Buse BERT-Base на корпусе Microsoft Research Parphrase Corpus (MRPC), который содержит только 3600 примеров и может настраиваться в течение нескольких минут на большинстве графических процессоров.
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
Это означает, что точность DEV устанавливала 84,55%. Небольшие наборы, такие как MRPC, имеют высокую дисперсию в точности набора разработчиков, даже при запуске с одной и той же контрольной точки до тренировок. Если вы перезапустите несколько раз (убедитесь, что укажите на различные output_dir ), вы должны увидеть результаты от 84% до 88%.
Несколько других предварительно обученных моделей реализованы внедорожными в run_classifier.py , поэтому должно быть простым следовать этим примерам, чтобы использовать BERT для любой задачи классификации с одним предложением или предложением.
Примечание. Вы можете увидеть сообщение Running train on CPU . Это действительно просто означает, что он работает на чем -то, кроме облачного 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) - это популярный набор данных для ответов на вопрос. Берт (во время выпуска) получает самые современные результаты в команде почти без модификации сетевой архитектуры, специфичной для конкретной задачи, или увеличения данных. Тем не менее, это требует полупроцессы и постобработки полукомплекса для работы с (а) характером контекстных параграфов с переменной длиной и (б) аннотаций ответов на уровне символов, которые используются для обучения команде. Эта обработка реализована и задокументирована в run_squad.py .
Чтобы запустить в команде, вам сначала нужно будет загрузить набор данных. Веб -сайт отряда, кажется, больше не ссылается на наборы данных V1.1, но здесь можно найти необходимые файлы:
Загрузите их в какой -то каталог $SQUAD_DIR .
Современная команда, полученная в результате статьи, в настоящее время не может быть воспроизведена на графическом процессоре 12 ГБ 16 ГБ из-за ограничений памяти (на самом деле, даже размер партии 1, по-видимому, не подходит на графическом процессоре 12 ГБ с использованием BERT-Large ). Тем не менее, достаточно сильная модель 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 наборы будут сохранены в файл с именем predictions.json в output_dir :
python $SQUAD_DIR /evaluate-v1.1.py $SQUAD_DIR /dev-v1.1.json ./squad/predictions.jsonКоторый должен создавать подобный выход:
{ " f1 " : 88.41249612335034, " exact_match " : 81.2488174077578} Вы должны увидеть результат, аналогичный 88,5%, зарегистрированным в статье для BERT-Base .
Если у вас есть доступ к облачным 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}Если вы настраиваете одну эпоху на Viviaqa до этого, результаты будут еще лучше, но вам нужно будет преобразовать витриаку в формат отряда JSON.
Эта модель также реализована и задокументирована в run_squad.py .
Чтобы запустить на Squad 2.0, вам сначала нужно будет загрузить набор данных. Необходимые файлы можно найти здесь:
Загрузите их в какой -то каталог $SQUAD_DIR .
На облаке 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/. Первоначальные предсказания DEV будут в.
Запустите этот сценарий, чтобы настроить порог для прогнозирования нулевых и не нулевых ответов:
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_predicticts.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Все эксперименты в бумаге были настраивались на облачном TPU, который имеет 64 ГБ оперативной памяти устройства. Следовательно, при использовании графического процессора с 12 ГБ-16 ГБ оперативной памяти вы, вероятно, столкнетесь с проблемами вне памяти, если вы используете те же гиперпараметры, описанные в статье.
Факторы, которые влияют на использование памяти:
max_seq_length : выпущенные модели были обучены длине последовательности до 512, но вы можете точно настроить с более короткой максимальной длиной последовательности, чтобы сохранить существенную память. Это управляется флагом max_seq_length в нашем примере кода.
train_batch_size : использование памяти также прямо пропорционально размеру партии.
Тип модели, BERT-Base против BERT-Large : модель BERT-Large требует значительно большей памяти, чем BERT-Base .
Оптимизатор : оптимизатор по умолчанию для BERT - это Адам, который требует много дополнительной памяти для хранения векторов m и v Переключение на более эффективный оптимизатор памяти может уменьшить использование памяти, но также может повлиять на результаты. Мы не экспериментировали с другими оптимизаторами для точной настройки.
Используя учебные сценарии по умолчанию ( run_classifier.py и run_squad.py ), мы сравнивали максимальный размер партии на отдельном титане x GPU (12 ГБ ОЗУ) с Tensorflow 1.11.0:
| Система | Длина SEQ | Максимальный размер партии |
|---|---|---|
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. Код будет основан на одном (или обоих) из следующих методов:
Накопление градиента . Образцы в Minibatch, как правило, независимы в отношении расчета градиента (исключая нормализацию пакетов, которая здесь не используется). Это означает, что до выполнения обновления веса могут быть накоплены градиенты нескольких меньших minibatches, и это будет точно эквивалентно одному большему обновлению.
Градиент контрольно -пропускной пункт . Основным использованием памяти GPU/TPU во время обучения DNN является кэширование промежуточных активаций в прямом проходе, которые необходимы для эффективных вычислений в обратном проходе. «Градиент контрольно-пропускной пункт» торгует памятью для вычислительного времени, размышляя за активации.
Тем не менее, это не реализовано в текущем выпуске.
В некоторых случаях, вместо того, чтобы настраивать всю предварительно обученную модель сквозной, может быть полезно для получения предварительно обученных контекстуальных встроений , которые являются фиксированными контекстуальными представлениями каждого входного токена, генерируемого из скрытых слоев предварительного -Оренарованная модель. Это также должно смягчить большинство вопросов вне памяти.
В качестве примера мы включаем скрипт 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 Это создаст файл JSON (одна строка на строку ввода), содержащий активации BERT от каждого слоя трансформатора, указанный layers (-1, является конечным скрытым слоем трансформатора и т. Д.)
Обратите внимание, что этот скрипт будет создавать очень большие выходные файлы (по умолчанию, около 15 КБ для каждого входного токена).
Если вам нужно поддерживать выравнивание между оригинальными и токенизированными словами (для проецирования учебных ярлыков), см. В разделе токенизации ниже.
Примечание. Вы можете увидеть сообщение, подобное тому, 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, .
Разделение пунктуации : разделить все знаки препинания с обеих сторон (то есть добавить пробелы вокруг всех знаков пунктуации). Символы препинания определяются как (а) все с классом P* Unicode, (б) любой символ, не являющийся буквальным/номером/пространством ASCII (например, символы, такие как $ , которые технически не пунктуация). Например, john johanson's, → john johanson ' s ,
Токенизация Wordsiece : примените токенизацию пробелов к выводу вышеуказанной процедуры и примените токенизацию слов к каждому токену отдельно. (Наша реализация напрямую основана на той, которая от 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 ++, и имел некоторую дополнительную сложность), но этот код генерирует данные предварительного обучения, как описано в статье.
Вот как запустить генерацию данных. Ввод - это простой текстовый файл с одним предложением на строку. (Важно, чтобы это были фактические предложения для задачи «следующего предсказания»). Документы разграничены пустыми линиями. Вывод представляет собой набор tf.train.Example S, сериализованный в формате файла TFRecord .
Вы можете выполнить сегментацию предложения с помощью готового инструментария NLP, такого как Spacy. Сценарий create_pretraining_data.py будет объединять сегменты до тех пор, пока они не достигнут максимальной длины последовательности, чтобы минимизировать вычислительные отходы от прокладки (см. Сценарий для получения более подробной информации см. Тем не менее, вы можете намеренно добавить небольшой объем шума к своим входным данным (например, случайным образом усечь 2% входных сегментов), чтобы сделать его более надежным для негативного ввода во время точной настройки.
В этом скрипте хранится все примеры для всего входного файла в памяти, поэтому для больших файлов данных вы должны положить конец входному файлу и вызовать сценарий несколько раз. (Вы можете передать в файловом глобусе 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 очень мал, этот пример обучения переоценит эти данные только в нескольких шагах и даст нереалистично высокие числа точности.
vocab_size в bert_config.json . Если вы используете больший словарный запас, не изменяя его, вы, скорее всего, получите NANS при тренировке на графическом процессоре или TPU из-за непревзойденного доступа.max_seq_length .BERT-Base на одном упреждаемом облачном TPU V2, который занимает около 2 недель по цене около 500 долларов США (основываясь на ценах в октябре 2018 года) Полем Вам придется масштабировать размер партии, когда тренируйтесь только на одном облачном TPU, по сравнению с тем, что использовалось в статье. Рекомендуется использовать самый большой размер партии, который вписывается в память TPU. Мы не сможем выпустить предварительно обработанные наборы данных, используемые в статье. Для Википедии рекомендуемая предварительная обработка состоит в том, чтобы загрузить последний дамп, извлечь текст WikiExtractor.py , а затем применить любую необходимую очистку для преобразования его в простой текст.
К сожалению, исследователи, которые собрали BookCorpus, больше не имеют его для публичной загрузки. Набор данных Project Guttenberg представляет собой несколько меньшую (200 м) коллекцию старых книг, которые являются общественным достоянием.
Common Crawl-еще одна очень большая коллекция текста, но вам, вероятно, придется сделать существенную предварительную обработку и очистку, чтобы извлечь удобный корпус для предварительного обучения BERT.
Этот репозиторий не включает код для изучения нового словаря Wordiece. 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. See the LICENSE file for more information.
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] ).
