Конвейеры данных со скоростью TPU: tf.data.Dataset и TFRecords

1. Обзор

ТПУ очень быстрые. Поток обучающих данных должен соответствовать скорости обучения. В этой лабораторной работе вы узнаете, как загружать данные из GCS с помощью API tf.data.Dataset для подачи в ваш TPU.

Эта лабораторная работа является первой частью серии «Керас в ТПУ». Вы можете делать их в следующем порядке или самостоятельно.

• [ЭТА ЛАБОРАТОРНАЯ ЛАБОРАТОРИЯ] Конвейеры данных со скоростью TPU: tf.data.Dataset и TFRecords
• Ваша первая модель Keras с трансферным обучением
• Сверточные нейронные сети с Keras и TPU
• Современные сети, сжимающие сети, Xception, с Keras и TPU.

Что вы узнаете

• Использование API tf.data.Dataset для загрузки обучающих данных
• Чтобы использовать формат TFRecord для эффективной загрузки обучающих данных из GCS.

Обратная связь

Если вы заметили что-то неладное в этой лаборатории кода, сообщите нам. Обратная связь может быть предоставлена ​​через вопросы GitHub [ ссылка обратной связи ].

2. Быстрый старт Google Colaboratory

Эта лабораторная работа использует Google Collaboratory и не требует никакой настройки с вашей стороны. Colaboratory — это онлайн-платформа для записных книжек для образовательных целей. Он предлагает бесплатное обучение процессорам, графическим процессорам и TPU.

Вы можете открыть этот образец блокнота и просмотреть пару ячеек, чтобы ознакомиться с Colaboratory.

Welcome to Colab.ipynb

Выберите серверную часть TPU

В меню Colab выберите «Время выполнения» > «Изменить тип среды выполнения» , а затем выберите «TPU». В этой лаборатории по программированию вы будете использовать мощный TPU (тензорный процессор), поддерживающий аппаратное ускорение обучения. Подключение к среде выполнения произойдет автоматически при первом запуске, или вы можете использовать кнопку «Подключиться» в правом верхнем углу.

Исполнение ноутбука

Выполняйте ячейки по одной, щелкая ячейку и используя Shift-ENTER. Вы также можете запустить весь блокнот, выбрав «Среда выполнения» > «Выполнить все».

Оглавление

Все тетради имеют оглавление. Открыть его можно с помощью черной стрелки слева.

Скрытые ячейки

В некоторых ячейках будет отображаться только заголовок. Это функция блокнота, специфичная для Colab. Вы можете дважды щелкнуть по ним, чтобы увидеть код внутри, но обычно это не очень интересно. Обычно функции поддержки или визуализации. Вам все равно нужно запустить эти ячейки, чтобы определить функции внутри.

Аутентификация

Colab может получить доступ к вашим частным корзинам облачного хранилища Google при условии, что вы пройдете аутентификацию с использованием авторизованной учетной записи. Приведенный выше фрагмент кода запустит процесс аутентификации.

3. [ИНФОРМАЦИЯ] Что такое тензорные процессоры (TPU)?

В двух словах

TPU — это аппаратные ускорители, специализирующиеся на задачах глубокого обучения. В этой лаборатории кода вы увидите, как их использовать с Keras и Tensorflow 2. Облачные TPU доступны в базовой конфигурации с 8 ядрами, а также в более крупных конфигурациях, называемых «модулями TPU», с числом до 2048 ядер. Дополнительное оборудование можно использовать для ускорения обучения за счет увеличения размера обучающего пакета.

Код для обучения модели на TPU в Keras (и использования графического процессора или процессора, если TPU недоступен):

try: # detect TPUs
    tpu = tf.distribute.cluster_resolver.TPUClusterResolver.connect()
    strategy = tf.distribute.TPUStrategy(tpu)
except ValueError: # detect GPUs
    strategy = tf.distribute.MirroredStrategy() # for CPU/GPU or multi-GPU machines

