Создавайте, обучайте и развертывайте языковую модель с миллиардами параметров на терабайтах данных с помощью TensorFlow и Amazon SageMaker.

Увеличение размера языковых моделей было одной из самых больших тенденций в обработке естественного языка (NLP) в последние годы. С 2018 года мы наблюдаем беспрецедентную разработку и развертывание все более крупных языковых моделей, включая BERT и его варианты, GPT-2, T-NLG и GPT-3 (175 миллиардов параметров).

Эти модели раздвинули границы возможных архитектурных инноваций. Мы сталкиваемся с рядом проблем при обучении крупномасштабных моделей глубокого обучения, особенно новой волны генеративных предварительно обученных преобразователей. Эти проблемы включают аппаратные ограничения и компромиссы с вычислениями и эффективностью. Чтобы преодолеть эти проблемы, связанные с параллелизмом моделей и данных, AWS предлагает широкий спектр возможностей.

В этом посте мы представляем два основных подхода: распараллеливание данных и распараллеливание моделей с использованием Создатель мудреца Амазонки, и обсудить их плюсы и минусы.

Модель

Для языковой модели мы используем трансформеры, представленные в статье Внимание это все, что вам нужно. Преобразователи — это модели глубокого обучения, предназначенные для того, чтобы сознательно избегать ловушек RNN, полагаясь на механизм самоконтроля для построения глобальных зависимостей между вводом и выводом. Архитектура модели Transformer обеспечивает значительно лучшую распараллеливание и позволяет достичь высокой производительности за относительно короткое время обучения. Основанный на успехе «Трансформеров», BERT представлен в газете. BERT: предварительная подготовка глубинных двунаправленных трансформаторов для понимания языка, добавлено двунаправленное предварительное обучение для языкового представления. Вдохновленный задачей Cloze, BERT предварительно обучен моделированию маскированного языка (MLM), в котором модель учится восстанавливать исходные слова для случайно замаскированных токенов. Модель BERT также предварительно обучена задаче прогнозирования следующего предложения (NSP), чтобы предсказать, находятся ли два предложения в правильном порядке чтения. С момента своего появления в 2018 году BERT и его варианты широко используются в языковых моделях.

Мы начнем с создания двух слоев внедрения для токена и позиционного внедрения. Входные вложения представляют собой сумму вложений токенов и вложений позиции.

class TokenAndPositionEmbedding(tf.keras.layers.Layer): """ Creates two separate embedding layers: one for tokens and one for token index (positions). """ def __init__(self, maxlen, vocab_size, embed_dim): super(TokenAndPositionEmbedding, self).__init__() self.token_emb = tf.keras.layers.Embedding(input_dim=vocab_size, output_dim=embed_dim) self.pos_emb = tf.keras.layers.Embedding(input_dim=maxlen, output_dim=embed_dim) def call(self, x): maxlen = tf.shape(x)[-1] # positions are represented by a token's index positions = tf.range(start=0, limit=maxlen, delta=1) positions = self.pos_emb(positions) # token embedding x = self.token_emb(x) # return sum as input return x + positions

Затем мы определяем блок преобразователя декодера с двумя подуровнями: уровень самоконтроля с несколькими головками и простая полносвязная сеть прямой связи с последующей нормализацией и отсевом уровня:

class TransformerBlock(tf.keras.layers.Layer): def __init__(self, embed_dim, num_heads, ff_dim, rate=0.1): # self attention layer super(TransformerBlock, self).__init__() self.att = tf.keras.layers.MultiHeadAttention( num_heads=num_heads, key_dim=embed_dim) # feed forward layer self.ffn = [tf.keras.layers.Dense(ff_dim, activation="relu"), tf.keras.layers.Dense(embed_dim)] # layer normalization self.layernorm1 = tf.keras.layers.LayerNormalization(epsilon=1e-6) self.layernorm2 = tf.keras.layers.LayerNormalization(epsilon=1e-6) # dropout self.dropout1 = tf.keras.layers.Dropout(rate) self.dropout2 = tf.keras.layers.Dropout(rate) def call(self, inputs): # getting batch size and seq len from input shape input_shape = tf.shape(inputs) batch_size = input_shape[0] seq_len = input_shape[1] # decoder casual mask casual_mask = casual_attention_mask(batch_size, seq_len, seq_len, tf.bool) # self attention forward pass attention_output = self.att(inputs, inputs, attention_mask=causal_mask) # dense layers, dropout and normalization attention_output = self.dropout1(attention_output) ffn_output = self.ffn[0](out1) ffn_output = self.ffn[1](ffn_output) out2 = self.dropout2(ffn_output) return self.layernorm2(out1 + out2)

