Google I / O'daki önemli notları, ürün oturumlarını, atölyeleri ve daha fazlasını izleyin Oynatma listesine bakın

TFRecord ve tf.train.Example

TensorFlow.org'da görüntüleyin Google Colab'de çalıştırın Kaynağı GitHub'da görüntüleyin Defteri indirin

TFRecord biçimi, bir dizi ikili kaydı depolamak için basit bir biçimdir.

Protokol arabellekleri , yapılandırılmış verilerin verimli bir şekilde serileştirilmesi için platformlar arası, diller arası bir kitaplıktır.

Protokol mesajları .proto dosyalarıyla tanımlanır, bunlar genellikle bir mesaj türünü anlamanın en kolay yoludur.

tf.train.Example mesajı (veya tf.train.Example ), bir {"string": value} eşlemesini temsil eden esnek bir mesaj türüdür. TensorFlow ile kullanılmak üzere tasarlanmıştır ve TFX gibi üst düzey API'lerde kullanılır.

Bu not defteri, tf.train.Example mesajının nasıl oluşturulacağını, ayrıştırılacağını ve kullanılacağını ve ardından tf.train.Example mesajlarını serileştirmeyi, yazmayı ve .tfrecord dosyalarından tf.train.Example mesajları gösterecektir.

Kurulum

import tensorflow as tf

import numpy as np
import IPython.display as display

tf.train.Example

tf.train.Example için veri türleri

Temel olarak, bir tf.train.Example bir {"string": tf.train.Feature} eşlemesidir.

tf.train.Feature mesaj türü, aşağıdaki üç türden birini kabul edebilir (Başvuru için .proto dosyasına bakın). Diğer jenerik türlerin çoğu şunlardan birine zorlanabilir:

  1. tf.train.BytesList (aşağıdaki türler zorlanabilir)

    • string
    • byte
  2. tf.train.FloatList (aşağıdaki türler zorlanabilir)

    • float ( float32 )
    • double ( float64 )
  3. tf.train.Int64List (aşağıdaki türler zorlanabilir)

    • bool
    • enum
    • int32
    • uint32
    • int64
    • uint64

Standart bir TensorFlow türünü tf.train.Example uyumlu tf.train.Feature dönüştürmek için aşağıdaki kısayol işlevlerini kullanabilirsiniz. Her işlevin skaler bir girdi değeri tf.train.Feature ve yukarıdaki üç list türünden birini içeren bir tf.train.Feature döndürdüğünü tf.train.Feature :

# The following functions can be used to convert a value to a type compatible
# with tf.train.Example.

def _bytes_feature(value):
  """Returns a bytes_list from a string / byte."""
  if isinstance(value, type(tf.constant(0))):
    value = value.numpy() # BytesList won't unpack a string from an EagerTensor.
  return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value]))

def _float_feature(value):
  """Returns a float_list from a float / double."""
  return tf.train.Feature(float_list=tf.train.FloatList(value=[value]))

def _int64_feature(value):
  """Returns an int64_list from a bool / enum / int / uint."""
  return tf.train.Feature(int64_list=tf.train.Int64List(value=[value]))

Aşağıda bu işlevlerin nasıl çalıştığına dair bazı örnekler verilmiştir. Değişen giriş türlerine ve standartlaştırılmış çıktı türlerine dikkat edin. Bir işlevin girdi türü yukarıda belirtilen zorlayıcı türlerden biriyle eşleşmiyorsa, işlev bir istisna oluşturur (ör. 1.0 bir float olduğundan _int64_feature(1.0) hata verir, bu nedenle bunun yerine _float_feature işlevi ile birlikte kullanılmalıdır) :

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))
bytes_list {
  value: "test_string"
}

bytes_list {
  value: "test_bytes"
}

float_list {
  value: 2.7182817459106445
}

int64_list {
  value: 1
}

int64_list {
  value: 1
}

Tüm protokol mesajları, .SerializeToString yöntemi kullanılarak bir ikili dizeye serileştirilebilir:

feature = _float_feature(np.exp(1))

feature.SerializeToString()
b'\x12\x06\n\x04T\xf8-@'

tf.train.Example mesajı oluşturma