# use TPUStrategy scope to define model
with strategy.scope():
  model = tf.keras.Sequential( ... )
  model.compile( ... )

# train model normally on a tf.data.Dataset
model.fit(training_dataset, epochs=EPOCHS, steps_per_epoch=...)

Сегодня мы будем использовать TPU для создания и оптимизации классификатора цветов на интерактивной скорости (минуты на тренировочный прогон).

Почему ТПУ?

Современные графические процессоры организованы вокруг программируемых «ядер» — очень гибкой архитектуры, которая позволяет им решать различные задачи, такие как 3D-рендеринг, глубокое обучение, физическое моделирование и т. д. С другой стороны, TPU сочетают в себе классический векторный процессор со специализированным процессором. модуль матричного умножения и преуспейте в любой задаче, где доминируют большие матричные умножения, например, в нейронных сетях.

Иллюстрация: плотный слой нейронной сети в виде матричного умножения с пакетом из восьми изображений, обрабатываемых нейронной сетью одновременно. Пожалуйста, выполните умножение одной строки на столбец, чтобы убедиться, что оно действительно выполняет взвешенную сумму всех значений пикселей изображения. Сверточные слои также можно представить как умножения матриц, хотя это немного сложнее ( объяснение здесь, в разделе 1 ).

Аппаратное обеспечение

МХУ и ВПУ

Ядро TPU v2 состоит из блока умножения матриц (MXU), который выполняет матричные умножения, и блока векторной обработки (VPU) для всех других задач, таких как активации, softmax и т. д. VPU обрабатывает вычисления float32 и int32. С другой стороны, MXU работает в формате с плавающей запятой смешанной точности (16–32 бита).

С плавающей запятой смешанной точности и bfloat16

MXU вычисляет умножение матриц, используя входные данные bfloat16 и выходные данные float32. Промежуточные накопления выполняются с точностью float32.

Обучение нейронной сети обычно устойчиво к шуму, вносимому пониженной точностью с плавающей запятой. Бывают случаи, когда шум даже помогает оптимизатору сходиться. 16-битная точность с плавающей запятой традиционно использовалась для ускорения вычислений, но форматы float16 и float32 имеют очень разные диапазоны. Уменьшение точности с float32 до float16 обычно приводит к переполнению или потере значения. Решения существуют, но обычно требуется дополнительная работа, чтобы float16 работал.

Именно поэтому Google представила формат bfloat16 в TPU. bfloat16 — это усеченное число float32 с точно такими же битами экспоненты и диапазоном, что и у float32. В дополнение к тому факту, что TPU выполняют умножение матриц со смешанной точностью с использованием входных данных bfloat16 и выходных данных float32, это означает, что, как правило, никаких изменений кода не требуется, чтобы получить выгоду от повышения производительности за счет пониженной точности.

Использование смешанной точности bfloat16/float32 является значением по умолчанию для TPU. Чтобы включить его, в вашем коде Tensorflow не требуется никаких изменений. Вы по-прежнему работаете с float32 во всем своем коде. При выполнении матричного умножения TPU автоматически сокращает свои входные данные до bfloat16. Результирующая матрица — float32.

Систолический массив

MXU реализует умножение матриц аппаратно, используя так называемую архитектуру «систолического массива», в которой элементы данных проходят через массив аппаратных вычислительных блоков. (В медицине термин «систолический» относится к сокращениям сердца и кровотоку, здесь — к потоку данных.)

Основным элементом матричного умножения является скалярное произведение строки одной матрицы и столбца другой матрицы (см. иллюстрацию вверху этого раздела). Для матричного умножения Y=X*W одним элементом результата будет:

Y[2,0] = X[2,0]*W[0,0] + X[2,1]*W[1,0] + X[2,2]*W[2,0] + ... + X[2,n]*W[n,0]

