TFRecord और tf.train.उदाहरण

TensorFlow.org पर देखें Google Colab में चलाएं GitHub पर स्रोत देखें नोटबुक डाउनलोड करें

बाइनरी रिकॉर्ड के अनुक्रम को संग्रहीत करने के लिए TFRecord प्रारूप एक सरल प्रारूप है।

प्रोटोकॉल बफ़र्स एक पार मंच, संरचित डेटा के कुशल क्रमबद्धता के लिए पार भाषा पुस्तकालय है।

प्रोटोकॉल संदेशों द्वारा परिभाषित कर रहे .proto फ़ाइलें, इन अक्सर संदेश प्रकार को समझने के लिए सबसे आसान तरीका है।

tf.train.Example संदेश (या Protobuf) एक लचीला संदेश प्रकार है कि एक का प्रतिनिधित्व करता है {"string": value} मानचित्रण। यह TensorFlow साथ प्रयोग के लिए बनाया गया है और इस तरह के रूप उच्च स्तर एपीआई प्रयोग किया जाता है TFX

इस नोटबुक दर्शाता है कि कैसे बनाने के लिए, पार्स, और प्रयोग tf.train.Example serialize संदेश, और फिर, लिखने, और पढ़ने tf.train.Example करने के लिए और से संदेश .tfrecord फ़ाइलें।

सेट अप

import tensorflow as tf

import numpy as np
import IPython.display as display

tf.train.Example

के लिए डेटा प्रकार tf.train.Example

मूल रूप से, एक tf.train.Example एक है {"string": tf.train.Feature} मानचित्रण।

tf.train.Feature संदेश प्रकार निम्नलिखित तीन प्रकारों में से एक स्वीकार कर सकते हैं (देखें .proto फ़ाइल संदर्भ के लिए)। अधिकांश अन्य सामान्य प्रकारों को इनमें से किसी एक में ज़बरदस्ती किया जा सकता है:

  1. tf.train.BytesList (निम्नलिखित प्रकार मजबूर किया जा सकता है)

    • string
    • byte
  2. tf.train.FloatList (निम्नलिखित प्रकार मजबूर किया जा सकता है)

    • float ( float32 )
    • double ( float64 )
  3. tf.train.Int64List (निम्नलिखित प्रकार मजबूर किया जा सकता है)

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

आदेश में एक करने के लिए एक मानक TensorFlow प्रकार बदलने के लिए tf.train.Example संगत tf.train.Feature , तो आप नीचे दिए गए शॉर्टकट कार्यों का उपयोग कर सकते हैं। नोट प्रत्येक कार्य एक अदिश इनपुट मूल्य लेता है और एक रिटर्न कि tf.train.Feature तीन में से एक से युक्त list से ऊपर प्रकार:

# 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]))

ये फ़ंक्शन कैसे काम करते हैं, इसके कुछ उदाहरण नीचे दिए गए हैं। अलग-अलग इनपुट प्रकारों और मानकीकृत आउटपुट प्रकारों पर ध्यान दें। एक समारोह के लिए इनपुट प्रकार ऊपर कहा गया है मजबूर किया हुआ प्रकारों में से एक से मेल नहीं खाता, तो समारोह एक अपवाद बढ़ा देंगे (जैसे _int64_feature(1.0) से बाहर त्रुटि जाएगा, क्योंकि 1.0 एक नाव-इसलिए, इसके साथ प्रयोग किया जाना चाहिए है _float_feature बजाय समारोह ):

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
}

सभी आद्य संदेशों एक द्विआधारी-स्ट्रिंग का उपयोग करने के लिए धारावाहिक जा सकती है .SerializeToString विधि:

feature = _float_feature(np.exp(1))

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

एक बनाना tf.train.Example संदेश

यदि आप एक बनाना चाहते हैं मान लीजिए tf.train.Example मौजूदा डेटा से संदेश। अभ्यास में, डाटासेट कहीं से भी आ सकता है, लेकिन बनाने की प्रक्रिया tf.train.Example एक भी अवलोकन से संदेश एक ही हो जाएगा:

  1. प्रत्येक अवलोकन के अंतर्गत, प्रत्येक मूल्य की जरूरत है एक के लिए परिवर्तित किया tf.train.Feature 3 संगत प्रकारों में से एक होता है, इसके बाद के संस्करण कार्यों में से एक का उपयोग कर।

  2. आप फीचर नाम स्ट्रिंग से # 1 में निर्मित एन्कोडेड फीचर मान के लिए एक नक्शा (शब्दकोश) बनाते हैं।

  3. नक्शा चरण 2 में उत्पादित एक में बदल जाती है Features संदेश