Mevcut verilerden bir tf.train.Example mesajı oluşturmak istediğinizi varsayalım. Uygulamada, veri kümesi herhangi bir yerden gelebilir, ancak tf.train.Example mesajını tek bir gözlemden oluşturma prosedürü aynı olacaktır:

  1. Her gözlemde, her değerin yukarıdaki işlevlerden biri kullanılarak 3 uyumlu türden birini içeren bir tf.train.Feature dönüştürülmesi gerekir.

  2. Özellik adı dizesinden # 1'de üretilen kodlanmış özellik değerine bir harita (sözlük) oluşturursunuz.

  3. 2. adımda üretilen harita, Features mesajına dönüştürülür.

Bu defterde NumPy kullanarak bir veri kümesi oluşturacaksınız.

Bu veri kümesinin 4 özelliği olacaktır:

  • bir boole özelliği, False veya True eşit olasılıkla
  • [0, 5] arasından rastgele seçilen bir tamsayı özelliği
  • indeks olarak tamsayı özelliğini kullanarak bir dize tablosundan üretilen bir dize özelliği
  • standart bir normal dağılımdan bir kayan özellik

Yukarıdaki dağılımların her birinden bağımsız ve aynı şekilde dağıtılmış 10.000 gözlemden oluşan bir örnek düşünün:

# The number of observations in the dataset.
n_observations = int(1e4)

# Boolean feature, encoded as False or True.
feature0 = np.random.choice([False, True], n_observations)

# Integer feature, random from 0 to 4.
feature1 = np.random.randint(0, 5, n_observations)

# String feature
strings = np.array([b'cat', b'dog', b'chicken', b'horse', b'goat'])
feature2 = strings[feature1]

# Float feature, from a standard normal distribution
feature3 = np.random.randn(n_observations)

Bu özelliklerin her biri, bir tf.train.Example uyumlu bir tür, _bytes_feature , _float_feature , _int64_feature . Daha sonra bu kodlanmış özelliklerden bir tf.train.Example mesaj oluşturabilirsiniz:

def serialize_example(feature0, feature1, feature2, feature3):
  """
  Creates a tf.train.Example message ready to be written to a file.
  """
  # Create a dictionary mapping the feature name to the tf.train.Example-compatible
  # data type.
  feature = {
      'feature0': _int64_feature(feature0),
      'feature1': _int64_feature(feature1),
      'feature2': _bytes_feature(feature2),
      'feature3': _float_feature(feature3),
  }

  # Create a Features message using tf.train.Example.

  example_proto = tf.train.Example(features=tf.train.Features(feature=feature))
  return example_proto.SerializeToString()

Örneğin, veri kümesinden tek bir gözleminiz olduğunu varsayalım, [False, 4, bytes('goat'), 0.9876] . create_message() kullanarak bu gözlem için tf.train.Example mesajını oluşturabilir ve yazdırabilirsiniz. Her bir gözlem, yukarıdaki gibi bir Features mesajı olarak yazılacaktır. tf.train.Example mesajının sadece Features mesajının etrafındaki bir sarmalayıcı olduğuna tf.train.Example edin:

# This is an example observation from the dataset.

example_observation = []

serialized_example = serialize_example(False, 4, b'goat', 0.9876)
serialized_example
b'\nR\n\x11\n\x08feature0\x12\x05\x1a\x03\n\x01\x00\n\x11\n\x08feature1\x12\x05\x1a\x03\n\x01\x04\n\x14\n\x08feature3\x12\x08\x12\x06\n\x04[\xd3|?\n\x14\n\x08feature2\x12\x08\n\x06\n\x04goat'

İletinin kodunu çözmek için tf.train.Example.FromString yöntemini kullanın.

example_proto = tf.train.Example.FromString(serialized_example)
example_proto
features {
  feature {
    key: "feature0"
    value {
      int64_list {
        value: 0
      }
    }
  }
  feature {
    key: "feature1"
    value {
      int64_list {
        value: 4
      }
    }
  }
  feature {
    key: "feature2"
    value {
      bytes_list {
        value: "goat"
      }
    }
  }
  feature {
    key: "feature3"
    value {
      float_list {
        value: 0.9876000285148621
      }
    }
  }
}