На графическом процессоре можно было бы запрограммировать это скалярное произведение в «ядро» графического процессора, а затем выполнить его на таком количестве «ядер», которое доступно параллельно, чтобы попытаться вычислить каждое значение результирующей матрицы одновременно. Если результирующая матрица имеет размер 128x128, для этого потребуется наличие 128x128 = 16 КБ «ядер», что обычно невозможно. Самые большие графические процессоры имеют около 4000 ядер. С другой стороны, TPU использует минимум аппаратного обеспечения для вычислительных блоков в MXU: просто bfloat16 x bfloat16 => float32 умножительные аккумуляторы, и ничего больше. Они настолько малы, что TPU может реализовать 16 КБ из них в MXU 128x128 и обработать умножение матриц за один раз.

Иллюстрация: систолическая диаграмма MXU. Вычислительные элементы представляют собой многократные аккумуляторы. В массив загружаются значения одной матрицы (красные точки). Значения другой матрицы проходят через массив (серые точки). Вертикальные линии распространяют значения вверх. Горизонтальные линии распространяют частичные суммы. Пользователю остается в качестве упражнения проверить, что по мере прохождения данных через массив вы получаете результат умножения матрицы, выходящий из правой части.

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

Облачный ТПУ

Когда вы запрашиваете один « Cloud TPU v2» на Google Cloud Platform, вы получаете виртуальную машину (ВМ) с платой TPU, подключенной к PCI. Плата TPU имеет четыре двухъядерных чипа TPU. Каждое ядро ​​TPU оснащено VPU (блок векторной обработки) и MXU 128x128 (блок умножения MatriX). Этот «Облачный TPU» затем обычно подключается через сеть к виртуальной машине, которая его запросила. Итак, полная картина выглядит так:

Иллюстрация: ваша виртуальная машина с сетевым ускорителем Cloud TPU. Сам «Облачный TPU» состоит из виртуальной машины с подключенной к PCI платой TPU с четырьмя двухъядерными чипами TPU.

капсулы ТПУ

В центрах обработки данных Google TPU подключены к межсоединению высокопроизводительных вычислений (HPC), благодаря чему они могут выглядеть как один очень большой ускоритель. Google называет их модулями, и они могут включать в себя до 512 ядер TPU v2 или 2048 ядер TPU v3.

Иллюстрация: модуль TPU v3. Платы и стойки TPU подключаются через межсоединение HPC.

Во время обучения градиенты обмениваются между ядрами TPU с использованием алгоритма all-reduce ( хорошее объяснение all-reduce здесь ). Обучаемая модель может воспользоваться преимуществами аппаратного обеспечения при обучении на больших размерах пакетов.

Иллюстрация: синхронизация градиентов во время обучения с использованием алгоритма полного сокращения в двухмерной тороидальной сети высокопроизводительных вычислений Google TPU.

Программное обеспечение

Обучение в больших объемах

Идеальный размер пакета для TPU — 128 элементов данных на ядро ​​TPU, но оборудование уже может демонстрировать хорошее использование 8 элементов данных на ядро ​​TPU. Помните, что один Cloud TPU имеет 8 ядер.

В этой лаборатории кода мы будем использовать Keras API. В Keras указанный вами пакет является глобальным размером пакета для всего TPU. Ваши пакеты будут автоматически разделены на 8 и запущены на 8 ядрах TPU.

Дополнительные советы по производительности см. в Руководстве по производительности TPU . При очень больших размерах партий в некоторых моделях может потребоваться особая осторожность, более подробную информацию см. в разделе LARSOptimizer .

Под капотом: XLA.

Программы Tensorflow определяют графы вычислений. TPU не запускает код Python напрямую, он запускает граф вычислений, определенный вашей программой Tensorflow. Под капотом компилятор под названием XLA (ускоренный компилятор линейной алгебры) преобразует граф вычислительных узлов Tensorflow в машинный код TPU. Этот компилятор также выполняет множество расширенных оптимизаций вашего кода и структуры памяти. Компиляция происходит автоматически по мере отправки работы в TPU. Вам не обязательно явно включать XLA в цепочку сборки.

