अपने स्थानीय TensorFlow के लिए RSVP आज हर जगह घटना!
इस पेज का अनुवाद Cloud Translation API से किया गया है.
Switch to English

TFRecord और tf.train.Example

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

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

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

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

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

यह नोटबुक tf.train.Example संदेश बनाने, पार्स करने और tf.train.Example उपयोग करने का तरीका प्रदर्शित करेगी, और फिर 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 (निम्न प्रकार tf.train.BytesList जा सकते हैं)

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

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

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

एक मानक TensorFlow प्रकार को tf.train में बदलने के लिए 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) जैसे _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 में tf.train.Feature । 3 संगत प्रकारों में से एक को शामिल करें। ऊपर दिए गए कार्यों में से एक का उपयोग करके।

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

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

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

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

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

उपरोक्त वितरण में से प्रत्येक से 10,000 स्वतंत्र रूप से और अनौपचारिक रूप से वितरित टिप्पणियों से मिलकर एक नमूने पर विचार करें:

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

संदेश को डीकोड करने के लिए 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 फ़ाइल में रिकॉर्ड का एक क्रम होता है। फ़ाइल को केवल क्रमिक रूप से पढ़ा जा सकता है।

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

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

uint64 length
uint32 masked_crc32_of_length
byte   data[length]
uint32 masked_crc32_of_data

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

0 बी 8 बी 547860

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(False, shape=(), dtype=bool)
tf.Tensor(0, shape=(), dtype=int64)
tf.Tensor(b'cat', shape=(), dtype=string)
tf.Tensor(-0.07564599618591197, shape=(), dtype=float64)

Dataset प्रत्येक तत्व पर फ़ंक्शन लागू करने के लिए tf.data.Dataset.map विधि का उपयोग करें।

मैप किए गए फ़ंक्शन को TensorFlow ग्राफ मोड में काम करना चाहिए - इसे tf.Tensors पर और वापस लौटना 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\x13\n\x08feature2\x12\x07\n\x05\n\x03cat\n\x14\n\x08feature3\x12\x08\x12\x06\n\x04J\xec\x9a\xbd\n\x11\n\x08feature1\x12\x05\x1a\x03\n\x01\x00\n\x11\n\x08feature0\x12\x05\x1a\x03\n\x01\x00'>

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

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)

एक TFRecord फ़ाइल पढ़ना

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

Tf.data का उपयोग करके tf.data फ़ाइलों के उपभोग के बारे में अधिक जानकारी यहां पाई जा सकती है

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

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

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

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

for raw_record in raw_dataset.take(10):
  print(repr(raw_record))