इस नोटबुक में, आप NumPy का उपयोग करके एक डेटासेट बनाएंगे।

इस डेटासेट में 4 विशेषताएं होंगी:

  • एक बूलियन सुविधा, False या True बराबर संभावना के साथ
  • एक पूर्णांक सुविधा समान रूप से बेतरतीब ढंग से से चुना [0, 5]
  • एक अनुक्रमणिका के रूप में पूर्णांक सुविधा का उपयोग करके एक स्ट्रिंग तालिका से उत्पन्न एक स्ट्रिंग सुविधा
  • एक मानक सामान्य वितरण से एक फ्लोट सुविधा

उपरोक्त प्रत्येक वितरण से स्वतंत्र रूप से और समान रूप से वितरित प्रेक्षणों के १०,००० वाले नमूने पर विचार करें:

# 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)

इन सुविधाओं में से प्रत्येक एक मजबूर किया जा सकता है tf.train.Example संगत प्रकार से एक का उपयोग _bytes_feature , _float_feature , _int64_feature । फिर आप एक बना सकते हैं tf.train.Example इन इनकोडिंग सुविधाओं से संदेश:

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()

उदाहरण के लिए, आप डाटासेट से एक भी अवलोकन, मान लीजिए [False, 4, bytes('goat'), 0.9876] । आप बना सकते हैं और मुद्रित कर सकते हैं tf.train.Example का उपयोग कर इस अवलोकन के लिए संदेश create_message() के रूप में एक प्रत्येक एकल अवलोकन लिखा जाएगा Features संदेश के ऊपर के अनुसार। ध्यान दें कि tf.train.Example संदेश बस के चारों ओर एक आवरण है Features संदेश:

# 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\x14\n\x08feature2\x12\x08\n\x06\n\x04goat\n\x14\n\x08feature3\x12\x08\x12\x06\n\x04[\xd3|?\n\x11\n\x08feature1\x12\x05\x1a\x03\n\x01\x04\n\x11\n\x08feature0\x12\x05\x1a\x03\n\x01\x00'

संदेश उपयोग को डिकोड करने के tf.train.Example.FromString विधि।

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 प्रारूप विवरण

एक TFRecord फ़ाइल में अभिलेखों का एक क्रम होता है। फ़ाइल को केवल क्रमिक रूप से पढ़ा जा सकता है।

प्रत्येक रिकॉर्ड में एक बाइट-स्ट्रिंग, डेटा पेलोड, प्लस डेटा लंबाई, और सीआरसी 32C (के लिए होता है 32-बिट सीआरसी का उपयोग कर कास्टगनोली बहुपद ) अखंडता की जाँच के लिए हैश।

प्रत्येक रिकॉर्ड निम्न स्वरूपों में संग्रहीत किया जाता है:

uint64 length
uint32 masked_crc32_of_length
byte   data[length]
uint32 masked_crc32_of_data

फ़ाइल बनाने के लिए रिकॉर्ड्स को एक साथ जोड़ा जाता है। सीआरसी कर रहे हैं यहाँ वर्णित है, और एक सीआरसी का मुखौटा है:

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

TFRecord का उपयोग करके फ़ाइलें tf.data

tf.data मॉड्यूल भी पढ़ रहे हैं और TensorFlow में डेटा लिखने के लिए उपकरण प्रदान करता है।

TFRecord फ़ाइल लिखना

सबसे आसान तरीका है एक डाटासेट में डेटा प्राप्त करने के लिए उपयोग करने के लिए है from_tensor_slices विधि।

एक सरणी पर लागू, यह स्केलर का एक डेटासेट देता है:

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

सरणियों के टपल पर लागू, यह टुपल्स का एक डेटासेट देता है:

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(True, shape=(), dtype=bool)
tf.Tensor(1, shape=(), dtype=int64)
tf.Tensor(b'dog', shape=(), dtype=string)
tf.Tensor(-0.9885608219225024, shape=(), dtype=float64)

का प्रयोग करें tf.data.Dataset.map एक के प्रत्येक तत्व के लिए एक समारोह लागू करने का तरीका Dataset

मैप किए गए समारोह TensorFlow ग्राफ में काम करना होगा मोड उस पर काम करते हैं और लौटना चाहिए tf.Tensors । एक गैर टेन्सर समारोह, जैसे serialize_example , साथ लिपटे जा सकती है tf.py_function यह संगत बनाने के लिए।