Иллюстрация: для работы на TPU граф вычислений, определенный вашей программой Tensorflow, сначала преобразуется в представление XLA (ускоренный компилятор линейной алгебры), а затем компилируется XLA в машинный код TPU.

Использование TPU в Keras

TPU поддерживаются через Keras API, начиная с Tensorflow 2.1. Поддержка Keras работает на TPU и модулях TPU. Вот пример, который работает на TPU, графических процессорах и процессоре:

try: # detect TPUs
    tpu = tf.distribute.cluster_resolver.TPUClusterResolver.connect()
    strategy = tf.distribute.TPUStrategy(tpu)
except ValueError: # detect GPUs
    strategy = tf.distribute.MirroredStrategy() # for CPU/GPU or multi-GPU machines

# use TPUStrategy scope to define model
with strategy.scope():
  model = tf.keras.Sequential( ... )
  model.compile( ... )

# train model normally on a tf.data.Dataset
model.fit(training_dataset, epochs=EPOCHS, steps_per_epoch=...)

В этом фрагменте кода:

• TPUClusterResolver().connect() находит TPU в сети. Он работает без параметров в большинстве облачных систем Google (задания платформы AI, Colaboratory, Kubeflow, виртуальные машины глубокого обучения, созданные с помощью утилиты «ctpu up»). Эти системы знают, где находится их TPU, благодаря переменной среды TPU_NAME. Если вы создаете TPU вручную, либо установите окружение TPU_NAME. вар. на виртуальной машине, из которой вы его используете, или вызовите TPUClusterResolver с явными параметрами: TPUClusterResolver(tp_uname, zone, project)
• TPUStrategy — это часть, которая реализует распределение и алгоритм синхронизации градиента «все-сокращение».
• Стратегия применяется через область видимости. Модель должна быть определена в области действия стратегии().
• Функция tpu_model.fit ожидает объект tf.data.Dataset для ввода для обучения TPU.

Распространенные задачи портирования TPU

• Хотя существует множество способов загрузки данных в модель Tensorflow, для TPU требуется использование API tf.data.Dataset .
• TPU очень быстрые, и прием данных часто становится узким местом при работе на них. В Руководстве по производительности TPU есть инструменты, которые можно использовать для обнаружения узких мест в данных, а также другие советы по производительности.
• Числа int8 или int16 обрабатываются как int32. TPU не имеет целочисленного оборудования, работающего с разрядностью менее 32 бит.
• Некоторые операции Tensorflow не поддерживаются. Список здесь . Хорошей новостью является то, что это ограничение применимо только к обучающему коду, то есть к прямому и обратному проходу через вашу модель. Вы по-прежнему можете использовать все операции Tensorflow в конвейере ввода данных, поскольку они будут выполняться на ЦП.
• tf.py_func не поддерживается в TPU.

4. Загрузка данных

Мы будем работать с набором данных изображений цветов. Цель состоит в том, чтобы научиться разделять их на 5 типов цветов. Загрузка данных осуществляется с помощью API tf.data.Dataset . Для начала давайте познакомимся с API.

Практический

Откройте следующую записную книжку, заполните ячейки (Shift-ENTER) и следуйте инструкциям везде, где вы видите надпись «ТРЕБУЕТСЯ РАБОТА».

Fun with tf.data.Dataset (playground).ipynb

Дополнительная информация

О наборе данных «цветы»

Набор данных организован в 5 папках. В каждой папке собраны цветы одного вида. Папки названы подсолнухи, ромашки, одуванчики, тюльпаны и розы. Данные размещаются в общедоступном сегменте Google Cloud Storage. Отрывок:

gs://flowers-public/sunflowers/5139971615_434ff8ed8b_n.jpg
gs://flowers-public/daisy/8094774544_35465c1c64.jpg
gs://flowers-public/sunflowers/9309473873_9d62b9082e.jpg
gs://flowers-public/dandelion/19551343954_83bb52f310_m.jpg
gs://flowers-public/dandelion/14199664556_188b37e51e.jpg
gs://flowers-public/tulips/4290566894_c7f061583d_m.jpg
gs://flowers-public/roses/3065719996_c16ecd5551.jpg
gs://flowers-public/dandelion/8168031302_6e36f39d87.jpg
gs://flowers-public/sunflowers/9564240106_0577e919da_n.jpg
gs://flowers-public/daisy/14167543177_cd36b54ac6_n.jpg

Почему tf.data.Dataset?

Keras и Tensorflow принимают наборы данных во всех своих функциях обучения и оценки. После загрузки данных в набор данных API предлагает все общие функции, полезные для данных обучения нейронной сети:

dataset = ... # load something (see below)
dataset = dataset.shuffle(1000) # shuffle the dataset with a buffer of 1000
dataset = dataset.cache() # cache the dataset in RAM or on disk
dataset = dataset.repeat() # repeat the dataset indefinitely
dataset = dataset.batch(128) # batch data elements together in batches of 128
AUTOTUNE = tf.data.AUTOTUNE
dataset = dataset.prefetch(AUTOTUNE) # prefetch next batch(es) while training

Советы по производительности и рекомендации по работе с наборами данных можно найти в этой статье . Справочная документация находится здесь .

tf.data.Основы набора данных

Данные обычно поставляются в нескольких файлах, в данном случае в изображениях. Вы можете создать набор данных имен файлов, вызвав:

filenames_dataset = tf.data.Dataset.list_files('gs://flowers-public/*/*.jpg')
# The parameter is a "glob" pattern that supports the * and ? wildcards.

Затем вы «сопоставляете» функцию с каждым именем файла, которая обычно загружает и декодирует файл в фактические данные в памяти:

def decode_jpeg(filename):
  bits = tf.io.read_file(filename)
  image = tf.io.decode_jpeg(bits)
  return image

image_dataset = filenames_dataset.map(decode_jpeg)
# this is now a dataset of decoded images (uint8 RGB format)

Чтобы перебрать набор данных:

for data in my_dataset:
  print(data)

Наборы данных кортежей

При обучении с учителем набор обучающих данных обычно состоит из пар обучающих данных и правильных ответов. Чтобы обеспечить это, функция декодирования может возвращать кортежи. После этого у вас будет набор данных кортежей, и кортежи будут возвращены при его итерации. Возвращаемые значения представляют собой тензоры Tensorflow, готовые к использованию вашей моделью. Вы можете вызвать для них .numpy() , чтобы увидеть необработанные значения:

def decode_jpeg_and_label(filename):
  bits = tf.read_file(filename)
  image = tf.io.decode_jpeg(bits)
  label = ... # extract flower name from folder name
  return image, label

image_dataset = filenames_dataset.map(decode_jpeg_and_label)
# this is now a dataset of (image, label) pairs 

for image, label in dataset:
  print(image.numpy().shape, label.numpy())

Вывод: загрузка изображений по одному происходит медленно!

По мере обработки этого набора данных вы увидите, что можете загружать примерно 1–2 изображения в секунду. Это слишком медленно! Аппаратные ускорители, которые мы будем использовать для обучения, могут выдержать во много раз большую скорость. Перейдите в следующий раздел, чтобы узнать, как мы этого достигнем.

Решение

Вот блокнот с решением. Вы можете использовать его, если застряли.

Fun with tf.data.Dataset (solution).ipynb

Что мы рассмотрели

• 🤔 tf.data.Dataset.list_files
• 🤔 tf.data.Dataset.map
• 🤔 Наборы данных кортежей
• 😀 перебор наборов данных

Пожалуйста, найдите время и прокрутите этот контрольный список в уме.

5. Быстрая загрузка данных

