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

1. Обзор

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

Эта лабораторная работа — часть 1 серии "Keras на TPU". Вы можете выполнять их в указанном порядке или по отдельности.

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

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

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

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

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

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

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

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

Welcome to Colab.ipynb

Выберите бэкэнд TPU.

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

Выполнение блокнота

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

Оглавление

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

Скрытые клетки

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

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

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

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

В двух словах

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

Код для обучения модели на TPU в Keras (с возможностью переключения на GPU или CPU, если 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 ).

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

MXU и VPU

Ядро 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]

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

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

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

Облачный TPU

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

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

TPU-капсулы

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

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

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

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

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

Обучение в больших группах

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

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

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

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

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

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

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

Начиная с TensorFlow 2.1, поддержка TPU осуществляется через API Keras. Keras работает как с TPU, так и с TPU-подами. Вот пример, работающий на TPU, GPU(ах) и CPU:

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 Cloud (задания AI Platform, Colaboratory, Kubeflow, виртуальные машины глубокого обучения, созданные с помощью утилиты 'ctpu up'). Эти системы знают, где находится их TPU, благодаря переменной среды TPU_NAME. Если вы создаете TPU вручную, либо установите переменную среды TPU_NAME на виртуальной машине, с которой вы его используете, либо вызовите TPUClusterResolver с явными параметрами: TPUClusterResolver(tp_uname, zone, project)
• TPUStrategy — это часть, реализующая распределение и алгоритм синхронизации градиентов "all-reduce".
• Стратегия применяется через область видимости. Модель должна быть определена внутри области видимости стратегии (scope()).
• Функция tpu_model.fit ожидает в качестве входных данных для обучения на TPU объект tf.data.Dataset.

Типичные задачи портирования 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 принимают наборы данных (Dataset) во всех своих функциях обучения и оценки. После загрузки данных в набор данных 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.Dataset

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

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 Cloud Storage (GCS) способен поддерживать очень высокую пропускную способность, но, как и во всех облачных системах хранения, установление соединения требует некоторого обмена данными по сети. Поэтому хранение наших данных в виде тысяч отдельных файлов не является оптимальным вариантом. Мы будем объединять их в меньшее количество файлов и использовать возможности tf.data.Dataset для параллельного чтения из нескольких файлов.

Прочтение до конца

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

Flower pictures to TFRecords.ipynb

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

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

Формат файла 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.
• Современные сверточные сети, SqueezeNet, Xception, Keras и TPU.

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

TPU и GPU доступны на платформе Cloud AI Platform :

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

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

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