Наконец, мы создаем нашу языковую модель с предыдущим слоем внедрения и блоками преобразования:

class MyModel(tf.keras.Model): def __init__(self, maxlen, vocab_size, embed_dim, num_heads, feed_forward_dim, num_layers, learning_rate): super(MyModel, self).__init__(maxlen, vocab_size, embed_dim, num_heads, feed_forward_dim, num_layers, learning_rate) # embedding layer self.embedding_layer = TokenAndPositionEmbedding(maxlen, vocab_size, embed_dim) # transformer blocks self.transformer_blocks = [ TransformerBlock(embed_dim, num_heads, feed_forward_dim) for i in range(num_layers) ] # last dense layer self.dense = tf.keras.layers.Dense(vocab_size) def call(self, inputs, training=None): x_emb = self.embedding_layer(inputs) x = x_emb for transformer_block in self.transformer_blocks: x = transformer_block(x) outputs = self.dense(x) return [outputs, x_emb] def init_train_settings(maxlen, vocab_size, embed_dim, num_heads, feed_forward_dim, num_layers, learning_rate): """ Creates model, optimizer and loss function """ model = MyModel(maxlen, vocab_size, embed_dim, num_heads, feed_forward_dim, num_layers, learning_rate) loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) optimizer = tf.keras.optimizers.Adam(learning_rate=learning_rate) return model, optimizer, loss_fn

В зависимости от ваших гиперпараметров вы можете масштабировать эту модель от тысяч параметров до миллиардов параметров. Основная проблема с моделями с миллиардами параметров заключается в том, что вы не можете разместить модель в одном экземпляре и должны распределить модель по нескольким узлам для обучения и вывода.

Набор данных

В наших экспериментах мы использовали Набор данных сваи. The Pile — это текстовый набор данных на английском языке объемом 800 ГиБ, предназначенный для обучения крупномасштабных языковых моделей. Он создан из 22 разнообразных и высококачественных наборов данных, включая как устоявшиеся наборы данных НЛП, так и новые.

Набор данных создается из различных источников данных, включая книги; репозитории GitHub; интернет страницы; журналы чата; и статьи по медицине, физике, математике, информатике и философии. В частности, он использует следующие источники: Pile-CC, PubMed Central, ArXiv, GitHub, проект FreeLaw, Stack Exchange, Управление по патентам и товарным знакам США, PubMed, Ubuntu, IRC, HackerNews, YouTube, PhilPapers, Books3, Project Gutenberg ( PG-19), OpenSubtitles, английская Википедия, DM Mathematics, EuroParl, корпус электронной почты Enron и NIH ExPorter. Он также включает OpenWebText2 и BookCorpus2, которые являются расширениями исходных наборов данных OpenWebText и BookCorpus соответственно. Разнообразие источников данных может улучшить общие междисциплинарные знания и, следовательно, улучшить возможности последующего обобщения.

Основная проблема с этим набором данных — его размер; набор данных содержит 825 ГиБ текста, что соответствует 4.2 ТиБ предварительно обработанных и сжатых точек данных. Подобно проблемам, с которыми мы сталкиваемся при обучении и размещении моделей, обучение модели с этим набором данных на одном экземпляре займет много времени и непрактично.

Наше решение состоит в том, чтобы разбить набор данных на фрагменты размером примерно 1 ГиБ, загрузить и предварительно обработать функции в Набор данных TensorFlow объекты и хранить их в Эластичный файловый сервис Amazon (Амазон ЭФС). Наборы данных TensorFlow обеспечивают простой в использовании и высокопроизводительный конвейер данных, который хорошо интегрируется с нашими моделями. Amazon EFS — это простой в использовании сервис, который позволяет нам создать общую файловую систему, которая автоматически масштабируется по мере добавления и удаления файлов. Кроме того, Amazon EFS может при необходимости резко увеличить пропускную способность, что очень важно для нашего конвейера обучения данных и моделей.

Далее мы рассмотрим стратегии распределенного обучения для решения этих задач.