Аппаратные ускорители Tensor Processing Unit (TPU), которые мы будем использовать в этой лабораторной работе, очень быстрые. Зачастую задача состоит в том, чтобы предоставить им данные достаточно быстро, чтобы они были заняты. Облачное хранилище Google (GCS) способно поддерживать очень высокую пропускную способность, но, как и во всех системах облачного хранения, инициирование соединения требует затрат сети туда и обратно. Поэтому хранить наши данные в тысячах отдельных файлов не идеально. Мы собираемся объединить их в меньшее количество файлов и использовать возможности tf.data.Dataset для параллельного чтения из нескольких файлов.

Чтение

Код, который загружает файлы изображений, изменяет их размер до стандартного размера, а затем сохраняет их в 16 файлах TFRecord, находится в следующем блокноте. Пожалуйста, быстро прочтите его. Выполнять его необязательно, поскольку данные в правильном формате TFRecord будут предоставлены для остальной части кодовой лаборатории.

Flower pictures to TFRecords.ipynb

Идеальное расположение данных для оптимальной пропускной способности GCS

Эмпирическое правило состоит в том, чтобы разделить ваши данные на несколько (от 10 до 100) больших файлов (от 10 до 100 МБ). Если у вас слишком много файлов, например, тысячи файлов, время на доступ к каждому файлу может начать мешать. Если у вас слишком мало файлов, например один или два, вы не получите преимуществ параллельной потоковой передачи из нескольких файлов.

Формат файла TFRecord

Предпочтительным форматом файлов Tensorflow для хранения данных является формат TFRecord на основе protobuf . Другие форматы сериализации тоже подойдут, но вы можете загрузить набор данных из файлов TFRecord напрямую, написав:

filenames = tf.io.gfile.glob(FILENAME_PATTERN)
dataset = tf.data.TFRecordDataset(filenames)
dataset = dataset.map(...) # do the TFRecord decoding here - see below

Для оптимальной производительности рекомендуется использовать следующий более сложный код для одновременного чтения из нескольких файлов TFRecord. Этот код будет читать N файлов параллельно и игнорировать порядок данных в пользу скорости чтения.

AUTOTUNE = tf.data.AUTOTUNE
ignore_order = tf.data.Options()
ignore_order.experimental_deterministic = False

filenames = tf.io.gfile.glob(FILENAME_PATTERN)
dataset = tf.data.TFRecordDataset(filenames, num_parallel_reads=AUTOTUNE)
dataset = dataset.with_options(ignore_order)
dataset = dataset.map(...) # do the TFRecord decoding here - see below

Шпаргалка по TFRecord

В TFRecords можно хранить три типа данных: байтовые строки (список байтов), 64-битные целые числа и 32-битные числа с плавающей запятой . Они всегда сохраняются в виде списков, один элемент данных будет списком размером 1. Вы можете использовать следующие вспомогательные функции для хранения данных в TFRecords.

запись байтовых строк

# warning, the input is a list of byte strings, which are themselves lists of bytes
def _bytestring_feature(list_of_bytestrings):
  return tf.train.Feature(bytes_list=tf.train.BytesList(value=list_of_bytestrings))

запись целых чисел

def _int_feature(list_of_ints): # int64
  return tf.train.Feature(int64_list=tf.train.Int64List(value=list_of_ints))

запись поплавков

def _float_feature(list_of_floats): # float32
  return tf.train.Feature(float_list=tf.train.FloatList(value=list_of_floats))

написание TFRecord , используя приведенные выше помощники

# input data in my_img_bytes, my_class, my_height, my_width, my_floats
with tf.python_io.TFRecordWriter(filename) as out_file:
  feature = {
    "image": _bytestring_feature([my_img_bytes]), # one image in the list
    "class": _int_feature([my_class]),            # one class in the list
    "size": _int_feature([my_height, my_width]),  # fixed length (2) list of ints
    "float_data": _float_feature(my_floats)       # variable length  list of floats
  }
  tf_record = tf.train.Example(features=tf.train.Features(feature=feature))
  out_file.write(tf_record.SerializeToString())

