 TensorFlow.org पर देखें |  Google Colab में चलाएं |  GitHub पर स्रोत देखें |  नोटबुक डाउनलोड करें |
अवलोकन
एवरो डेटासेट एपीआई का उद्देश्य एवरो रूप TensorFlow में मूल रूप से डेटा फ़ॉर्मेट लोड करने के लिए है TensorFlow डाटासेट । एवरो प्रोटोकॉल बफ़र्स के समान एक डेटा क्रमांकन प्रणाली है। यह Apache Hadoop में व्यापक रूप से उपयोग किया जाता है जहां यह लगातार डेटा के लिए एक क्रमांकन प्रारूप और Hadoop नोड्स के बीच संचार के लिए एक तार प्रारूप दोनों प्रदान कर सकता है। एवरो डेटा एक पंक्ति-उन्मुख, संकुचित बाइनरी डेटा प्रारूप है। यह स्कीमा पर निर्भर करता है जिसे एक अलग JSON फ़ाइल के रूप में संग्रहीत किया जाता है। एवरो प्रारूप और स्कीमा घोषणा की कल्पना के लिए, का संदर्भ लें आधिकारिक मैनुअल ।
सेटअप पैकेज
आवश्यक टेंसरफ़्लो-आईओ पैकेज स्थापित करें
pip install tensorflow-io
पैकेज आयात करें
import tensorflow as tf
import tensorflow_io as tfio
मान्य tf और tfio आयात
print("tensorflow-io version: {}".format(tfio.__version__))
print("tensorflow version: {}".format(tf.__version__))
tensorflow-io version: 0.18.0 tensorflow version: 2.5.0
प्रयोग
डेटासेट का अन्वेषण करें
इस ट्यूटोरियल के प्रयोजन के लिए, आइए एवरो डेटासेट का नमूना डाउनलोड करें।
एक नमूना एवरो फ़ाइल डाउनलोड करें:
curl -OL https://github.com/tensorflow/io/raw/master/docs/tutorials/avro/train.avrols -l train.avro
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 151 100 151 0 0 1268 0 --:--:-- --:--:-- --:--:-- 1268
100 369 100 369 0 0 1255 0 --:--:-- --:--:-- --:--:-- 1255
-rw-rw-r-- 1 kbuilder kokoro 369 May 25 22:23 train.avro
नमूना एवरो फ़ाइल की संबंधित स्कीमा फ़ाइल डाउनलोड करें:
curl -OL https://github.com/tensorflow/io/raw/master/docs/tutorials/avro/train.avscls -l train.avsc
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 151 100 151 0 0 1247 0 --:--:-- --:--:-- --:--:-- 1247
100 271 100 271 0 0 780 0 --:--:-- --:--:-- --:--:-- 780
-rw-rw-r-- 1 kbuilder kokoro 271 May 25 22:23 train.avsc
उपरोक्त उदाहरण में, mnist डेटासेट के आधार पर एक परीक्षण एवरो डेटासेट बनाया गया था। TFRecord प्रारूप में मूल mnist डाटासेट से उत्पन्न होता है TF नामित डाटासेट । हालांकि, डेमो डेटासेट के रूप में mnist डेटासेट बहुत बड़ा है। सादगी के उद्देश्य से, इसके अधिकांश भाग को काट दिया गया था और पहले कुछ रिकॉर्ड केवल रखे गए थे। इसके अलावा, अतिरिक्त trimming के लिए किया गया था image मूल mnist डेटासेट में क्षेत्र और करने के लिए यह मैप किया features एवरो में क्षेत्र। तो एवरो फ़ाइल train.avro : 4 रिकॉर्ड, जिनमें से प्रत्येक 3 फ़ील्ड होते है features , जो पूर्णांक, की एक सरणी है label , एक पूर्णांक या शून्य, और dataType , एक enum। डीकोड को देखने के लिए train.avro (नोट मूल एवरो डेटा फ़ाइल मानव पठनीय रूप में एवरो एक ठोस स्वरूप है नहीं है):
एवरो फ़ाइल पढ़ने के लिए आवश्यक पैकेज स्थापित करें:
pip install avro
मानव-पठनीय प्रारूप में एवरो फ़ाइल को पढ़ने और प्रिंट करने के लिए:
from avro.io import DatumReader
from avro.datafile import DataFileReader
import json
def print_avro(avro_file, max_record_num=None):
if max_record_num is not None and max_record_num <= 0:
return
with open(avro_file, 'rb') as avro_handler:
reader = DataFileReader(avro_handler, DatumReader())
record_count = 0
for record in reader:
record_count = record_count+1
print(record)
if max_record_num is not None and record_count == max_record_num:
break
print_avro(avro_file='train.avro')
{'features': [0, 0, 0, 1, 4], 'label': None, 'dataType': 'TRAINING'}
{'features': [0, 0], 'label': 2, 'dataType': 'TRAINING'}
{'features': [0], 'label': 3, 'dataType': 'VALIDATION'}
{'features': [1], 'label': 4, 'dataType': 'VALIDATION'}
और स्कीमा train.avro जो का प्रतिनिधित्व करती है train.avsc JSON- प्रारूपण फ़ाइल है। देखने के लिए train.avsc :
def print_schema(avro_schema_file):
with open(avro_schema_file, 'r') as handle:
parsed = json.load(handle)
print(json.dumps(parsed, indent=4, sort_keys=True))
print_schema('train.avsc')
{
"fields": [
{
"name": "features",
"type": {
"items": "int",
"type": "array"
}
},
{
"name": "label",
"type": [
"int",
"null"
]
},
{
"name": "dataType",
"type": {
"name": "dataTypes",
"symbols": [
"TRAINING",
"VALIDATION"
],
"type": "enum"
}
}
],
"name": "ImageDataset",
"type": "record"
}
डेटासेट तैयार करें
लोड train.avro एवरो डाटासेट एपीआई के साथ TensorFlow डाटासेट के रूप में:
features = {
'features[*]': tfio.experimental.columnar.VarLenFeatureWithRank(dtype=tf.int32),
'label': tf.io.FixedLenFeature(shape=[], dtype=tf.int32, default_value=-100),
'dataType': tf.io.FixedLenFeature(shape=[], dtype=tf.string)
}
schema = tf.io.gfile.GFile('train.avsc').read()
dataset = tfio.experimental.columnar.make_avro_record_dataset(file_pattern=['train.avro'],
reader_schema=schema,
features=features,
shuffle=False,
batch_size=3,
num_epochs=1)
for record in dataset:
print(record['features[*]'])
print(record['label'])
print(record['dataType'])
print("--------------------")
SparseTensor(indices=tf.Tensor( [[0 0] [0 1] [0 2] [0 3] [0 4] [1 0] [1 1] [2 0]], shape=(8, 2), dtype=int64), values=tf.Tensor([0 0 0 1 4 0 0 0], shape=(8,), dtype=int32), dense_shape=tf.Tensor([3 5], shape=(2,), dtype=int64)) tf.Tensor([-100 2 3], shape=(3,), dtype=int32) tf.Tensor([b'TRAINING' b'TRAINING' b'VALIDATION'], shape=(3,), dtype=string) -------------------- SparseTensor(indices=tf.Tensor([[0 0]], shape=(1, 2), dtype=int64), values=tf.Tensor([1], shape=(1,), dtype=int32), dense_shape=tf.Tensor([1 1], shape=(2,), dtype=int64)) tf.Tensor([4], shape=(1,), dtype=int32) tf.Tensor([b'VALIDATION'], shape=(1,), dtype=string) --------------------
ऊपर के उदाहरण धर्मान्तरित train.avro tensorflow डाटासेट में। डेटासेट का प्रत्येक तत्व एक डिक्शनरी है जिसकी कुंजी फीचर नाम है, मान परिवर्तित विरल या सघन टेंसर है। उदाहरण के लिए, यह धर्मान्तरित features , label , dataType एक VarLenFeature (SparseTensor), FixedLenFeature (DenseTensor), और FixedLenFeature (DenseTensor) क्रमशः क्षेत्र। चूंकि batch_size 3 है, यह से 3 रिकॉर्ड विवश train.avro परिणाम डेटासेट में एक तत्व में। में पहली रिकॉर्ड के लिए train.avro जिसका लेबल रिक्त है, निर्दिष्ट डिफ़ॉल्ट मान (-100) के साथ एवरो पाठक की जगह यह। इस उदाहरण में, वहाँ में कुल 4 रिकॉर्ड कर रहे हैं train.avro । चूंकि बैच का आकार 3 है, परिणाम डाटासेट 3 तत्व है, जो की के अंतिम बैच का आकार 1. है हालांकि उपयोगकर्ता भी अंतिम बैच छोड़ने के लिए करता है, तो आकार को सक्षम करने से बैच आकार से छोटा होता है में सक्षम है शामिल drop_final_batch । जैसे:
dataset = tfio.experimental.columnar.make_avro_record_dataset(file_pattern=['train.avro'],
reader_schema=schema,
features=features,
shuffle=False,
batch_size=3,
drop_final_batch=True,
num_epochs=1)
for record in dataset:
print(record)
{'features[*]': <tensorflow.python.framework.sparse_tensor.SparseTensor object at 0x7f97656423d0>, 'dataType': <tf.Tensor: shape=(3,), dtype=string, numpy=array([b'TRAINING', b'TRAINING', b'VALIDATION'], dtype=object)>, 'label': <tf.Tensor: shape=(3,), dtype=int32, numpy=array([-100, 2, 3], dtype=int32)>}
एवरो पार्स/रीड पैरेललिज्म को बढ़ाकर एवरो डेटा प्रोसेसिंग में तेजी लाने के लिए num_parallel_reads को भी बढ़ाया जा सकता है।
dataset = tfio.experimental.columnar.make_avro_record_dataset(file_pattern=['train.avro'],
reader_schema=schema,
features=features,
shuffle=False,
num_parallel_reads=16,
batch_size=3,
drop_final_batch=True,
num_epochs=1)
for record in dataset:
print(record)
{'features[*]': <tensorflow.python.framework.sparse_tensor.SparseTensor object at 0x7f9765693990>, 'dataType': <tf.Tensor: shape=(3,), dtype=string, numpy=array([b'TRAINING', b'TRAINING', b'VALIDATION'], dtype=object)>, 'label': <tf.Tensor: shape=(3,), dtype=int32, numpy=array([-100, 2, 3], dtype=int32)>}
का विस्तृत उपयोग के लिए make_avro_record_dataset , का संदर्भ लें एपीआई दस्तावेज़ ।
एवरो डेटासेट के साथ tf.keras मॉडल को प्रशिक्षित करें
अब आइए mnist डेटासेट पर आधारित एवरो डेटासेट के साथ tf.keras मॉडल प्रशिक्षण के एंड-टू-एंड उदाहरण के माध्यम से चलते हैं।
लोड train.avro एवरो डाटासेट एपीआई के साथ TensorFlow डाटासेट के रूप में:
features = {
'features[*]': tfio.experimental.columnar.VarLenFeatureWithRank(dtype=tf.int32)
}
schema = tf.io.gfile.GFile('train.avsc').read()
dataset = tfio.experimental.columnar.make_avro_record_dataset(file_pattern=['train.avro'],
reader_schema=schema,
features=features,
shuffle=False,
batch_size=1,
num_epochs=1)
एक साधारण केरस मॉडल को परिभाषित करें:
def build_and_compile_cnn_model():
model = tf.keras.Sequential()
model.compile(optimizer='sgd', loss='mse')
return model
model = build_and_compile_cnn_model()
एवरो डेटासेट के साथ केरस मॉडल को प्रशिक्षित करें:
model.fit(x=dataset, epochs=1, steps_per_epoch=1, verbose=1)
WARNING:tensorflow:Layers in a Sequential model should only have a single input tensor, but we receive a <class 'dict'> input: {'features[*]': <tensorflow.python.framework.sparse_tensor.SparseTensor object at 0x7f94b00645d0>}
Consider rewriting this model with the Functional API.
WARNING:tensorflow:Layers in a Sequential model should only have a single input tensor, but we receive a <class 'dict'> input: {'features[*]': <tensorflow.python.framework.sparse_tensor.SparseTensor object at 0x7f976476ca90>}
Consider rewriting this model with the Functional API.
1/1 [==============================] - 0s 60ms/step - loss: 0.0000e+00
<tensorflow.python.keras.callbacks.History at 0x7f94ec08c6d0>
एवरो डेटासेट किसी भी एवरो डेटा को टेंसरफ्लो टेंसर में पार्स और ज़बरदस्ती कर सकता है, जिसमें रिकॉर्ड, मैप्स, एरेज़, ब्रांच और एन्यूमरेशन में रिकॉर्ड शामिल हैं। पार्सिंग जानकारी को एवरो डेटासेट कार्यान्वयन में एक मानचित्र के रूप में पारित किया जाता है, जहां कुंजी एन्कोड करती है कि डेटा मानों को कैसे पार्स करना है, डेटा को TensorFlow टेंसर में कैसे ज़बरदस्ती करना है - आदिम प्रकार (जैसे बूल, इंट, लॉन्ग, फ्लोट, डबल, स्ट्रिंग) का निर्धारण करना ) और साथ ही टेंसर प्रकार (जैसे विरल या सघन)। TensorFlow के पार्सर प्रकारों की एक सूची (तालिका 1 देखें) और आदिम प्रकारों (तालिका 2) के ज़बरदस्ती प्रदान की जाती है।
तालिका 1 समर्थित TensorFlow पार्सर प्रकार:
| TensorFlow पार्सर प्रकार | टेंसरफ्लो टेंसर | व्याख्या |
|---|---|---|
| tf.FixedLenFeature([], tf.int32) | सघन टेंसर | एक निश्चित लंबाई की विशेषता को पार्स करें; यानी सभी पंक्तियों में तत्वों की समान संख्या होती है, उदाहरण के लिए केवल एक तत्व या एक सरणी जिसमें प्रत्येक पंक्ति के लिए हमेशा समान संख्या में तत्व होते हैं |
| tf.SparseFeature(index_key=['key_1st_index', 'key_2nd_index'], value_key='key_value', dtype=tf.int64, size=[20, 50]) | विरल टेंसर | एक विरल विशेषता को पार्स करें जहां प्रत्येक पंक्ति में सूचकांकों और मूल्यों की एक चर लंबाई सूची होती है। 'index_key' सूचकांकों की पहचान करता है। 'Value_key' मान की पहचान करता है। 'Dtype' डेटा प्रकार है। प्रत्येक अनुक्रमणिका प्रविष्टि के लिए 'आकार' अपेक्षित अधिकतम अनुक्रमणिका मान है |
| tfio.experimental.columnar.VarLenFeatureWithRank([],tf.int64) | विरल टेंसर | एक चर लंबाई विशेषता पार्स करें; इसका मतलब है कि प्रत्येक डेटा पंक्ति में तत्वों की एक चर संख्या हो सकती है, उदाहरण के लिए पहली पंक्ति में 5 तत्व हैं, दूसरी पंक्ति में 7 तत्व हैं |
तालिका 2 एवरो प्रकारों से TensorFlow के प्रकारों में समर्थित रूपांतरण:
| एवरो आदिम प्रकार | TensorFlow आदिम प्रकार |
|---|---|
| बूलियन: एक बाइनरी मान | tf.बूल |
| बाइट्स: 8-बिट अहस्ताक्षरित बाइट्स का एक क्रम | tf.स्ट्रिंग |
| डबल: डबल सटीक 64-बिट आईईईई फ्लोटिंग पॉइंट नंबर | tf.float64 |
| एनम: एन्यूमरेशन टाइप | tf.string प्रतीक नाम का उपयोग कर |
| फ्लोट: एकल परिशुद्धता 32-बिट आईईईई फ्लोटिंग पॉइंट नंबर | tf.float32 |
| int: 32-बिट हस्ताक्षरित पूर्णांक | tf.int32 |
| लंबा: 64-बिट हस्ताक्षरित पूर्णांक | tf.int64 |
| शून्य: कोई मूल्य नहीं | डिफ़ॉल्ट मान का उपयोग करता है |
| स्ट्रिंग: यूनिकोड वर्ण अनुक्रम | tf.स्ट्रिंग |
एवरो डाटासेट एपीआई के उदाहरण के एक व्यापक सेट के भीतर प्रदान की जाती है परीक्षण ।