TFRecords format ayrıntıları

Bir TFRecord dosyası bir dizi kayıt içerir. Dosya yalnızca sırayla okunabilir.

Her kayıt, veri yükü için bir bayt dizisi, artı veri uzunluğu ve bütünlük denetimi için CRC32C (Castagnoli polinomunu kullanan 32-bit CRC) karmalarını içerir.

Her kayıt aşağıdaki formatlarda saklanır:

uint64 length
uint32 masked_crc32_of_length
byte   data[length]
uint32 masked_crc32_of_data

Dosyayı oluşturmak için kayıtlar birleştirilir. CRC'ler burada açıklanmıştır ve bir CRC'nin maskesi şöyledir:

masked_crc = ((crc >> 15) | (crc << 17)) + 0xa282ead8ul

Tf.data kullanarak tf.data dosyaları

tf.data modülü ayrıca TensorFlow'da veri okumak ve yazmak için araçlar sağlar.

Bir TFRecord dosyası yazma

Verileri bir veri kümesine almanın en kolay yolu from_tensor_slices yöntemini kullanmaktır.

Bir diziye uygulandığında, skalarlardan oluşan bir veri kümesi döndürür:

tf.data.Dataset.from_tensor_slices(feature1)
<TensorSliceDataset shapes: (), types: tf.int64>

Bir dizi dizisine uygulandığında, tupleların bir veri kümesini döndürür:

features_dataset = tf.data.Dataset.from_tensor_slices((feature0, feature1, feature2, feature3))
features_dataset
<TensorSliceDataset shapes: ((), (), (), ()), types: (tf.bool, tf.int64, tf.string, tf.float64)>
# Use `take(1)` to only pull one example from the dataset.
for f0,f1,f2,f3 in features_dataset.take(1):
  print(f0)
  print(f1)
  print(f2)
  print(f3)
tf.Tensor(False, shape=(), dtype=bool)
tf.Tensor(2, shape=(), dtype=int64)
tf.Tensor(b'chicken', shape=(), dtype=string)
tf.Tensor(0.0034007389935575725, shape=(), dtype=float64)

Bir Dataset tf.data.Dataset.map her bir öğesine bir işlev uygulamak için tf.data.Dataset.map yöntemini kullanın.

Haritalanan işlev TensorFlow grafik modunda çalışmalıdır — tf.Tensors üzerinde çalışmalı ve geri tf.Tensors . serialize_example gibi tensör olmayan bir işlev, uyumlu hale getirmek için tf.py_function ile tf.py_function .

tf.py_function kullanılması, aksi takdirde kullanılamayan şekil ve tür bilgilerinin belirtilmesini gerektirir:

def tf_serialize_example(f0,f1,f2,f3):
  tf_string = tf.py_function(
    serialize_example,
    (f0,f1,f2,f3),  # pass these args to the above function.
    tf.string)      # the return type is `tf.string`.
  return tf.reshape(tf_string, ()) # The result is a scalar
tf_serialize_example(f0,f1,f2,f3)
<tf.Tensor: shape=(), dtype=string, numpy=b'\nU\n\x17\n\x08feature2\x12\x0b\n\t\n\x07chicken\n\x11\n\x08feature0\x12\x05\x1a\x03\n\x01\x00\n\x11\n\x08feature1\x12\x05\x1a\x03\n\x01\x02\n\x14\n\x08feature3\x12\x08\x12\x06\n\x04\xef\xde^;'>

Bu işlevi veri kümesindeki her öğeye uygulayın:

serialized_features_dataset = features_dataset.map(tf_serialize_example)
serialized_features_dataset
<MapDataset shapes: (), types: tf.string>
def generator():
  for features in features_dataset:
    yield serialize_example(*features)
serialized_features_dataset = tf.data.Dataset.from_generator(
    generator, output_types=tf.string, output_shapes=())
serialized_features_dataset
<FlatMapDataset shapes: (), types: tf.string>

Ve bunları bir TFRecord dosyasına yazın:

filename = 'test.tfrecord'
writer = tf.data.experimental.TFRecordWriter(filename)
writer.write(serialized_features_dataset)