का उपयोग करते हुए tf.py_function आकार और प्रकार की जानकारी है कि अन्यथा उपलब्ध नहीं है निर्दिष्ट करने के लिए की आवश्यकता है:

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'\nQ\n\x14\n\x08feature3\x12\x08\x12\x06\n\x04R\x12}\xbf\n\x11\n\x08feature1\x12\x05\x1a\x03\n\x01\x01\n\x13\n\x08feature2\x12\x07\n\x05\n\x03dog\n\x11\n\x08feature0\x12\x05\x1a\x03\n\x01\x01'>

इस फ़ंक्शन को डेटासेट में प्रत्येक तत्व पर लागू करें:

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>

और उन्हें एक TFRecord फ़ाइल में लिखें:

filename = 'test.tfrecord'
writer = tf.data.experimental.TFRecordWriter(filename)
writer.write(serialized_features_dataset)
WARNING:tensorflow:From /tmp/ipykernel_16482/3575438268.py:2: TFRecordWriter.__init__ (from tensorflow.python.data.experimental.ops.writers) is deprecated and will be removed in a future version.
Instructions for updating:
To write TFRecords to disk, use `tf.io.TFRecordWriter`. To save and load the contents of a dataset, use `tf.data.experimental.save` and `tf.data.experimental.load`

TFRecord फ़ाइल पढ़ना

तुम भी उपयोग कर रहा TFRecord फ़ाइल पढ़ सकते हैं tf.data.TFRecordDataset वर्ग।

उपभोक्ता का उपयोग कर TFRecord फाइलों पर अधिक जानकारी tf.data में पाया जा सकता बिल्ड TensorFlow इनपुट पाइपलाइनों: tf.data गाइड।

का उपयोग करते हुए TFRecordDataset रों इनपुट डेटा के मानकीकरण और प्रदर्शन का अनुकूलन के लिए उपयोगी हो सकता है।

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

इस बिंदु पर डाटासेट धारावाहिक शामिल tf.train.Example संदेशों। जब इसे पुनरावृत्त किया जाता है तो यह इन्हें स्केलर स्ट्रिंग टेंसर के रूप में लौटाता है।

का प्रयोग करें .take विधि केवल पहले 10 रिकॉर्ड दिखाने के लिए।

for raw_record in raw_dataset.take(10):
  print(repr(raw_record))
<tf.Tensor: shape=(), dtype=string, numpy=b'\nQ\n\x14\n\x08feature3\x12\x08\x12\x06\n\x04R\x12}\xbf\n\x11\n\x08feature0\x12\x05\x1a\x03\n\x01\x01\n\x13\n\x08feature2\x12\x07\n\x05\n\x03dog\n\x11\n\x08feature1\x12\x05\x1a\x03\n\x01\x01'>
<tf.Tensor: shape=(), dtype=string, numpy=b'\nQ\n\x14\n\x08feature3\x12\x08\x12\x06\n\x04\xb5\x91\xdc\xbb\n\x11\n\x08feature1\x12\x05\x1a\x03\n\x01\x00\n\x11\n\x08feature0\x12\x05\x1a\x03\n\x01\x01\n\x13\n\x08feature2\x12\x07\n\x05\n\x03cat'>
<tf.Tensor: shape=(), dtype=string, numpy=b'\nU\n\x11\n\x08feature0\x12\x05\x1a\x03\n\x01\x00\n\x17\n\x08feature2\x12\x0b\n\t\n\x07chicken\n\x14\n\x08feature3\x12\x08\x12\x06\n\x04\xbd\x91g=\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\x00\n\x13\n\x08feature2\x12\x07\n\x05\n\x03dog\n\x11\n\x08feature1\x12\x05\x1a\x03\n\x01\x01\n\x14\n\x08feature3\x12\x08\x12\x06\n\x04e\xc5\x98>'>
<tf.Tensor: shape=(), dtype=string, numpy=b'\nS\n\x15\n\x08feature2\x12\t\n\x07\n\x05horse\n\x11\n\x08feature1\x12\x05\x1a\x03\n\x01\x03\n\x14\n\x08feature3\x12\x08\x12\x06\n\x04e\xa4|>\n\x11\n\x08feature0\x12\x05\x1a\x03\n\x01\x01'>
<tf.Tensor: shape=(), dtype=string, numpy=b'\nQ\n\x11\n\x08feature0\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\x0b\xb3\x02@\n\x11\n\x08feature1\x12\x05\x1a\x03\n\x01\x00'>
<tf.Tensor: shape=(), dtype=string, numpy=b'\nQ\n\x14\n\x08feature3\x12\x08\x12\x06\n\x04G\xa4\xda\xbf\n\x13\n\x08feature2\x12\x07\n\x05\n\x03dog\n\x11\n\x08feature0\x12\x05\x1a\x03\n\x01\x01\n\x11\n\x08feature1\x12\x05\x1a\x03\n\x01\x01'>
<tf.Tensor: shape=(), dtype=string, numpy=b'\nQ\n\x11\n\x08feature1\x12\x05\x1a\x03\n\x01\x01\n\x11\n\x08feature0\x12\x05\x1a\x03\n\x01\x00\n\x13\n\x08feature2\x12\x07\n\x05\n\x03dog\n\x14\n\x08feature3\x12\x08\x12\x06\n\x04\xd2/\xcf\xbf'>
<tf.Tensor: shape=(), dtype=string, numpy=b'\nQ\n\x11\n\x08feature0\x12\x05\x1a\x03\n\x01\x00\n\x14\n\x08feature3\x12\x08\x12\x06\n\x04<\xedO?\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'\nR\n\x11\n\x08feature0\x12\x05\x1a\x03\n\x01\x01\n\x11\n\x08feature1\x12\x05\x1a\x03\n\x01\x04\n\x14\n\x08feature3\x12\x08\x12\x06\n\x041I\xe1?\n\x14\n\x08feature2\x12\x08\n\x06\n\x04goat'>