<tf.Tensor: shape=(), dtype=string, numpy=b'\nQ\n\x13\n\x08feature2\x12\x07\n\x05\n\x03cat\n\x14\n\x08feature3\x12\x08\x12\x06\n\x04J\xec\x9a\xbd\n\x11\n\x08feature0\x12\x05\x1a\x03\n\x01\x00\n\x11\n\x08feature1\x12\x05\x1a\x03\n\x01\x00'>
<tf.Tensor: shape=(), dtype=string, numpy=b'\nS\n\x15\n\x08feature2\x12\t\n\x07\n\x05horse\n\x14\n\x08feature3\x12\x08\x12\x06\n\x04\x1f\xe0\xcb?\n\x11\n\x08feature0\x12\x05\x1a\x03\n\x01\x00\n\x11\n\x08feature1\x12\x05\x1a\x03\n\x01\x03'>
<tf.Tensor: shape=(), dtype=string, numpy=b'\nU\n\x11\n\x08feature0\x12\x05\x1a\x03\n\x01\x01\n\x14\n\x08feature3\x12\x08\x12\x06\n\x04q\xa9\xb8>\n\x17\n\x08feature2\x12\x0b\n\t\n\x07chicken\n\x11\n\x08feature1\x12\x05\x1a\x03\n\x01\x02'>
<tf.Tensor: shape=(), dtype=string, numpy=b'\nU\n\x11\n\x08feature0\x12\x05\x1a\x03\n\x01\x00\n\x14\n\x08feature3\x12\x08\x12\x06\n\x04\x93|+?\n\x17\n\x08feature2\x12\x0b\n\t\n\x07chicken\n\x11\n\x08feature1\x12\x05\x1a\x03\n\x01\x02'>
<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\xa0X}?\n\x14\n\x08feature2\x12\x08\n\x06\n\x04goat\n\x11\n\x08feature1\x12\x05\x1a\x03\n\x01\x04'>
<tf.Tensor: shape=(), dtype=string, numpy=b'\nU\n\x14\n\x08feature3\x12\x08\x12\x06\n\x04[\x19\x11\xc0\n\x11\n\x08feature1\x12\x05\x1a\x03\n\x01\x02\n\x17\n\x08feature2\x12\x0b\n\t\n\x07chicken\n\x11\n\x08feature0\x12\x05\x1a\x03\n\x01\x01'>
<tf.Tensor: shape=(), dtype=string, numpy=b'\nS\n\x15\n\x08feature2\x12\t\n\x07\n\x05horse\n\x14\n\x08feature3\x12\x08\x12\x06\n\x0473\x12>\n\x11\n\x08feature1\x12\x05\x1a\x03\n\x01\x03\n\x11\n\x08feature0\x12\x05\x1a\x03\n\x01\x00'>
<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\x00\n\x11\n\x08feature1\x12\x05\x1a\x03\n\x01\x01\n\x14\n\x08feature3\x12\x08\x12\x06\n\x04\xa2\xf7\xf9>'>
<tf.Tensor: shape=(), dtype=string, numpy=b'\nR\n\x11\n\x08feature0\x12\x05\x1a\x03\n\x01\x00\n\x14\n\x08feature2\x12\x08\n\x06\n\x04goat\n\x11\n\x08feature1\x12\x05\x1a\x03\n\x01\x04\n\x14\n\x08feature3\x12\x08\x12\x06\n\x04\xba\xf8\xb1?'>
<tf.Tensor: shape=(), dtype=string, numpy=b'\nQ\n\x11\n\x08feature1\x12\x05\x1a\x03\n\x01\x00\n\x11\n\x08feature0\x12\x05\x1a\x03\n\x01\x01\n\x14\n\x08feature3\x12\x08\x12\x06\n\x04\xb71\xe5>\n\x13\n\x08feature2\x12\x07\n\x05\n\x03cat'>

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

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

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

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=0>, 'feature2': <tf.Tensor: shape=(), dtype=string, numpy=b'cat'>, 'feature3': <tf.Tensor: shape=(), dtype=float32, numpy=-0.075646>}
{'feature0': <tf.Tensor: shape=(), dtype=int64, numpy=0>, 'feature1': <tf.Tensor: shape=(), dtype=int64, numpy=3>, 'feature2': <tf.Tensor: shape=(), dtype=string, numpy=b'horse'>, 'feature3': <tf.Tensor: shape=(), dtype=float32, numpy=1.5927771>}
{'feature0': <tf.Tensor: shape=(), dtype=int64, numpy=1>, '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.36066774>}
{'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.6698696>}
{'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.98963356>}
{'feature0': <tf.Tensor: shape=(), dtype=int64, numpy=1>, 'feature1': <tf.Tensor: shape=(), dtype=int64, numpy=2>, 'feature2': <tf.Tensor: shape=(), dtype=string, numpy=b'chicken'>, 'feature3': <tf.Tensor: shape=(), dtype=float32, numpy=-2.2671726>}
{'feature0': <tf.Tensor: shape=(), dtype=int64, numpy=0>, '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.1427735>}
{'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.4882174>}
{'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=1.390403>}
{'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.44764492>}

यहां, tf.parse_example फ़ंक्शन tf.train.Example फ़ील्ड को मानक tf.train.Example में tf.parse_example करता है।

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

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

TFRecord फ़ाइल लिखना

इसके बाद, फ़ाइल test.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 फ़ाइल पढ़ना

ये क्रमबद्ध 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: 0
      }
    }
  }
  feature {
    key: "feature1"
    value {
      int64_list {
        value: 0
      }
    }
  }
  feature {
    key: "feature2"
    value {
      bytes_list {
        value: "cat"
      }
    }
  }
  feature {
    key: "feature3"
    value {
      float_list {
        value: -0.07564599812030792
      }
    }
  }
}


वॉकथ्रू: छवि डेटा पढ़ना और लिखना

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

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

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

छवियों को प्राप्त करें

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

जेपीईजी

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 के साथ संगत प्रकारों में 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.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
      }
...

ध्यान दें कि सभी सुविधाएँ अब tf.train.Example संदेश में संग्रहीत हैं। इसके बाद, ऊपर दिए गए कोड को फंक्शनल करें और 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] का उपयोग करके इसे निकालें, 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))
पर

जेपीईजी

जेपीईजी