Bir TFRecord dosyasını okumak

TFRecord dosyasını tf.data.TFRecordDataset sınıfını kullanarak da okuyabilirsiniz.

TFRecord dosyalarının tf.data kullanılarak kullanılması hakkında daha fazla bilgiyi burada bulabilirsiniz .

TFRecordDataset kullanmak, girdi verilerini standartlaştırmak ve performansı optimize etmek için yararlı olabilir.

filenames = [filename]
raw_dataset = tf.data.TFRecordDataset(filenames)
raw_dataset
<TFRecordDatasetV2 shapes: (), types: tf.string>

Bu noktada, veri kümesi serileştirilmiş tf.train.Example mesajları içerir. Üzerinde yinelendiğinde, bunları skaler dizi tensörleri olarak döndürür.

Yalnızca ilk 10 kaydı göstermek için .take yöntemini kullanın.

for raw_record in raw_dataset.take(10):
  print(repr(raw_record))
<tf.Tensor: shape=(), dtype=string, numpy=b'\nU\n\x17\n\x08feature2\x12\x0b\n\t\n\x07chicken\n\x11\n\x08feature0\x12\x05\x1a\x03\n\x01\x00\n\x14\n\x08feature3\x12\x08\x12\x06\n\x04\xef\xde^;\n\x11\n\x08feature1\x12\x05\x1a\x03\n\x01\x02'>
<tf.Tensor: shape=(), dtype=string, numpy=b'\nQ\n\x11\n\x08feature0\x12\x05\x1a\x03\n\x01\x01\n\x14\n\x08feature3\x12\x08\x12\x06\n\x04\xe4\xb1>?\n\x11\n\x08feature1\x12\x05\x1a\x03\n\x01\x00\n\x13\n\x08feature2\x12\x07\n\x05\n\x03cat'>
<tf.Tensor: shape=(), dtype=string, numpy=b'\nQ\n\x11\n\x08feature1\x12\x05\x1a\x03\n\x01\x00\n\x14\n\x08feature3\x12\x08\x12\x06\n\x04\x12\xfd\xf1\xbe\n\x13\n\x08feature2\x12\x07\n\x05\n\x03cat\n\x11\n\x08feature0\x12\x05\x1a\x03\n\x01\x00'>
<tf.Tensor: shape=(), dtype=string, numpy=b'\nS\n\x11\n\x08feature1\x12\x05\x1a\x03\n\x01\x03\n\x11\n\x08feature0\x12\x05\x1a\x03\n\x01\x01\n\x14\n\x08feature3\x12\x08\x12\x06\n\x04\xb9_\xf9\xbe\n\x15\n\x08feature2\x12\t\n\x07\n\x05horse'>
<tf.Tensor: shape=(), dtype=string, numpy=b'\nU\n\x14\n\x08feature3\x12\x08\x12\x06\n\x04n\x81\xcf?\n\x11\n\x08feature0\x12\x05\x1a\x03\n\x01\x00\n\x11\n\x08feature1\x12\x05\x1a\x03\n\x01\x02\n\x17\n\x08feature2\x12\x0b\n\t\n\x07chicken'>
<tf.Tensor: shape=(), dtype=string, numpy=b'\nS\n\x11\n\x08feature1\x12\x05\x1a\x03\n\x01\x03\n\x11\n\x08feature0\x12\x05\x1a\x03\n\x01\x01\n\x14\n\x08feature3\x12\x08\x12\x06\n\x04l\xe5\xc2\xbe\n\x15\n\x08feature2\x12\t\n\x07\n\x05horse'>
<tf.Tensor: shape=(), dtype=string, numpy=b'\nQ\n\x11\n\x08feature1\x12\x05\x1a\x03\n\x01\x00\n\x13\n\x08feature2\x12\x07\n\x05\n\x03cat\n\x14\n\x08feature3\x12\x08\x12\x06\n\x04\x80\xc6\x9b\xbe\n\x11\n\x08feature0\x12\x05\x1a\x03\n\x01\x01'>
<tf.Tensor: shape=(), dtype=string, numpy=b'\nR\n\x11\n\x08feature0\x12\x05\x1a\x03\n\x01\x00\n\x14\n\x08feature3\x12\x08\x12\x06\n\x04\xb8\xd3\x06\xbf\n\x11\n\x08feature1\x12\x05\x1a\x03\n\x01\x04\n\x14\n\x08feature2\x12\x08\n\x06\n\x04goat'>
<tf.Tensor: shape=(), dtype=string, numpy=b'\nQ\n\x13\n\x08feature2\x12\x07\n\x05\n\x03dog\n\x11\n\x08feature0\x12\x05\x1a\x03\n\x01\x01\n\x14\n\x08feature3\x12\x08\x12\x06\n\x04\xfdv\xec\xbe\n\x11\n\x08feature1\x12\x05\x1a\x03\n\x01\x01'>
<tf.Tensor: shape=(), dtype=string, numpy=b'\nU\n\x17\n\x08feature2\x12\x0b\n\t\n\x07chicken\n\x14\n\x08feature3\x12\x08\x12\x06\n\x04\xb1\xc2\x1b?\n\x11\n\x08feature0\x12\x05\x1a\x03\n\x01\x00\n\x11\n\x08feature1\x12\x05\x1a\x03\n\x01\x02'>

