Как в tensoboard прочитать файл
Перейти к содержимому

Как в tensoboard прочитать файл

  • автор:

5) Tensorboard Tutorial

Tensorboard – это интерфейс, используемый для визуализации графика и других инструментов для понимания, отладки и оптимизации модели.

пример

Изображение ниже взято из графика, который вы создадите в этом уроке. Это основная панель:

На картинке ниже вы можете увидеть панель Tensorboard. Панель содержит различные вкладки, которые связаны с уровнем информации, которую вы добавляете при запуске модели.

  • Скаляры: показать различную полезную информацию во время обучения модели
  • Графики: показать модель
  • Гистограмма: отображение весов с помощью гистограммы
  • Распределение: Показать распределение веса
  • Проектор: Показать анализ главных компонентов и алгоритм T-SNE. Техника использует для уменьшения размерности

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

Если вы посмотрите на график, вы сможете понять, как работает модель.

  1. Поставьте данные в модель: добавьте количество данных, равное размеру пакета, в модель, т. Е. Количество подачи данных после каждой итерации
  2. Подайте данные на Тензор
  3. Тренируй модель
  4. Показать количество партий во время тренировки. Сохраните модель на диске.

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

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

Чтобы дать вам представление о том, насколько полезным может быть график, посмотрите на рисунок ниже:

Нейронная сеть решает, как соединить различные «нейроны» и сколько слоев до модели может предсказать результат. После того как вы определили архитектуру, вам нужно не только обучать модель, но и метрики для вычисления точности прогноза. Этот показатель называется функцией потерь. Цель состоит в том, чтобы минимизировать функцию потерь. Другими словами, это означает, что модель делает меньше ошибок. Все алгоритмы машинного обучения будут повторять вычисления много раз, пока потери не достигнут более плоской линии. Чтобы минимизировать эту функцию потерь, вам нужно определить скорость обучения. это скорость вы хотите, чтобы модель учиться. Если вы установите слишком высокую скорость обучения, модель не успеет что-либо изучить. Это случай на левой картинке. Линия движется вверх и вниз, а это означает, что модель предсказывает с чистым предположением результат. Рисунок справа показывает, что потери уменьшаются в течение итерации, пока кривая не станет плоской, что означает, что модель нашла решение.

TensorBoard – отличный инструмент для визуализации таких метрик и выявления потенциальных проблем. Нейронная сеть может занять часы или недели, прежде чем они найдут решение. TensorBoard обновляет метрики очень часто. В этом случае вам не нужно ждать до конца, чтобы убедиться, что модель тренируется правильно. Вы можете открыть TensorBoard, проверить ход обучения и внести соответствующие изменения, если это необходимо.

Как использовать TensorBoard?

В этом руководстве вы узнаете, как открыть TensorBoard из терминала для MacOS и из командной строки для Windows.

Код будет объяснен в следующем уроке, основное внимание здесь уделено TensorBoard.

Во-первых, вам нужно импортировать библиотеки, которые вы будете использовать во время обучения

## Import the library import tensorflow as tf import numpy as np

Вы создаете данные. Это массив из 10000 строк и 5 столбцов

X_train = (np.random.sample((10000,5))) y_train = (np.random.sample((10000,1))) X_train.shape

Вывод 

(10000, 5)

Приведенные ниже коды преобразуют данные и создают модель.

Обратите внимание, что скорость обучения равна 0,1. Если вы измените эту скорость на более высокое значение, модель не найдет решение. Это то, что произошло на левой стороне рисунка выше.

В большинстве учебников по TensorFlow вы будете использовать оценщик TensorFlow. Это TensorFlow API, который содержит все математические вычисления.

Чтобы создать файлы журнала, вам нужно указать путь. Это делается с помощью аргумента model_dir.

В приведенном ниже примере вы храните модель в рабочем каталоге, то есть там, где вы храните записную книжку или файл python. Внутри этого пути TensorFlow создаст папку с именем train с именем дочерней папки linreg.

