एवरो डेटासेट एपीआई

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.avro
ls -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.avsc
ls -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 पार्सर प्रकार:

तालिका 2 एवरो प्रकारों से TensorFlow के प्रकारों में समर्थित रूपांतरण:

एवरो डाटासेट एपीआई के उदाहरण के एक व्यापक सेट के भीतर प्रदान की जाती है परीक्षण ।