Чтобы прочитать данные из TFRecords, вы должны сначала объявить структуру сохраненных вами записей. В объявлении вы можете получить доступ к любому именованному полю как к списку фиксированной длины или списку переменной длины:

чтение из TFRecords

def read_tfrecord(data):
  features = {
    # tf.string = byte string (not text string)
    "image": tf.io.FixedLenFeature([], tf.string), # shape [] means scalar, here, a single byte string
    "class": tf.io.FixedLenFeature([], tf.int64),  # shape [] means scalar, i.e. a single item
    "size": tf.io.FixedLenFeature([2], tf.int64),  # two integers
    "float_data": tf.io.VarLenFeature(tf.float32)  # a variable number of floats
  }

  # decode the TFRecord
  tf_record = tf.io.parse_single_example(data, features)

  # FixedLenFeature fields are now ready to use
  sz = tf_record['size']

  # Typical code for decoding compressed images
  image = tf.io.decode_jpeg(tf_record['image'], channels=3)

  # VarLenFeature fields require additional sparse.to_dense decoding
  float_data = tf.sparse.to_dense(tf_record['float_data'])

  return image, sz, float_data

# decoding a tf.data.TFRecordDataset
dataset = dataset.map(read_tfrecord)
# now a dataset of triplets (image, sz, float_data)

Полезные фрагменты кода:

чтение отдельных элементов данных

tf.io.FixedLenFeature([], tf.string)   # for one byte string
tf.io.FixedLenFeature([], tf.int64)    # for one int
tf.io.FixedLenFeature([], tf.float32)  # for one float

чтение списков элементов фиксированного размера

tf.io.FixedLenFeature([N], tf.string)   # list of N byte strings
tf.io.FixedLenFeature([N], tf.int64)    # list of N ints
tf.io.FixedLenFeature([N], tf.float32)  # list of N floats

чтение переменного количества элементов данных

tf.io.VarLenFeature(tf.string)   # list of byte strings
tf.io.VarLenFeature(tf.int64)    # list of ints
tf.io.VarLenFeature(tf.float32)  # list of floats

VarLenFeature возвращает разреженный вектор, и после декодирования TFRecord требуется дополнительный шаг:

dense_data = tf.sparse.to_dense(tf_record['my_var_len_feature'])

Также возможно иметь необязательные поля в TFRecords. Если вы укажете значение по умолчанию при чтении поля, то вместо ошибки будет возвращено значение по умолчанию, если поле отсутствует.

tf.io.FixedLenFeature([], tf.int64, default_value=0) # this field is optional

Что мы рассмотрели

• 🤔 сегментирование файлов данных для быстрого доступа из GCS
• 😓 как писать TFRecords. (Вы уже забыли синтаксис? Ничего страшного, добавьте эту страницу в закладки как шпаргалку)
• 🤔 загрузка набора данных из TFRecords с помощью TFRecordDataset

Пожалуйста, найдите время и прокрутите этот контрольный список в уме.

6. Поздравляем!

Теперь вы можете снабдить TPU данными. Пожалуйста, перейдите в следующую лабораторию.

• [ЭТА ЛАБОРАТОРНАЯ ЛАБОРАТОРИЯ] Конвейеры данных со скоростью TPU: tf.data.Dataset и TFRecords
• Ваша первая модель Keras с трансферным обучением
• Сверточные нейронные сети с Keras и TPU
• Современные сети, сжимающие сети, Xception, с Keras и TPU.

ТПУ на практике

TPU и графические процессоры доступны на платформе Cloud AI :

• На виртуальных машинах глубокого обучения
• В ноутбуках на платформе AI
• Вакансии по обучению платформам искусственного интеллекта

Наконец, мы любим обратную связь. Пожалуйста, сообщите нам, если вы заметили в этой лаборатории что-то не так или считаете, что ее следует улучшить. Обратная связь может быть предоставлена ​​через вопросы GitHub [ ссылка обратной связи ].

Автор: Мартин Гёрнер Твиттер: @martin_gorner