feature_columns = [ tf.feature_column.numeric_column('x', shape=X_train.shape[1:])] DNN_reg = tf.estimator.DNNRegressor(feature_columns=feature_columns, # Indicate where to store the log file model_dir='train/linreg', hidden_units=[500, 300], optimizer=tf.train.ProximalAdagradOptimizer( learning_rate=0.1, l1_regularization_strength=0.001 ) )

Вывод 

INFO:tensorflow:Using default config. INFO:tensorflow:Using config: , '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1>

Последний шаг состоит в обучении модели. Во время обучения TensorFlow записывает информацию в каталог моделей.

# Train the estimator train_input = tf.estimator.inputs.numpy_input_fn( x=, y=y_train, shuffle=False,num_epochs=None) DNN_reg.train(train_input,steps=3000)

Вывод

INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Create CheckpointSaverHook. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Saving checkpoints for 1 into train/linreg/model.ckpt. INFO:tensorflow:loss = 40.060104, step = 1 INFO:tensorflow:global_step/sec: 197.061 INFO:tensorflow:loss = 10.62989, step = 101 (0.508 sec) INFO:tensorflow:global_step/sec: 172.487 INFO:tensorflow:loss = 11.255318, step = 201 (0.584 sec) INFO:tensorflow:global_step/sec: 193.295 INFO:tensorflow:loss = 10.604872, step = 301 (0.513 sec) INFO:tensorflow:global_step/sec: 175.378 INFO:tensorflow:loss = 10.090343, step = 401 (0.572 sec) INFO:tensorflow:global_step/sec: 209.737 INFO:tensorflow:loss = 10.057928, step = 501 (0.476 sec) INFO:tensorflow:global_step/sec: 171.646 INFO:tensorflow:loss = 10.460144, step = 601 (0.583 sec) INFO:tensorflow:global_step/sec: 192.269 INFO:tensorflow:loss = 10.529617, step = 701 (0.519 sec) INFO:tensorflow:global_step/sec: 198.264 INFO:tensorflow:loss = 9.100082, step = 801 (0.504 sec) INFO:tensorflow:global_step/sec: 226.842 INFO:tensorflow:loss = 10.485607, step = 901 (0.441 sec) INFO:tensorflow:global_step/sec: 152.929 INFO:tensorflow:loss = 10.052481, step = 1001 (0.655 sec) INFO:tensorflow:global_step/sec: 166.745 INFO:tensorflow:loss = 11.320213, step = 1101 (0.600 sec) INFO:tensorflow:global_step/sec: 161.854 INFO:tensorflow:loss = 9.603306, step = 1201 (0.619 sec) INFO:tensorflow:global_step/sec: 179.074 INFO:tensorflow:loss = 11.110269, step = 1301 (0.556 sec) INFO:tensorflow:global_step/sec: 202.776 INFO:tensorflow:loss = 11.929443, step = 1401 (0.494 sec) INFO:tensorflow:global_step/sec: 144.161 INFO:tensorflow:loss = 11.951693, step = 1501 (0.694 sec) INFO:tensorflow:global_step/sec: 154.144 INFO:tensorflow:loss = 8.620987, step = 1601 (0.649 sec) INFO:tensorflow:global_step/sec: 151.094 INFO:tensorflow:loss = 10.666125, step = 1701 (0.663 sec) INFO:tensorflow:global_step/sec: 193.644 INFO:tensorflow:loss = 11.0349865, step = 1801 (0.516 sec) INFO:tensorflow:global_step/sec: 189.707 INFO:tensorflow:loss = 9.860596, step = 1901 (0.526 sec) INFO:tensorflow:global_step/sec: 176.423 INFO:tensorflow:loss = 10.695, step = 2001 (0.567 sec) INFO:tensorflow:global_step/sec: 213.066 INFO:tensorflow:loss = 10.426752, step = 2101 (0.471 sec) INFO:tensorflow:global_step/sec: 220.975 INFO:tensorflow:loss = 10.594796, step = 2201 (0.452 sec) INFO:tensorflow:global_step/sec: 219.289 INFO:tensorflow:loss = 10.4212265, step = 2301 (0.456 sec) INFO:tensorflow:global_step/sec: 215.123 INFO:tensorflow:loss = 9.668612, step = 2401 (0.465 sec) INFO:tensorflow:global_step/sec: 175.65 INFO:tensorflow:loss = 10.009649, step = 2501 (0.569 sec) INFO:tensorflow:global_step/sec: 206.962 INFO:tensorflow:loss = 10.477722, step = 2601 (0.483 sec) INFO:tensorflow:global_step/sec: 229.627 INFO:tensorflow:loss = 9.877638, step = 2701 (0.435 sec) INFO:tensorflow:global_step/sec: 195.792 INFO:tensorflow:loss = 10.274586, step = 2801 (0.512 sec) INFO:tensorflow:global_step/sec: 176.803 INFO:tensorflow:loss = 10.061047, step = 2901 (0.566 sec) INFO:tensorflow:Saving checkpoints for 3000 into train/linreg/model.ckpt. INFO:tensorflow:Loss for final step: 10.73032.

Для пользователей MacOS

Для пользователей Windows

Вы можете увидеть эту информацию в TensorBoard.

Теперь, когда у вас есть записанные события журнала, вы можете открыть Tensorboard. Tensorboad работает на порту 6006 (Jupyter работает на порту 8888). Вы можете использовать пользователя Terminal for MacOs или приглашение Anaconda для пользователя Windows.

Для пользователей MacOS 

# Different for you cd /Users/Guru99/tuto_TF source activate hello-tf!

Записная книжка хранится в пути / Users / Guru99 / tuto_TF

Для пользователей Windows 

cd C:\Users\Admin\Anaconda3 activate hello-tf

Записная книжка хранится в пути C: \ Users \ Admin \ Anaconda3

Для запуска Tensorboard вы можете использовать этот код

Для пользователей MacOS 

tensorboard --logdir=./train/linreg

Для пользователей Windows 

tensorboard --logdir=.\train\linreg

Tensorboard находится в этом URL: http: // localhost: 6006

Он также может быть расположен в следующем месте.

Скопируйте и вставьте URL в ваш любимый браузер. Вы должны увидеть это:

Обратите внимание, что мы научимся читать граф в учебнике, посвященном глубокому обучению.

Если вы видите что-то вроде этого:

Это означает, что Tensorboard не может найти файл журнала. Убедитесь, что вы указали правильный путь на компакт-диске, или дважды проверьте, было ли создано событие журнала. Если нет, перезапустите код.

Если вы хотите закрыть TensorBoard Нажмите CTRL + C

Полезный совет: проверьте в своем анаконде приглашение на текущий рабочий каталог,

Файл журнала должен быть создан в C: \ Users \ Admin

Резюме:

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

Чтобы активировать Tensorboard, вам нужно указать путь к вашему файлу:

cd /Users/Guru99/tuto_TF

Активировать среду Tensorflow

activate hello-tf
tensorboard --logdir=.+ PATH

Tensorflow – чтение файлов

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

Есть несколько функций и опций из стандартной библиотеки Python, которые вы можете использовать для решения этой задачи.

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

В этой статье мы рассмотрим основы чтения CSV-файла при помощи TensorFlow и использования этих данных в ваших графах.

Placeholder-ы

Самый простой способ чтения данных — просто прочитать их при помощи стандартного кода на Python. Давайте рассмотрим базовый пример и прочитаем данные из файла олимпийских игр 2016 года.

Первое, что мы сделаем, это создадим граф, который берет одну строку данных за другой и суммирует общие медали.

 import tensorflow as tf import urllib2, cStringIO # URL csv файла URL = 'https://storage.dev-ops-notes.ru/The_2016_Olympic_Games_medal.csv' # Установим Uset-Agent и скачаем файл opener = urllib2.build_opener() opener.addheaders = [('User-Agent', 'Mozilla/5.0')] response = opener.open(URL) # читаем содержимое csv файла buf = cStringIO.StringIO(response.read()) # определяем placeholder-ы # тензор, содержащий данные (gold, silver, bronze) для расчета features = tf.placeholder(tf.int32, shape=[3], name='features') # тензор, содержащий название страны country = tf.placeholder(tf.string, name='country') # операция расчета (в нашем случае суммирования тензора с данными) total = tf.reduce_sum(features, name='total')

Далее определим новую операцию tf.Print(), которая будет суммировать и печатать общий результат сложения всех медалей (features).

printerop = tf.Print(total, [country, features, total], name='printer')

Что происходит, когда мы используем printerop? Эта переменная ссылается на функцию, которая регистрирует текущие значения, переданные ей во втором параметре (в данном случае список [country, features, total]) и возвращает их сумму, применяя к этому списку операцию total. Далее мы открываем сеанс для расчетов графа, открываем файл для чтения и передаем строки из файла функции printerop строка за строкой. Обратите внимание, что чтение файла выполняется исключительно средствами Python во время расчетов в сеансе.

 line_count = 0 with tf.Session() as sess: sess.run( tf.global_variables_initializer()) while True: line = buf.readline().strip() if len(line) == 0: break if line_count == 0: # пропустим заголовок cvs файла line_count += 1 continue # Читаем данные для расчета, используя python, в переменную TensorFlow с именем features country_name, code, gold, silver, bronze, total = line.strip().split(",") gold = int(gold) silver = int(silver) bronze = int(bronze) # Вызываем функцию Print, которая делает всю работу total = sess.run(printerop, feed_dict=) print(country_name, total) line_count += 1

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

TensorFlow-Reading-files-CVS-Example-1.png

Внутри цикла мы читаем файла файл построчно, разделяем каждую строку на элементы до каждой запятой, преобразуем значения в целые числа и затем передаем данные в файл feed_dict в качестве значений для placeholder-а.

При каждом вызове printerop в лог TensorFlow будет попадать строка вида, содержащая лог операции:

 I tensorflow/core/kernels/logging_ops.cc:79] [\"France\"][10 18 14][42]

Результат же самой операции будет печататься на стандартный поток вывода функцией print (country_name, total), которая печатает текущее имя страны из Python переменной и результат работы printerop (сумма золотых, серебряных и бронзовых медалей).

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

Чтение csv файлов в Tensorflow

TensorFlow поддерживает и непосредственное считывание данных в тензоры, однако работать с CSV форматом далеко не всегда удобно и приятно. Тем не менее, т.к. это довольно частый сценарий, давайте рассмотрим один из множества способ сделать это.

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

 def file_reader_func(filename_queue): reader = tf.TextLineReader(skip_header_lines=1) _, csv_row = reader.read(filename_queue) record_defaults = [[""], [""], [0], [0], [0], [0]] country, code, gold, silver, bronze, total = tf.decode_csv(csv_row, record_defaults=record_defaults) features = tf.pack([gold, silver, bronze]) return features, country

Функция file_reader_func здесь принимает объект очереди, а не обычный список Python, поэтому нам нужно создать его перед тем, как передавать его в нашу функцию:

 filename_queue = tf.train.string_input_producer(filenames, num_epochs=1, shuffle=False) example, country = file_reader_func(filename_queue)

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

 with tf.Session() as sess: tf.global_variables_initializer().run() coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(coord=coord) while True: try: example_data, country_name = sess.run([example, country]) print(example_data, country_name) except tf.errors.OutOfRangeError: break

Цикл while будет обходить данные до тех пор, пока у нас не останется данных и не возникнет исключение OutOfRangeError.

При помощи этого кода мы теперь можем получить по одной строки из нашего набора данных и загружать их прямо в наш граф для последующей обработки. Существуют и другие функции для получения порций данных и их перемешивания (см. описание функций tf.train.string_input_producer и tf.train.shuffle_batch).

Краткое руководство по TensorFlow 2 для начинающих

Оптимизируйте свои подборки Сохраняйте и классифицируйте контент в соответствии со своими настройками.

Это краткое введение использует Keras для:

  1. Загрузите готовый набор данных.
  2. Создайте модель машинного обучения нейронной сети, которая классифицирует изображения.
  3. Обучите эту нейронную сеть.
  4. Оцените точность модели.

Это руководство представляет собой записную книжку Google Colaboratory . Программы на Python запускаются непосредственно в браузере — отличный способ изучить и использовать TensorFlow. Чтобы следовать этому руководству, запустите блокнот в Google Colab, нажав кнопку в верхней части этой страницы.

  1. В Colab подключитесь к среде выполнения Python: в правом верхнем углу строки меню выберите ПОДКЛЮЧИТЬСЯ .
  2. Запустите все ячейки кода записной книжки. Выберите « Среда выполнения » > « Выполнить все» .

Настроить TensorFlow.

Импортируйте TensorFlow в свою программу, чтобы начать:

import tensorflow as tf print("TensorFlow version:", tf.__version__) 
TensorFlow version: 2.8.0-rc1

Если вы используете собственную среду разработки, а не Colab , см. руководство по установке для настройки TensorFlow для разработки.

Примечание. Убедитесь, что вы выполнили обновление до последней версии пакета pip 2, если вы используете собственную среду разработки. Подробнее см. в руководстве по установке .

Загрузите набор данных

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

mnist = tf.keras.datasets.mnist (x_train, y_train), (x_test, y_test) = mnist.load_data() x_train, x_test = x_train / 255.0, x_test / 255.0

Построить модель машинного обучения

Создайте модель tf.keras.Sequential путем наложения слоев.

model = tf.keras.models.Sequential([ tf.keras.layers.Flatten(input_shape=(28, 28)), tf.keras.layers.Dense(128, activation='relu'), tf.keras.layers.Dropout(0.2), tf.keras.layers.Dense(10) ])

Для каждого примера модель возвращает вектор оценок логитов или логарифмических шансов , по одному для каждого класса.

predictions = model(x_train[:1]).numpy() predictions 
array([[ 0.2760778 , -0.39324787, -0.17098302, 1.2016621 , -0.03416392, 0.5461229 , -0.7203061 , -0.41886678, -0.59480035, -0.7580608 ]], dtype=float32)

Функция tf.nn.softmax преобразует эти логиты в вероятности для каждого класса:

tf.nn.softmax(predictions).numpy() 
array([[0.11960829, 0.06124588, 0.0764901 , 0.30181262, 0.08770514, 0.15668967, 0.04416083, 0.05969675, 0.05006609, 0.04252464]], dtype=float32)

Примечание. Можно встроить функцию tf.nn.softmax в функцию активации для последнего уровня сети. Хотя это может сделать выходные данные модели более интерпретируемыми, этот подход не рекомендуется, поскольку невозможно обеспечить точный и численно стабильный расчет потерь для всех моделей при использовании выходных данных softmax.

Определите функцию потерь для обучения с использованием losses.SparseCategoricalCrossentropy , которая принимает вектор логитов и индекс True и возвращает скалярную потерю для каждого примера.

loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

Эта потеря равна отрицательной логарифмической вероятности истинного класса: потеря равна нулю, если модель уверена в правильном классе.

Эта необученная модель дает вероятности, близкие к случайным (1/10 для каждого класса), поэтому начальная потеря должна быть близка к -tf.math.log(1/10) ~= 2.3 .

loss_fn(y_train[:1], predictions).numpy() 
1.8534881

Перед началом обучения настройте и скомпилируйте модель с помощью Model.compile . Установите класс optimizer на adam , установите loss на функцию loss_fn , которую вы определили ранее, и укажите метрику, которая будет оцениваться для модели, установив параметр metrics на accuracy .

model.compile(optimizer='adam', loss=loss_fn, metrics=['accuracy'])

Обучите и оцените свою модель

Используйте метод Model.fit , чтобы настроить параметры модели и минимизировать потери:

model.fit(x_train, y_train, epochs=5)

Epoch 1/5 1875/1875 [==============================] — 4s 2ms/step — loss: 0.2950 — accuracy: 0.9143 Epoch 2/5 1875/1875 [==============================] — 3s 2ms/step — loss: 0.1451 — accuracy: 0.9567 Epoch 3/5 1875/1875 [==============================] — 4s 2ms/step — loss: 0.1080 — accuracy: 0.9668 Epoch 4/5 1875/1875 [==============================] — 4s 2ms/step — loss: 0.0906 — accuracy: 0.9717 Epoch 5/5 1875/1875 [==============================] — 4s 2ms/step — loss: 0.0749 — accuracy: 0.9761

Метод Model.evaluate проверяет производительность моделей, обычно на » Validation-set » или » Test-set «.

model.evaluate(x_test, y_test, verbose=2) 
313/313 - 1s - loss: 0.0783 - accuracy: 0.9755 - 588ms/epoch - 2ms/step [0.07825208455324173, 0.9754999876022339]

Классификатор изображений теперь обучен с точностью ~ 98% на этом наборе данных. Чтобы узнать больше, прочитайте туториалы по TensorFlow .

Если вы хотите, чтобы ваша модель возвращала вероятность, вы можете обернуть обученную модель и прикрепить к ней softmax:

probability_model = tf.keras.Sequential([ model, tf.keras.layers.Softmax() ]) 
probability_model(x_test[:5])

Вывод

Поздравляем! Вы обучили модель машинного обучения, используя готовый набор данных с помощью API Keras .

Дополнительные примеры использования Keras см. в туториалах . Чтобы узнать больше о построении моделей с помощью Keras, прочитайте руководства . Если вы хотите узнать больше о загрузке и подготовке данных, см. руководства по загрузке данных изображения или загрузке данных CSV .

Если не указано иное, контент на этой странице предоставляется по лицензии Creative Commons «С указанием авторства 4.0», а примеры кода – по лицензии Apache 2.0. Подробнее об этом написано в правилах сайта. Java – это зарегистрированный товарный знак корпорации Oracle и ее аффилированных лиц.

Последнее обновление: 2022-01-26 UTC.

TFRecord и tf.Example

Note: Вся информация в этом разделе переведена с помощью русскоговорящего Tensorflow сообщества на общественных началах. Поскольку этот перевод не является официальным, мы не гарантируем что он на 100% аккуратен и соответствует официальной документации на английском языке. Если у вас есть предложение как исправить этот перевод, мы будем очень рады увидеть pull request в tensorflow/docs репозиторий GitHub. Если вы хотите помочь сделать документацию по Tensorflow лучше (сделать сам перевод или проверить перевод подготовленный кем-то другим), напишите нам на docs-ru@tensorflow.org list.

Чтобы эффективно читать данные будет полезно сериализовать ваши данные и держать их в наборе файлов (по 100-200MB каждый) каждый из которых может быть прочитан построчно. Это особенно верно если данные передаются по сети. Также это может быть полезно для кеширования и предобработки данных.

Формат TFRecord это простой формат для хранения последовательности двоичных записей.

Protocol buffers это кросс-платформенная, кросс-языковая библиотека для эффективной сериализации структурированных данных.

Сообщения протокола обычно определяются файлами .proto . Это часто простейший способ понять тип сообщения.

Сообщение tf.Example (или protobuf) гибкий тип сообщений, который преедставляет сопоставление . Он разработан для использования с TensorFlow и используется в высокоуровневых APIs таких как TFX.

Этот урок покажет как создавать, парсить и использовать сообщение tf.Example , а затем сериализовать читать и писать сообщения tf.Example в/из файлов .tfrecord .

Замечание: Хотя эти структуры полезны, они необязательны. Нет необходимости конвертировать существующий код для использования TFRecords если вы не используете tf.data и чтение данных все еще узкое место обучения. См. Производительность конвейера входных данных для советов по производительности датасета.

Setup

  
In [ ]:
 
 
 
import tensorflow as tf import numpy as np import IPython.display as display 


tf.Example


Типы данных для tf.Example


Фундаментально tf.Example это соответствие .


Вид сообщений tf.train.Feature допускает один из следующих трех типов (См. файл .proto для справки). Большинство других общих типов может быть сведено к одному из этих трех:


    

  1. tf.train.BytesList (можно привести следующие типы)

      

    • string
      • 

    • byte
      • 

    

    2. 

  2. tf.train.FloatList (можно привести следующие типы)

      

    • float ( float32 )
      • 

    • double ( float64 )
      • 

    

    3. 

  3. tf.train.Int64List (можно привести следующие типы)

      

    • bool
      • 

    • enum
      • 

    • int32
      • 

    • uint32
      • 

    • int64
      • 

    • uint64
      • 

    

    4. 



Чтобы преобразовать стандартный тип TensorFlow в tf.Example -совместимый tf.train.Feature , вы можете использовать приведенные ниже функции. Обратите внимание, что каждая функция принимает на вход скалярное значение и возвращает tf.train.Feature содержащий один из трех вышеприведенных list типов:


  
In [ ]:
 
 
 
# Следующая функция может быть использована чтобы преобразовать значение в тип совместимый с # с tf.Example. def _bytes_feature(value): """Преобразует string / byte в bytes_list.""" if isinstance(value, type(tf.constant(0))): value = value.numpy() # BytesList не будет распаковывать строку из EagerTensor. return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value])) def _float_feature(value): """Преобразует float / double в float_list.""" return tf.train.Feature(float_list=tf.train.FloatList(value=[value])) def _int64_feature(value): """Преобразует bool / enum / int / uint в int64_list.""" return tf.train.Feature(int64_list=tf.train.Int64List(value=[value])) 


Замечание: Для простоты этот пример использует только скалярные входные данные. Простейший способ обработки нескалярных признаков - использование tf.serialize_tensor для конвертации тензоров в двоичнеые строки. Стоки являются скалярами в тензорфлоу. Используйте tf.parse_tensor для обратной конвертации двоичных сток в тензор.


Ниже приведены несколько примеров того как работают эти функции. Обратите внимание на различные типы ввода и стандартизированные типы вывода. Если входной тип функции не совпадает с одним из приводимых типов указанных выше, функция вызовет исключение (например _int64_feature(1.0) выдаст ошибку поскольку 1.0 это значение с плавающей точкой и должно быть использовано с функцией _float_feature ):


  
In [ ]:
 
 
 
print(_bytes_feature(b'test_string')) print(_bytes_feature(u'test_bytes'.encode('utf-8'))) print(_float_feature(np.exp(1))) print(_int64_feature(True)) print(_int64_feature(1)) 


Все proto сообщения могут быть сериализованы в двоичную строку с использованием метода .SerializeToString :


  
In [ ]:
 
 
 
feature = _float_feature(np.exp(1)) feature.SerializeToString() 


Создание сообщения tf.Example


Допустим вы хотите создать сообщение tf.Example из существующих данных. На практике данные могут прийти откуда угодно, но процедура создания сообщения tf.Example из одного наблюдения будет той же:


    

  1. В рамках каждого наблюдения каждое значение должно быть преобразовано в tf.train.Feature содержащее одно из 3 совместимых типов, с использованием одной из вышеприведенных функций.
    2. 

  2. Вы создаете отображение (словарь) из строки названий признаков в закодированное значение признака выполненное на шаге #1.
    3. 

  3. Отображение (map) созданное на шаге 2 конвертируется в Features message.
    4. 



В этом уроке вы создадите датасет с использованием NumPy.








У этого датасета будет 4 признака:


    

  • булев признак, False или True с равной вероятностью
    • 

  • целочисленный признак - равномерно случайно выбранный из [0, 5]
    • 

  • строковый признак сгенерированный из табицы строк с использованием целочисленного признака в качестве индекса
    • 

  • признак с плавающей точкой из стандартного нормального распределения
    • 



Рассмотрим выборку состающую из 10 000 независимых, одинаково распределенных наблюдений из каждого вышеприведенного распределения:


  
In [ ]:
 
 
 
# Число наблюдений в датасете. n_observations = int(1e4) # Булев признак, принимающий значения False или True. feature0 = np.random.choice([False, True], n_observations) # Целочисленный признак, случайное число от 0 до 4. feature1 = np.random.randint(0, 5, n_observations) # Строковый признак strings = np.array([b'cat', b'dog', b'chicken', b'horse', b'goat']) feature2 = strings[feature1] # Признак с плавающей точкой, из стандартного нормального распределения feature3 = np.random.randn(n_observations) 


Каждый из этих признаков может быть приведен к tf.Example -совместимому типу с использованием одного из _bytes_feature , _float_feature , _int64_feature . Вы можете затем создать tf.Example -сообщение из этих закодированных признаков:


  
In [ ]:
 
 
 
def serialize_example(feature0, feature1, feature2, feature3): """ Создает tf.Example-сообщение готовое к записи в файл. """ # Создает словарь отображение имен признаков в tf.Example-совместимые # типы данных. feature =  'feature0': _int64_feature(feature0), 'feature1': _int64_feature(feature1), 'feature2': _bytes_feature(feature2), 'feature3': _float_feature(feature3), > # Создает Features message с использованием tf.train.Example. example_proto = tf.train.Example(features=tf.train.Features(feature=feature)) return example_proto.SerializeToString() 


Возьмем, например, одно наблюдение из датасета, [False, 4, bytes('goat'), 0.9876] . Вы можете создать и распечатать tf.Example -сообщение для этого наблюдения с использованием create_message() . Каждое наблюдение может быть записано в виде Features -сообщения как указано выше. Note that the tf.Example -сообщение это всего лишь обертка вокруг Features -сообщения:


  
In [ ]:
 
 
 
# Это пример наблюдения из набора данных. example_observation = [] serialized_example = serialize_example(False, 4, b'goat', 0.9876) serialized_example 


Для декодирования сообщения используйте метод tf.train.Example.FromString .


  
In [ ]:
 
 
 
example_proto = tf.train.Example.FromString(serialized_example) example_proto 


Детали формата TFRecords


Файл TFRecord содержит последовательность записей. Файл может быть прочитан только линейно.


Каждая запись содержит строку байтов для данных плюс длину данных и CRC32C (32-bit CRC использующий полином Кастаньоли) хеши для проверки целостности.








Каждая запись хранится в следующих форматах:


uint64 length uint32 masked_crc32_of_length byte data[length] uint32 masked_crc32_of_data 


Записи сцеплены друг с другом и организуют файл.. CRCs описаны тут, и маска CRC выглядит так:


masked_crc = ((crc >> 15) | (crc  


Замечание: Не обязательно использовать tf.Example в файлах TFRecord. tf.Example это всего лишь метод сериализации словарей в байтовые строки. Строки текста, закодированные данные изображений, или сериализованные тензоры (с использованием tf.io.serialize_tensor , и tf.io.parse_tensor при загрузке). См. модуль tf.io для дополнительных возможностей.


Файлы TFRecord с использованием tf.data


Модуль tf.data также предоставляет инструменты для чтения и записи данных в TensorFlow.


Запись файла TFRecord


Простейший способ помещения данных в датасет это использование метода from_tensor_slices .


Примененный к массиву он возвращает датасет скаляров:


  
In [ ]:
 
 
 
tf.data.Dataset.from_tensor_slices(feature1) 


Примененный к кортежу массивов он возвращает датасет кортежей:


  
In [ ]:
 
 
 
features_dataset = tf.data.Dataset.from_tensor_slices((feature0, feature1, feature2, feature3)) features_dataset 


  
In [ ]:
 
 
 
# Используйте `take(1)` чтобы взять только один пример из датасета. for f0,f1,f2,f3 in features_dataset.take(1): print(f0) print(f1) print(f2) print(f3) 


Используйте метод tf.data.Dataset.map чтобы применить функцию к каждому элементу Dataset .


«Функция отображения должна работать в графовом режиме TensorFlow - она должна принимать и возвращать tf.Tensors . Не тензорная функция, такая как create_example , может быть заключена в tf.py_function , для совместимости.


Использование tf.py_function требует указания размерности и информации о типе, которая в противном случае недоступна:


  
In [ ]:
 
 
 
def tf_serialize_example(f0,f1,f2,f3): tf_string = tf.py_function( serialize_example, (f0,f1,f2,f3), # передайте эти аргументы в верхнюю функцию. tf.string) # возвращаемый тип `tf.string`. return tf.reshape(tf_string, ()) # Результатом является скаляр 


  
In [ ]:
 
 
 
tf_serialize_example(f0,f1,f2,f3) 


Примените эту функцию к каждому элементу датасета:


  
In [ ]:
 
 
 
serialized_features_dataset = features_dataset.map(tf_serialize_example) serialized_features_dataset 


  
In [ ]:
 
 
 
def generator(): for features in features_dataset: yield serialize_example(*features) 


  
In [ ]:
 
 
 
serialized_features_dataset = tf.data.Dataset.from_generator( generator, output_types=tf.string, output_shapes=()) 


  
In [ ]:
 
 
 
serialized_features_dataset 


И запишите их в файл TFRecord:


  
In [ ]:
 
 
 
filename = 'test.tfrecord' writer = tf.data.experimental.TFRecordWriter(filename) writer.write(serialized_features_dataset) 


Чтение TFRecord файла


Вы можете также прочитать TFRecord файл используя класс tf.data.TFRecordDataset .


Больше информации об использовании TFRecord файлов с использованием tf.data может быть найдено тут..


Использование TFRecordDataset -ов может быть полезно для стандартизации входных данных и оптимизации производительности.


  
In [ ]:
 
 
 
filenames = [filename] raw_dataset = tf.data.TFRecordDataset(filenames) raw_dataset 


На этом этапе датасет содержит сериализованные сообщения tf.train.Example . При их итерации возвращаются скалярные строки тензоров.


Используйте метод .take чтобы показать только первые 10 записей.


Замечание: итерация по tf.data.Dataset работает только при включенном eager execution.


  
In [ ]:
 
 
 
for raw_record in raw_dataset.take(10): print(repr(raw_record)) 


Эти тензоры может распарсить используя нижеприведенную функцию. Заметьте что feature_description обязателен тут поскольку датасеты используют графовое исполнение и нуждаются в этом описании для построения своей размерностной и типовой сигнатуры:


  
In [ ]:
 
 
 
# Создайте описание этих признаков feature_description =  'feature0': tf.io.FixedLenFeature([], tf.int64, default_value=0), 'feature1': tf.io.FixedLenFeature([], tf.int64, default_value=0), 'feature2': tf.io.FixedLenFeature([], tf.string, default_value=''), 'feature3': tf.io.FixedLenFeature([], tf.float32, default_value=0.0), > def _parse_function(example_proto): # Разберите `tf.Example` proto используя вышеприведенный словарь. return tf.io.parse_single_example(example_proto, feature_description) 


Альтернативно, используйте tf.parse example чтобы распарсить весь пакет за раз. Примените эту функцию к кажому элементу датасета используя метод tf.data.Dataset.map :


  
In [ ]:
 
 
 
parsed_dataset = raw_dataset.map(_parse_function) parsed_dataset 


Используйте eager execution чтобы показывать наблюдения в датасете. В этом наборе данных 10,000 наблюдений, но вы выведете только первые 10. Данные показываются как словарь признаков. Каждое наблюдение это tf.Tensor , и элемент numpy этого тензора показывает значение признака:


  
In [ ]:
 
 
 
for parsed_record in parsed_dataset.take(10): print(repr(parsed_record)) 


Здесь функция tf.parse_example распаковывает поля tf.Example в стандартные тензоры.


TFRecord файлы в Python


Модуль tf.io также содержит чисто Python функции для чтения и записи файлов TFRecord.


Запись TFRecord файла


Далее запишем эти 10 000 наблюдений в файл test.tfrecord . Каждое наблюдения конвертируется в tf.Example -сообщение и затем пишется в файл. Вы можете после проверить, что файл test.tfrecord был создан:


  
In [ ]:
 
 
 
# Запишем наблюдения `tf.Example` в файл. with tf.io.TFRecordWriter(filename) as writer: for i in range(n_observations): example = serialize_example(feature0[i], feature1[i], feature2[i], feature3[i]) writer.write(example) 


  
In [ ]:
 
 
 
!du -sh filename> 


Чтение TFRecord файла


Эти сериализованные тензоры могут быть легко распарсены с использование tf.train.Example.ParseFromString :


  
In [ ]:
 
 
 
filenames = [filename] raw_dataset = tf.data.TFRecordDataset(filenames) raw_dataset 


  
In [ ]:
 
 
 
for raw_record in raw_dataset.take(1): example = tf.train.Example() example.ParseFromString(raw_record.numpy()) print(example) 


Упражнение: Чтение и запись данных изображений


Это пример того как читать и писать данные изображений используя TFRecords. Цель этого показать как, от начала до конца, ввести данные (в этом случае изображение) и записать данные в TFRecord файл, затем прочитать файл и показать изображение.


Это будет полезно если, например, вы хотите использовать несколько моделей на одних и тех же входных данных. Вместо хранения сырых данных изображений, они могут быть предобработанны в формат TFRecords, и затем могут быть использованы во всех дальнейших обработках и моделированиях.


Сперва давайте скачаем это изображение кота и покажем это фото строительства моста Williamsburg, NYC.


Получите изображения


  
In [ ]:
 
 
 
cat_in_snow = tf.keras.utils.get_file('320px-Felis_catus-cat_on_snow.jpg', 'https://storage.googleapis.com/download.tensorflow.org/example_images/320px-Felis_catus-cat_on_snow.jpg') williamsburg_bridge = tf.keras.utils.get_file('194px-New_East_River_Bridge_from_Brooklyn_det.4a09796u.jpg','https://storage.googleapis.com/download.tensorflow.org/example_images/194px-New_East_River_Bridge_from_Brooklyn_det.4a09796u.jpg') 


Write the TFRecord file


Как и ранее закодируйте признаки как типы совместимые с tf.Example . Здесь хранится необработанные данные изображения в формате string, так же как и высота, ширина, глубина и произвольный признак label . Последнее используется когда вы пишете файл чтобы различать изображение кота и моста. Используйте 0 изображения кота, и 1 для моста:


  
In [ ]:
 
 
 
image_labels =  cat_in_snow : 0, williamsburg_bridge : 1, > 


  
In [ ]:
 
 
 
# Это пример использования только изображения кота. image_string = open(cat_in_snow, 'rb').read() label = image_labels[cat_in_snow] # Создайте библиотеку с признаками которые могут быть релевантны. def image_example(image_string, label): image_shape = tf.image.decode_jpeg(image_string).shape feature =  'height': _int64_feature(image_shape[0]), 'width': _int64_feature(image_shape[1]), 'depth': _int64_feature(image_shape[2]), 'label': _int64_feature(label), 'image_raw': _bytes_feature(image_string), > return tf.train.Example(features=tf.train.Features(feature=feature)) for line in str(image_example(image_string, label)).split('\n')[:15]: print(line) print('. ') 


Заметьте что все признаки сейчас содержатся в tf.Example -сообщении. Далее функционализируйте вышеприведенный код и запишите пример сообщений в файл с именем images.tfrecords :


  
In [ ]:
 
 
 
# Запишем файлы изображений в `images.tfrecords`. # Сперва, преобразуем два изображения в `tf.Example`-сообщения. # Затем запишем их в `.tfrecords` файл. record_file = 'images.tfrecords' with tf.io.TFRecordWriter(record_file) as writer: for filename, label in image_labels.items(): image_string = open(filename, 'rb').read() tf_example = image_example(image_string, label) writer.write(tf_example.SerializeToString()) 


  
In [ ]:
 
 
 
!du -sh record_file> 


Чтение TFRecord файла


У вас сейчас есть файл images.tfrecords и вы можете проитерировать записи в нем чтобы прочитать то что вы в него записали. Поскольку этот пример содержит только изображение единственное свойство которое вам нужно это необработанная строка изображения. Извлеките ее используя геттеры описанные выше, а именно example.features.feature['image_raw'].bytes_list.value[0] . Вы можете также использовать метки чтобы определить, которая запись является котом, и которая мостом:


  
In [ ]:
 
 
 
raw_image_dataset = tf.data.TFRecordDataset('images.tfrecords') # Создадим словарь описывающий свойства. image_feature_description =  'height': tf.io.FixedLenFeature([], tf.int64), 'width': tf.io.FixedLenFeature([], tf.int64), 'depth': tf.io.FixedLenFeature([], tf.int64), 'label': tf.io.FixedLenFeature([], tf.int64), 'image_raw': tf.io.FixedLenFeature([], tf.string), > def _parse_image_function(example_proto): # Распарсим входной tf.Example proto используя вышесозданный словарь. return tf.io.parse_single_example(example_proto, image_feature_description) parsed_image_dataset = raw_image_dataset.map(_parse_image_function) parsed_image_dataset 





Похожие публикации:
    

  1. Bad recipient address syntax что значит
    2. 

  2. Javascript в visual studio как создать проект
    3. 

  3. Как создать бота в botfather
    4. 

  4. Какая самая умная машина
    5. 









		

		
Добавить комментарий 
Ваш адрес email не будет опубликован. Обязательные поля помечены *