Bu tensörler aşağıdaki fonksiyon kullanılarak ayrıştırılabilir. feature_description burada gerekli olduğunu unutmayın çünkü veri kümeleri grafik yürütme kullanır ve şekillerini ve tür imzalarını oluşturmak için bu açıklamaya ihtiyaç duyarlar:

# Create a description of the features.
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):
  # Parse the input `tf.train.Example` proto using the dictionary above.
  return tf.io.parse_single_example(example_proto, feature_description)

Alternatif olarak, tüm partiyi tek seferde ayrıştırmak için tf.parse example kullanın. tf.data.Dataset.map yöntemini kullanarak bu işlevi veri kümesindeki her öğeye uygulayın:

parsed_dataset = raw_dataset.map(_parse_function)
parsed_dataset
<MapDataset shapes: {feature0: (), feature1: (), feature2: (), feature3: ()}, types: {feature0: tf.int64, feature1: tf.int64, feature2: tf.string, feature3: tf.float32}>

Veri kümesindeki gözlemleri görüntülemek için istekli yürütmeyi kullanın. Bu veri kümesinde 10.000 gözlem vardır, ancak yalnızca ilk 10 tanesini görüntüleyeceksiniz. Veriler, özellikler sözlüğü olarak görüntülenir. Her öğe bir tf.Tensor ve bu tensörün numpy öğesi, özelliğin değerini gösterir:

for parsed_record in parsed_dataset.take(10):
  print(repr(parsed_record))
{'feature0': <tf.Tensor: shape=(), dtype=int64, numpy=0>, 'feature1': <tf.Tensor: shape=(), dtype=int64, numpy=2>, 'feature2': <tf.Tensor: shape=(), dtype=string, numpy=b'chicken'>, 'feature3': <tf.Tensor: shape=(), dtype=float32, numpy=0.003400739>}
{'feature0': <tf.Tensor: shape=(), dtype=int64, numpy=1>, 'feature1': <tf.Tensor: shape=(), dtype=int64, numpy=0>, 'feature2': <tf.Tensor: shape=(), dtype=string, numpy=b'cat'>, 'feature3': <tf.Tensor: shape=(), dtype=float32, numpy=0.7449019>}
{'feature0': <tf.Tensor: shape=(), dtype=int64, numpy=0>, 'feature1': <tf.Tensor: shape=(), dtype=int64, numpy=0>, 'feature2': <tf.Tensor: shape=(), dtype=string, numpy=b'cat'>, 'feature3': <tf.Tensor: shape=(), dtype=float32, numpy=-0.4726339>}
{'feature0': <tf.Tensor: shape=(), dtype=int64, numpy=1>, 'feature1': <tf.Tensor: shape=(), dtype=int64, numpy=3>, 'feature2': <tf.Tensor: shape=(), dtype=string, numpy=b'horse'>, 'feature3': <tf.Tensor: shape=(), dtype=float32, numpy=-0.48705843>}
{'feature0': <tf.Tensor: shape=(), dtype=int64, numpy=0>, 'feature1': <tf.Tensor: shape=(), dtype=int64, numpy=2>, 'feature2': <tf.Tensor: shape=(), dtype=string, numpy=b'chicken'>, 'feature3': <tf.Tensor: shape=(), dtype=float32, numpy=1.6211374>}
{'feature0': <tf.Tensor: shape=(), dtype=int64, numpy=1>, 'feature1': <tf.Tensor: shape=(), dtype=int64, numpy=3>, 'feature2': <tf.Tensor: shape=(), dtype=string, numpy=b'horse'>, 'feature3': <tf.Tensor: shape=(), dtype=float32, numpy=-0.3806566>}
{'feature0': <tf.Tensor: shape=(), dtype=int64, numpy=1>, 'feature1': <tf.Tensor: shape=(), dtype=int64, numpy=0>, 'feature2': <tf.Tensor: shape=(), dtype=string, numpy=b'cat'>, 'feature3': <tf.Tensor: shape=(), dtype=float32, numpy=-0.3042488>}
{'feature0': <tf.Tensor: shape=(), dtype=int64, numpy=0>, 'feature1': <tf.Tensor: shape=(), dtype=int64, numpy=4>, 'feature2': <tf.Tensor: shape=(), dtype=string, numpy=b'goat'>, 'feature3': <tf.Tensor: shape=(), dtype=float32, numpy=-0.5266681>}
{'feature0': <tf.Tensor: shape=(), dtype=int64, numpy=1>, 'feature1': <tf.Tensor: shape=(), dtype=int64, numpy=1>, 'feature2': <tf.Tensor: shape=(), dtype=string, numpy=b'dog'>, 'feature3': <tf.Tensor: shape=(), dtype=float32, numpy=-0.4618453>}
{'feature0': <tf.Tensor: shape=(), dtype=int64, numpy=0>, 'feature1': <tf.Tensor: shape=(), dtype=int64, numpy=2>, 'feature2': <tf.Tensor: shape=(), dtype=string, numpy=b'chicken'>, 'feature3': <tf.Tensor: shape=(), dtype=float32, numpy=0.6084395>}

Burada, tf.parse_example işlevi tf.train.Example alanlarını standart tensörlere tf.train.Example .

Python'da TFRecord dosyaları

tf.io modülü, TFRecord dosyalarını okumak ve yazmak için saf Python işlevlerini de içerir.

Bir TFRecord dosyası yazma

Ardından, 10.000 gözlemi test.tfrecord dosyasına test.tfrecord . Her gözlem bir tf.train.Example mesajına dönüştürülür ve ardından dosyaya yazılır. Daha sonra test.tfrecord dosyasının oluşturulduğunu doğrulayabilirsiniz:

# Write the `tf.train.Example` observations to the file.
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)
du -sh {filename}
984K    test.tfrecord

Bir TFRecord dosyasını okumak

Bu serileştirilmiş tensörler, tf.train.Example.ParseFromString kullanılarak kolayca ayrıştırılabilir:

filenames = [filename]
raw_dataset = tf.data.TFRecordDataset(filenames)
raw_dataset
<TFRecordDatasetV2 shapes: (), types: tf.string>
for raw_record in raw_dataset.take(1):
  example = tf.train.Example()
  example.ParseFromString(raw_record.numpy())
  print(example)
features {
  feature {
    key: "feature0"
    value {
      int64_list {
        value: 0
      }
    }
  }
  feature {
    key: "feature1"
    value {
      int64_list {
        value: 2
      }
    }
  }
  feature {
    key: "feature2"
    value {
      bytes_list {
        value: "chicken"
      }
    }
  }
  feature {
    key: "feature3"
    value {
      float_list {
        value: 0.00340073904953897
      }
    }
  }
}

İzlenecek yol: Görüntü verilerini okuma ve yazma

Bu, TFRecords kullanılarak görüntü verilerinin nasıl okunacağına ve yazılacağına ilişkin uçtan uca bir örnektir. Bir görüntüyü giriş verileri olarak kullanarak, verileri bir TFRecord dosyası olarak yazacak, ardından dosyayı geri okuyacak ve görüntüyü görüntüleyeceksiniz.