Распределенное обучение

В этом проекте мы столкнулись с двумя проблемами: масштабирование размера модели и объема данных. Увеличение размера модели и количества обучаемых параметров может привести к повышению точности, но существует ограничение на модель, которую можно поместить в память одного графического процессора или даже в несколько графических процессоров в одном экземпляре. Кроме того, модели большего размера требуют больше времени для обучения.

Вы можете решить эти проблемы двумя разными способами: параллелизм данных и параллелизм моделей. При параллелизме данных мы выполняем стохастический градиентный спуск (SGD), распределяя записи мини-пакета по разным устройствам для ускорения обучения. Однако параллельное обучение данных сопряжено с дополнительной сложностью вычисления мини-пакетного среднего градиента с градиентами со всех устройств, шаг называется AllReduce, что усложняется по мере роста обучающего кластера. При использовании параллелизма данных мы должны иметь возможность разместить модель и одну точку данных в устройстве (ЦП или ГП), что является ограничивающим фактором в наших экспериментах, поскольку размер такой большой модели намного больше, чем память одного ГП. размер.

Другим решением является использование параллелизма моделей, который разделяет модель на несколько устройств. Параллелизм модели — это процесс разделения модели между несколькими устройствами или узлами (например, экземплярами с графическим процессором) и создания эффективного конвейера для обучения модели на этих устройствах для максимального использования графического процессора.

Распараллеливание данных

Распараллеливание данных является наиболее распространенным подходом к нескольким графическим процессорам или распределенному обучению. Вы можете группировать свои данные, отправлять их на несколько устройств (каждое из которых содержит реплицированную модель), а затем объединять результаты. Мы экспериментировали с двумя пакетами для распараллеливания данных: Horovod и the Распределенная параллельная библиотека данных SageMaker.

Horovod — это распределенная обучающая среда глубокого обучения для TensorFlow, Keras, PyTorch и Apache MXNet. Чтобы использовать Horovod, мы прошли следующий процесс:

1. Инициализировать, запустив hvd.init().
2. Свяжите каждое устройство с одним процессом. Первый процесс или рабочий процесс связан с первым устройством, второй процесс связан со вторым устройством и так далее.
3. Отрегулируйте скорость обучения в зависимости от количества устройств.
4. Оберните оптимизатор в hvd.DistributedOptimizer.
5. Передайте начальные состояния переменных от первого рабочего с рангом 0 всем остальным процессам. Это необходимо для обеспечения последовательной инициализации всех воркеров при запуске обучения со случайными весами или восстановлении из контрольной точки.
6. Убедитесь, что только устройство 0 может сохранять контрольные точки, чтобы предотвратить их повреждение другими рабочими процессами.

Ниже приведен сценарий обучения:

import horovod.tensorflow as hvd
# Initialize Horovod
hvd.init() # Pin GPU to be used to process local rank (one GPU per process)
gpus = tf.config.experimental.list_physical_devices('GPU')
for gpu in gpus: tf.config.experimental.set_memory_growth(gpu, True)
if gpus: tf.config.experimental.set_visible_devices(gpus[hvd.local_rank()], 'GPU') # Build model
... @tf.function
def training_step(texts, labels, first_batch): with tf.GradientTape() as tape: predictions = model(texts, training=True) loss = loss_fn(labels, predictions[0]) # Horovod: add Horovod Distributed GradientTape. tape = hvd.DistributedGradientTape(tape) grads = tape.gradient(loss, model.trainable_variables) opt.apply_gradients(zip(grads, model.trainable_variables)) # Horovod: broadcast initial variable states from rank 0 to all other processes. # This is necessary to ensure consistent initialization of all workers when # training is started with random weights or restored from a checkpoint. # # Note: broadcast should be done after the first gradient step to ensure optimizer # initialization. if first_batch: hvd.broadcast_variables(model.variables, root_rank=0) hvd.broadcast_variables(opt.variables(), root_rank=0) return loss # Horovod: adjust number of steps based on number of GPUs.
for batch, (texts, labels) in enumerate(dataset.take(10000 // hvd.size())): loss = training_step(texts, labels, batch == 0) if batch % 10 == 0 and hvd.local_rank() == 0: print('Step #%dtLoss: %.6f' % (batch, loss)) # Horovod: save checkpoints only on worker 0 to prevent other workers from
# corrupting it.
if hvd.rank() == 0: checkpoint.save(checkpoint_dir)

Библиотека параллельных данных SageMaker позволяет нам масштабировать наше обучение с почти линейной эффективностью, ускоряя наше обучение с минимальными изменениями кода. Библиотека выполняет пользовательский AllReduce работу и оптимизирует обмен данными между устройствами, полностью используя сетевую инфраструктуру AWS и Эластичное вычислительное облако Amazon Топология инстанса (Amazon EC2). Чтобы использовать параллельную библиотеку данных SageMaker, мы прошли следующий процесс:

1. Импортировать и инициализировать sdp.init().
2. Свяжите каждое устройство с одним smdistributed.dataparallel процесс с local_rank. sdp.tensorflow.local_rank() дает нам локальный ранг устройств. Лидер имеет ранг 0, а рабочие — ранг 1, 2, 3 и так далее.
3. Отрегулируйте скорость обучения в зависимости от количества устройств.
4. Оберните tf.GradientTape DistributedGradientTape для выполнения AllReduce.
5. Передайте начальные переменные модели от ведущего узла всем рабочим узлам.
6. Убедитесь, что только устройство 0 может сохранять контрольные точки.

Распараллеливание модели

Мы можем настроить гиперпараметры, чтобы модель оставалась достаточно маленькой для обучения с использованием одного графического процессора, или мы можем использовать параллелизм модели, чтобы разделить модель между несколькими графическими процессорами в нескольких экземплярах. Увеличение количества обучаемых параметров модели может привести к повышению точности, но существует ограничение на максимальный размер модели, который можно поместить в одну память графического процессора. Мы использовали параллельную библиотеку распределенных моделей SageMaker для обучения наших более крупных моделей. Шаги следующие:

1. Импортируйте и инициализируйте библиотеку с помощью smp.init().
2. Модель Keras должна наследоваться от smp.DistributedModel вместо класса Keras Model.
3. Поставьте drop_remainder=True в tf.Dataset.batch() метод, обеспечивающий, чтобы размер партии всегда делился на количество микропартий.
4. Все случайные операции в конвейере данных должны использовать одно и то же начальное число: smp.dp_rank()Например, shuffle(ds, seed=smp.dp_rank()). Это обеспечивает согласованность выборок данных на устройствах, содержащих разные разделы модели.
5. Прямая и обратная логика должна быть в ступенчатой ​​​​функции с smp.step украшение.
6. Выполните постобработку выходных данных микропакетов, используя методы StepOutput, такие как reduce_mean, smp.step функция должна иметь возвращаемое значение, которое зависит от вывода smp.DistributedModel.

Сценарий обучения следующий:

import smdistributed.modelparallel.tensorflow as smp # SMP: Initialize
smp.init() # SMP: Define smp.DistributedModel the same way as Keras sub-classing API
class MyModel(smp.DistributedModel): def __init__(self, maxlen, vocab_size, embed_dim, num_heads, feed_forward_dim, num_layers, learning_rate): super(MyModel, self).__init__(maxlen, vocab_size, embed_dim, num_heads, feed_forward_dim, num_layers, learning_rate) self.embedding_layer = gpt_model.TokenAndPositionEmbedding(maxlen, vocab_size, embed_dim) self.transformer_blocks = [ gpt_model.TransformerBlock(embed_dim, num_heads, feed_forward_dim) for i in range(num_layers) ] self.dense = tf.keras.layers.Dense(vocab_size) def call(self, inputs, training=None): x_emb = self.embedding_layer(inputs) x = x_emb for transformer_block in self.transformer_blocks: x = transformer_block(x) outputs = self.dense(x) return [outputs, x_emb] # SMP: Define smp.step. Return any tensors needed outside
@smp.step
def get_grads(texts, labels): predictions = model(texts, training=True) loss = loss_fn(labels, predictions[0]) grads = optimizer.get_gradients(loss, model.trainable_variables) return grads, loss, predictions[0] @tf.function
def train_step(texts, labels, first_batch): gradients, loss, predictions = get_grads(texts, labels) # SMP: Accumulate the gradients across microbatches gradients = [g.accumulate() for g in gradients] optimizer.apply_gradients(zip(gradients, model.trainable_variables)) # SMP: Average the loss across microbatches train_loss(loss.reduce_mean()) # SMP: Merge predictions across microbatches train_accuracy(labels, predictions.merge()) return loss.reduce_mean() histories = [] for _ in range(epochs): train_loss.reset_states() train_accuracy.reset_states() for texts, labels in text_ds: for i in range(128): text = tf.expand_dims(texts[0][i], axis=0) label = tf.expand_dims(labels[0][i], axis=0) train_step(text, label) 

Подробное руководство по включению сценария обучения TensorFlow для параллельной библиотеки распределенных моделей SageMaker см. Изменение сценария обучения TensorFlow. Для PyTorch см. Изменить сценарий обучения PyTorch.

Отладчик SageMaker

В предыдущих разделах мы обсуждали, как оптимизировать обучение, используя методы распараллеливания моделей и данных. С Amazon SageMaker Отладчик, теперь мы можем собирать информацию о профилировании производительности из наших тренировочных прогонов, чтобы определить, насколько обучение улучшилось. По умолчанию отладчик фиксирует системные показатели для каждого обучающего задания SageMaker, такие как загрузка графического процессора, процессора, памяти, сети и операций ввода-вывода, с интервалом выборки 500 миллисекунд. Мы можем получить доступ к данным следующим образом:

from smdebug.profiler.analysis.notebook_utils.training_job import TrainingJob
tj = TrainingJob('SMD-MP-demo-2022-01-21-06-43-23-841', "us-east-1")
tj.wait_for_sys_profiling_data_to_be_available()
system_metrics_reader = tj.get_systems_metrics_reader()

Отладчик предоставляет утилиты для визуализации данные профилирования по-разному. В следующем примере мы видим общее использование GPU и CPU, а также время ожидания ввода-вывода для задания обучения с несколькими GPU с использованием Horovod. Чтобы сгенерировать эти графики, мы запускаем следующий код:

from smdebug.profiler.analysis.notebook_utils.timeline_charts import TimelineCharts view_timeline_charts = TimelineCharts( system_metrics_reader, framework_metrics_reader, select_dimensions=["CPU", "GPU", "I/O"], select_events=["total"], show_workers=False )

Использование графического процессора часто колеблется в пределах от 0 до 100 %, а высокое время ожидания ввода-вывода при низкой загрузке графического процессора является индикатором узкого места ввода-вывода. Кроме того, общая загрузка ЦП никогда не превышает 70%, а это означает, что мы можем улучшить предварительную обработку данных, увеличив количество рабочих процессов.

Мы можем повысить производительность, переключившись с Horovod на параллельную библиотеку распределенных данных SageMaker. На следующих графиках мы видим, что графические процессоры используются более эффективно и снижаются до низкого уровня использования только в течение коротких периодов времени.

Учебная инфраструктура

Для обучения моделей мы использовали 10 экземпляров ml.p3.16xlarge с помощью обучающего задания SageMaker. SageMaker сокращает время и затраты на обучение и настройку моделей машинного обучения (ML) без необходимости управления инфраструктурой. С помощью SageMaker вы можете легко обучать и настраивать модели машинного обучения с помощью встроенных инструментов для управления и отслеживания обучающих экспериментов, автоматического выбора оптимальных гиперпараметров, отладки учебных заданий и мониторинга использования системных ресурсов, таких как графические и центральные процессоры, и пропускной способности сети. Данные размещались в Amazon EFS, что позволяло нам увеличивать и уменьшать размер по мере добавления и удаления файлов без необходимости управления или выделения ресурсов. Нашей основной целью было повысить скорость обучения и снизить затраты.

Масштабируемость модели

Хотя эта инфраструктура в основном используется для генерации языка, с архитектурой GPT и набором данных Pile вы можете использовать эти методы для обучения крупномасштабных моделей преобразователей, что полезно во многих областях помимо NLP. В самом машинном обучении многие задачи компьютерного зрения в настоящее время решаются с помощью архитектур с большими параметрами (преобразователями), где было показано, что они превосходят традиционные CNN (сверточные нейронные сети) в таких задачах, как обучение представлению (см. Продвижение современного уровня в области компьютерного зрения с самоконтролируемыми трансформерами и в 10 раз более эффективным обучением) и крупномасштабное преобразование изображений в текст (например, CLIP). Модели с большими параметрами также открывают новые горизонты в науках о жизни в таких областях, как анализ структуры белка и анализ данных медицинских изображений.

Решения, которые мы подробно описываем в этом посте для распределенного обучения и управления большими моделями, также должны применяться к моделям в любой из этих областей.

Компромиссы

В исследовательском сообществе продолжается дискуссия о рисках обучения крупномасштабных языковых моделей, а также о том, достаточно ли продуманы потенциальные риски, связанные с их разработкой, и стратегии снижения этих рисков, некоторые из которых включают финансовые и экологические затраты. Согласно бумаги опубликовано в ACM, обучение одной базовой модели BERT (без настройки гиперпараметров) на графических процессорах, по оценкам, требует столько же энергии, сколько трансамериканский полет. Воздействие на окружающую среду зависит от размера модели, и возможность эффективной тонкой настройки таких моделей может потенциально значительно сократить выбросы. AWS недавно запустил новый Инструмент углеродного следа клиента, доступный для всех клиентов AWS бесплатно, в рамках усилий Amazon по повышению устойчивости и сокращению выбросов углерода. Запуск приложений в облаке AWS потенциально может уменьшить углеродный след (по сравнению с корпоративными центрами обработки данных, которые были исследованы в отчет 2019).

Заключение

В этом посте продемонстрировано решение, упрощающее тонкую настройку языковых моделей с миллиардом параметров в облаке AWS с помощью SageMaker.

Дополнительные сведения о параллелизме моделей с помощью SageMaker см. Обучайте модели NLP с более чем 175 миллиардами параметров с помощью параллельных дополнений моделей и Hugging Face на Amazon SageMaker. и Как Latent Space использовала библиотеку параллелизма моделей Amazon SageMaker для расширения границ крупномасштабных преобразователей.

Если вам нужна помощь в ускорении использования машинного обучения в ваших продуктах и ​​процессах, обратитесь в Лаборатория решений Amazon ML.

Об авторах

Сиа Голами — старший специалист по данным в лаборатории решений Amazon ML, где он создает решения AI/ML для клиентов из различных отраслей. Он увлечен обработкой естественного языка (NLP) и глубоким обучением. Вне работы Сия любит проводить время на природе и играть в теннис.

Мехди Нуриявляется менеджером и старшим научным сотрудником в лаборатории Amazon ML Solutions Lab, где он работает с клиентами из различных отраслей и помогает им ускорить миграцию в облако, а также решить свои проблемы с машинным обучением, используя самые современные решения и технологии.

Мухён Ким Специалист по анализу данных в Amazon Machine Learning Solutions Lab. Он решает различные бизнес-задачи клиентов, применяя машинное обучение и глубокое обучение, а также помогает им получить навыки.

Дэнни Берд является прикладным ученым в лаборатории решений Amazon ML. В лаборатории он помогал клиентам разрабатывать передовые решения машинного обучения по специальностям машинного обучения, от компьютерного зрения до обучения с подкреплением. Он увлечен продвижением технологий и раскрытием нового потенциала продуктов AWS.

Франсиско Кальдерон Родригес работает специалистом по данным в лаборатории решений Amazon ML. В качестве члена лаборатории ML Solutions Lab он помогает клиентам AWS решать важные бизнес-задачи с помощью глубокого обучения. В свободное время Франсиско любит заниматься музыкой и гитарой, играть в футбол со своими дочерьми и проводить время со своей семьей.

Йохей Накаяма является архитектором глубокого обучения в лаборатории решений Amazon ML. Он работает с клиентами из разных вертикалей, чтобы ускорить использование ими искусственного интеллекта и облачных сервисов AWS для решения своих бизнес-задач. Он заинтересован в применении технологий ML/AI в космической отрасли.

Натали Раушмайр — старший научный сотрудник AWS, где она помогает клиентам разрабатывать приложения для глубокого обучения.

• Коинсмарт. Лучшая в Европе биржа биткойнов и криптовалют.
• Платоблокчейн. Интеллект метавселенной Web3. Расширение знаний. БЕСПЛАТНЫЙ ДОСТУП.
• КриптоХок. Альткоин Радар. Бесплатная пробная версия.
• Источник: https://aws.amazon.com/blogs/machine-learning/create-train-and-deploy-a-billion-parameter-language-model-on-terabytes-of-data-with-tensorflow-and- амазонка-мудрец /