इन टेंसरों को नीचे दिए गए फ़ंक्शन का उपयोग करके पार्स किया जा सकता है। ध्यान दें कि feature_description यहाँ आवश्यक है, क्योंकि tf.data.Dataset रों उपयोग ग्राफ-निष्पादन, और उनके आकार और प्रकार हस्ताक्षर निर्माण करने के लिए इस विवरण की जरूरत है:

# 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)

वैकल्पिक रूप से, का उपयोग tf.parse example एक ही बार में पूरे बैच पार्स करने के लिए। डेटासेट का उपयोग करके में प्रत्येक आइटम के लिए इस फ़ंक्शन लागू tf.data.Dataset.map विधि:

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}>

डेटासेट में प्रेक्षणों को प्रदर्शित करने के लिए उत्सुक निष्पादन का उपयोग करें। इस डेटासेट में १०,००० अवलोकन हैं, लेकिन आप केवल पहले १० को प्रदर्शित करेंगे। डेटा को सुविधाओं के शब्दकोश के रूप में प्रदर्शित किया जाता है। प्रत्येक आइटम एक है tf.Tensor , और numpy इस टेन्सर प्रदर्शित करता है सुविधा के मूल्य के तत्व:

for parsed_record in parsed_dataset.take(10):
  print(repr(parsed_record))
{'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.9885608>}
{'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.006731237>}
{'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.05653547>}
{'feature0': <tf.Tensor: shape=(), dtype=int64, numpy=0>, '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.298381>}
{'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.24672087>}
{'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=2.042178>}
{'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=-1.7081383>}
{'feature0': <tf.Tensor: shape=(), dtype=int64, numpy=0>, 'feature1': <tf.Tensor: shape=(), dtype=int64, numpy=1>, 'feature2': <tf.Tensor: shape=(), dtype=string, numpy=b'dog'>, 'feature3': <tf.Tensor: shape=(), dtype=float32, numpy=-1.6186469>}
{'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.81221366>}
{'feature0': <tf.Tensor: shape=(), dtype=int64, numpy=1>, 'feature1': <tf.Tensor: shape=(), dtype=int64, numpy=4>, 'feature2': <tf.Tensor: shape=(), dtype=string, numpy=b'goat'>, 'feature3': <tf.Tensor: shape=(), dtype=float32, numpy=1.7600461>}

इधर, tf.parse_example समारोह unpacks tf.train.Example मानक tensors में खेतों।

पायथन में TFRecord फ़ाइलें

tf.io मॉड्यूल भी पढ़ रहे हैं और TFRecord फ़ाइलें लिखने के लिए शुद्ध पायथन कार्यों में शामिल है।

TFRecord फ़ाइल लिखना

इसके बाद, फ़ाइल के लिए 10,000 टिप्पणियों लिखने test.tfrecord । प्रत्येक अवलोकन एक में बदल जाती है tf.train.Example संदेश है, तो फाइल करने के लिए लिखा है। इसके बाद आप सत्यापित कर सकते हैं कि फ़ाइल test.tfrecord बना दिया गया है:

# 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

TFRecord फ़ाइल पढ़ना

ये धारावाहिक tensors आसानी से उपयोग कर रहा पार्स किया जा सकता tf.train.Example.ParseFromString :

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: 1
      }
    }
  }
  feature {
    key: "feature1"
    value {
      int64_list {
        value: 1
      }
    }
  }
  feature {
    key: "feature2"
    value {
      bytes_list {
        value: "dog"
      }
    }
  }
  feature {
    key: "feature3"
    value {
      float_list {
        value: -0.9885607957839966
      }
    }
  }
}

यही कारण है कि रिटर्न एक tf.train.Example आद्य जो उपयोग करने के लिए dificult है के रूप में है, लेकिन यह मूल रूप से एक का प्रतिनिधित्व है:

Dict[str,
     Union[List[float],
           List[int],
           List[str]]]

निम्नलिखित कोड मैन्युअल रूप से धर्मान्तरित Example , NumPy सरणी के एक शब्दकोश में TensorFlow ऑप्स का उपयोग किए बिना। का संदर्भ लें प्रोटो फ़ाइल detials के लिए।

result = {}
# example.features.feature is the dictionary
for key, feature in example.features.feature.items():
  # The values are the Feature objects which contain a `kind` which contains:
  # one of three fields: bytes_list, float_list, int64_list

  kind = feature.WhichOneof('kind')
  result[key] = np.array(getattr(feature, kind).value)

result
{'feature1': array([1]),
 'feature0': array([1]),
 'feature2': array([b'dog'], dtype='|S3'),
 'feature3': array([-0.9885608])}

पूर्वाभ्यास: छवि डेटा पढ़ना और लिखना

यह TFRecords का उपयोग करके छवि डेटा को पढ़ने और लिखने का एक एंड-टू-एंड उदाहरण है। इनपुट डेटा के रूप में एक छवि का उपयोग करके, आप डेटा को TFRecord फ़ाइल के रूप में लिखेंगे, फिर फ़ाइल को वापस पढ़ेंगे और छवि प्रदर्शित करेंगे।

यह उपयोगी हो सकता है, उदाहरण के लिए, आप एक ही इनपुट डेटासेट पर कई मॉडल का उपयोग करना चाहते हैं। छवि डेटा को कच्चे संग्रहीत करने के बजाय, इसे TFRecords प्रारूप में पूर्व-संसाधित किया जा सकता है, और इसका उपयोग आगे की सभी प्रसंस्करण और मॉडलिंग में किया जा सकता है।

सबसे पहले, के डाउनलोड करते हैं इस छवि को बर्फ में एक बिल्ली की और इस फोटो विलियम्सबर्ग ब्रिज, निर्माणाधीन NYC की।

चित्र प्राप्त करें

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
32768/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
24576/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>'))

जेपीईजी

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>'))

जेपीईजी

TFRecord फ़ाइल लिखें

पहले की तरह, के साथ संगत प्रकार के रूप में सुविधाओं सांकेतिक शब्दों में बदलना tf.train.Example । यह भंडार रॉ इमेज स्ट्रिंग सुविधा है, साथ ही ऊंचाई, चौड़ाई, गहराई, और मनमाने ढंग से label सुविधा। उत्तरार्द्ध का उपयोग तब किया जाता है जब आप बिल्ली की छवि और पुल की छवि के बीच अंतर करने के लिए फ़ाइल लिखते हैं। का प्रयोग करें 0 बिल्ली छवि के लिए, और 1 पुल छवि के लिए:

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.io.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
      }
...

सूचना है कि सुविधाओं के सभी अब में जमा हो जाती tf.train.Example संदेश। इसके बाद, उपरोक्त कोड functionalize और एक फ़ाइल नामित करने के लिए उदाहरण संदेश लिखने 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 फ़ाइल पढ़ें

अब आप फ़ाइल है images.tfrecords -और अब पुनरावृति पर में रिकॉर्ड वापस पढ़ने के लिए कर सकते हैं कि तुम क्या लिखा था। यह देखते हुए कि इस उदाहरण में आप केवल छवि को पुन: पेश करेंगे, केवल एक विशेषता जिसकी आपको आवश्यकता होगी वह है कच्ची छवि स्ट्रिंग। का उपयोग कर ही टिककर खेल ऊपर वर्णित यह निकालें, अर्थात् example.features.feature['image_raw'].bytes_list.value[0] । आप लेबल का उपयोग यह निर्धारित करने के लिए भी कर सकते हैं कि कौन सा रिकॉर्ड बिल्ली है और कौन सा पुल है:

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}>

TFRecord फ़ाइल से छवियों को पुनर्प्राप्त करें:

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

जेपीईजी

जेपीईजी