Örneğin, aynı girdi veri kümesinde birkaç model kullanmak istiyorsanız bu yararlı olabilir. Görüntü verilerini ham olarak depolamak yerine, TFRecords formatına önceden işlenebilir ve bu, tüm diğer işlem ve modellemelerde kullanılabilir.

Öncelikle, karda bir kedinin bu görüntüsünü ve New York'taki Williamsburg Köprüsü'nün yapım aşamasında olan bu fotoğrafını indirelim.

Görüntüleri getir

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')
Downloading data from https://storage.googleapis.com/download.tensorflow.org/example_images/320px-Felis_catus-cat_on_snow.jpg
24576/17858 [=========================================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/download.tensorflow.org/example_images/194px-New_East_River_Bridge_from_Brooklyn_det.4a09796u.jpg
16384/15477 [===============================] - 0s 0us/step
display.display(display.Image(filename=cat_in_snow))
display.display(display.HTML('Image cc-by: <a "href=https://commons.wikimedia.org/wiki/File:Felis_catus-cat_on_snow.jpg">Von.grzanka</a>'))

jpeg

display.display(display.Image(filename=williamsburg_bridge))
display.display(display.HTML('<a "href=https://commons.wikimedia.org/wiki/File:New_East_River_Bridge_from_Brooklyn_det.4a09796u.jpg">From Wikimedia</a>'))

jpeg

TFRecord dosyasını yazın

Daha önce olduğu gibi, özellikleri tf.train.Example ile uyumlu türler olarak tf.train.Example . Bu, ham görüntü dizisi özelliğinin yanı sıra yüksekliği, genişliği, derinliği ve rastgele label özelliğini de depolar. İkincisi, dosyayı yazarken kedi görüntüsü ile köprü görüntüsü arasında ayrım yapmak için kullanılır. Kedi resmi için 0 ve köprü resmi için 1 kullanın:

image_labels = {
    cat_in_snow : 0,
    williamsburg_bridge : 1,
}
# This is an example, just using the cat image.
image_string = open(cat_in_snow, 'rb').read()

label = image_labels[cat_in_snow]

# Create a dictionary with features that may be relevant.
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('...')
features {
  feature {
    key: "depth"
    value {
      int64_list {
        value: 3
      }
    }
  }
  feature {
    key: "height"
    value {
      int64_list {
        value: 213
      }
...

Tüm özelliklerin artık tf.train.Example mesajında ​​depolandığına tf.train.Example edin. Ardından, yukarıdaki kodu işlevselleştirin ve örnek mesajları images.tfrecords adlı bir dosyaya images.tfrecords :

# Write the raw image files to `images.tfrecords`.
# First, process the two images into `tf.train.Example` messages.
# Then, write to a `.tfrecords` file.
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())
du -sh {record_file}
36K images.tfrecords

TFRecord dosyasını okuyun

Artık images.tfrecords ve artık yazdıklarınızı tekrar okumak için içindeki kayıtları yineleyebilirsiniz. Bu örnekte yalnızca görüntüyü yeniden üreteceğiniz düşünüldüğünde, ihtiyacınız olan tek özellik ham görüntü dizesidir. Yukarıda açıklanan alıcıları, yani example.features.feature['image_raw'].bytes_list.value[0] . Etiketleri, hangi kaydın kedi, hangisinin köprü olduğunu belirlemek için de kullanabilirsiniz:

raw_image_dataset = tf.data.TFRecordDataset('images.tfrecords')

# Create a dictionary describing the features.
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):
  # Parse the input tf.train.Example proto using the dictionary above.
  return tf.io.parse_single_example(example_proto, image_feature_description)

parsed_image_dataset = raw_image_dataset.map(_parse_image_function)
parsed_image_dataset
<MapDataset shapes: {depth: (), height: (), image_raw: (), label: (), width: ()}, types: {depth: tf.int64, height: tf.int64, image_raw: tf.string, label: tf.int64, width: tf.int64}>

Görüntüleri TFRecord dosyasından kurtarın:

for image_features in parsed_image_dataset:
  image_raw = image_features['image_raw'].numpy()
  display.display(display.Image(data=image_raw))

jpeg

jpeg