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

CSV डेटा लोड करें

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

यह ट्यूटोरियल TensorFlow के साथ CSV डेटा का उपयोग करने के तरीके का उदाहरण प्रदान करता है।

इसके दो मुख्य भाग हैं:

  1. डेटा ऑफ डिस्क लोड हो रहा है
  2. प्रशिक्षण के लिए उपयुक्त रूप में इसे पूर्व-प्रसंस्करण करना।

यह ट्यूटोरियल लोडिंग पर ध्यान केंद्रित करता है, और प्रीप्रोसेसिंग के कुछ त्वरित उदाहरण देता है। प्रीप्रोसेसिंग पहलू पर केंद्रित एक ट्यूटोरियल के लिए प्रीप्रोसेसिंग लेयर गाइड और ट्यूटोरियल देखें

सेट अप

import pandas as pd
import numpy as np

# Make numpy values easier to read.
np.set_printoptions(precision=3, suppress=True)

import tensorflow as tf
from tensorflow.keras import layers
from tensorflow.keras.layers.experimental import preprocessing

मेमोरी डेटा में

किसी भी छोटे CSV डेटासेट के लिए एक TensorFlow मॉडल को प्रशिक्षित करने का सबसे सरल तरीका यह है कि इसे मेमोरी में एक पांडा डेटाफ़्रेम या एक न्यूपी सरणी के रूप में लोड किया जाए।

एक अपेक्षाकृत सरल उदाहरण है अबालोन डेटासेट

  • डेटासेट छोटा है।
  • सभी इनपुट विशेषताएं सभी सीमित-सीमा फ़्लोटिंग पॉइंट मान हैं।

यहां पंडों के DataFrame में डेटा डाउनलोड करने का तरीका DataFrame :

097e88b20

डेटासेट में एबालोन , समुद्री घोंघे का एक प्रकार का माप होता है।

एक अबेलोन शेल

"अबालोन शेल" ( निकी दुगन पोग , सीसी बाय-एसए 2.0 द्वारा)

इस डेटासेट के लिए नाममात्र का कार्य अन्य मापों से आयु की भविष्यवाणी करना है, इसलिए प्रशिक्षण के लिए सुविधाओं और लेबल को अलग करें:

abalone_features = abalone_train.copy()
abalone_labels = abalone_features.pop('Age')

इस डेटासेट के लिए आप सभी विशेषताओं को समान रूप से मानेंगे। एक एकल NumPy सरणी में सुविधाओं को पैक करें।:

abalone_features = np.array(abalone_features)
abalone_features
array([[0.435, 0.335, 0.11 , ..., 0.136, 0.077, 0.097],
       [0.585, 0.45 , 0.125, ..., 0.354, 0.207, 0.225],
       [0.655, 0.51 , 0.16 , ..., 0.396, 0.282, 0.37 ],
       ...,
       [0.53 , 0.42 , 0.13 , ..., 0.374, 0.167, 0.249],
       [0.395, 0.315, 0.105, ..., 0.118, 0.091, 0.119],
       [0.45 , 0.355, 0.12 , ..., 0.115, 0.067, 0.16 ]])

अगला एक प्रतिगमन मॉडल की आयु की भविष्यवाणी करें। चूंकि केवल एक एकल इनपुट टेंसर है, यहां एक keras.Sequential मॉडल पर्याप्त है।

abalone_model = tf.keras.Sequential([
  layers.Dense(64),
  layers.Dense(1)
])

abalone_model.compile(loss = tf.losses.MeanSquaredError(),
                      optimizer = tf.optimizers.Adam())

उस मॉडल को प्रशिक्षित करने के लिए, Model.fit में सुविधाओं और लेबलों को Model.fit :

abalone_model.fit(abalone_features, abalone_labels, epochs=10)
Epoch 1/10
104/104 [==============================] - 0s 1ms/step - loss: 60.2584
Epoch 2/10
104/104 [==============================] - 0s 1ms/step - loss: 11.4741
Epoch 3/10
104/104 [==============================] - 0s 1ms/step - loss: 8.5354
Epoch 4/10
104/104 [==============================] - 0s 1ms/step - loss: 8.0559
Epoch 5/10
104/104 [==============================] - 0s 1ms/step - loss: 7.6156
Epoch 6/10
104/104 [==============================] - 0s 1ms/step - loss: 7.2644
Epoch 7/10
104/104 [==============================] - 0s 1ms/step - loss: 6.9853
Epoch 8/10
104/104 [==============================] - 0s 1ms/step - loss: 6.7824
Epoch 9/10
104/104 [==============================] - 0s 1ms/step - loss: 6.6324
Epoch 10/10
104/104 [==============================] - 0s 1ms/step - loss: 6.5348

<tensorflow.python.keras.callbacks.History at 0x7f3f74717080>

आपने CSV डेटा का उपयोग करके किसी मॉडल को प्रशिक्षित करने का सबसे बुनियादी तरीका देखा है। अगला, आप सीखेंगे कि संख्यात्मक कॉलम को सामान्य करने के लिए प्रीप्रोसेसिंग कैसे लागू करें।

बेसिक प्रीप्रोसेसिंग

अपने मॉडल के इनपुट को सामान्य बनाने के लिए यह अच्छा अभ्यास है। experimental.preprocessing परतें आपके मॉडल में इस सामान्यीकरण का निर्माण करने का एक सुविधाजनक तरीका प्रदान करती हैं।

परत प्रत्येक स्तंभ के माध्य और विचरण को पूर्ववर्ती करेगी और डेटा को सामान्य करने के लिए इनका उपयोग करेगी।

सबसे पहले आप परत बनाएँ:

normalize = preprocessing.Normalization()

फिर आप अपने डेटा के सामान्यीकरण परत को अनुकूलित करने के लिए Normalization.adapt() विधि का उपयोग करते हैं।

normalize.adapt(abalone_features)

फिर अपने मॉडल में सामान्यीकरण परत का उपयोग करें:

norm_abalone_model = tf.keras.Sequential([
  normalize,
  layers.Dense(64),
  layers.Dense(1)
])

norm_abalone_model.compile(loss = tf.losses.MeanSquaredError(),
                           optimizer = tf.optimizers.Adam())

norm_abalone_model.fit(abalone_features, abalone_labels, epochs=10)
Epoch 1/10
104/104 [==============================] - 0s 2ms/step - loss: 93.4577
Epoch 2/10
104/104 [==============================] - 0s 1ms/step - loss: 54.7412
Epoch 3/10
104/104 [==============================] - 0s 2ms/step - loss: 16.7861
Epoch 4/10
104/104 [==============================] - 0s 2ms/step - loss: 5.8002
Epoch 5/10
104/104 [==============================] - 0s 1ms/step - loss: 4.9725
Epoch 6/10
104/104 [==============================] - 0s 1ms/step - loss: 4.9332
Epoch 7/10
104/104 [==============================] - 0s 1ms/step - loss: 4.9074
Epoch 8/10
104/104 [==============================] - 0s 1ms/step - loss: 4.9035
Epoch 9/10
104/104 [==============================] - 0s 1ms/step - loss: 4.9028
Epoch 10/10
104/104 [==============================] - 0s 1ms/step - loss: 4.8998

<tensorflow.python.keras.callbacks.History at 0x7f3f7454f4e0>

मिश्रित डेटा प्रकार

"टाइटैनिक" डेटासेट में टाइटैनिक पर यात्रियों के बारे में जानकारी होती है। इस डेटासेट पर नाममात्र का कार्य भविष्यवाणी करना है कि कौन बच गया।

भीमकाय

विकिमीडिया से छवि

कच्चे डेटा को आसानी से पंडों के DataFrame रूप में लोड किया जा सकता है, लेकिन TensorFlow मॉडल के इनपुट के रूप में तुरंत उपयोग करने योग्य नहीं है।

titanic = pd.read_csv("https://storage.googleapis.com/tf-datasets/titanic/train.csv")
titanic.head()
titanic_features = titanic.copy()
titanic_labels = titanic_features.pop('survived')

विभिन्न प्रकार के डेटा और श्रेणी के कारण आप केवल सुविधाओं को NumPy सरणी में नहीं रख सकते हैं और इसे keras.Sequential मॉडल में पास कर सकते हैं। प्रत्येक स्तंभ को व्यक्तिगत रूप से नियंत्रित करने की आवश्यकता है।

एक विकल्प के रूप में, आप श्रेणीबद्ध कॉलमों को संख्यात्मक कॉलम में बदलने के लिए अपने डेटा ऑफ़लाइन (किसी भी उपकरण का उपयोग करके) का उपयोग कर सकते हैं, फिर संसाधित आउटपुट को अपने TensorFlow मॉडल में पास कर सकते हैं। उस दृष्टिकोण का नुकसान यह है कि यदि आप अपने मॉडल को सहेजते और निर्यात करते हैं तो प्रीप्रोसेसिंग इसके साथ नहीं बचा है। experimental.preprocessing परतें इस समस्या से बचती हैं क्योंकि वे मॉडल का हिस्सा हैं।

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

कार्यात्मक एपीआई "प्रतीकात्मक" टेंसर्स पर काम करता है। सामान्य "उत्सुक" टेंसरों का एक मूल्य है। इसके विपरीत ये "प्रतीकात्मक" टेंसर्स नहीं करते हैं। इसके बजाय वे ट्रैक करते हैं कि उन पर कौन से ऑपरेशन चलाए जाते हैं, और गणना का प्रतिनिधित्व बनाते हैं, जिसे आप बाद में चला सकते हैं। यहाँ एक त्वरित उदाहरण है:

# Create a symbolic input
input = tf.keras.Input(shape=(), dtype=tf.float32)

# Do a calculation using is
result = 2*input + 1

# the result doesn't have a value
result
<tf.Tensor 'AddV2:0' shape=(None,) dtype=float32>
calc = tf.keras.Model(inputs=input, outputs=result)
print(calc(1).numpy())
print(calc(2).numpy())
3.0
5.0

प्रीप्रोसेसिंग मॉडल का निर्माण करने के लिए, प्रतीकात्मक keras.Input वस्तुओं का एक सेट बनाकर शुरू करें, CSV कॉलम के नाम और डेटा-प्रकारों का मिलान करें।

0bb5faf70
{'sex': <tf.Tensor 'sex:0' shape=(None, 1) dtype=string>,
 'age': <tf.Tensor 'age:0' shape=(None, 1) dtype=float32>,
 'n_siblings_spouses': <tf.Tensor 'n_siblings_spouses:0' shape=(None, 1) dtype=float32>,
 'parch': <tf.Tensor 'parch:0' shape=(None, 1) dtype=float32>,
 'fare': <tf.Tensor 'fare:0' shape=(None, 1) dtype=float32>,
 'class': <tf.Tensor 'class:0' shape=(None, 1) dtype=string>,
 'deck': <tf.Tensor 'deck:0' shape=(None, 1) dtype=string>,
 'embark_town': <tf.Tensor 'embark_town:0' shape=(None, 1) dtype=string>,
 'alone': <tf.Tensor 'alone:0' shape=(None, 1) dtype=string>}

आपके प्रीप्रोसेसिंग लॉजिक में पहला कदम न्यूमेरिकल इनपुट्स को एक साथ जोड़ना है, और उन्हें एक नॉर्मलाइज़ेशन लेयर के माध्यम से चलाना है:

numeric_inputs = {name:input for name,input in inputs.items()
                  if input.dtype==tf.float32}

x = layers.Concatenate()(list(numeric_inputs.values()))
norm = preprocessing.Normalization()
norm.adapt(np.array(titanic[numeric_inputs.keys()]))
all_numeric_inputs = norm(x)

all_numeric_inputs
<tf.Tensor 'normalization_1/truediv:0' shape=(None, 4) dtype=float32>

बाद में उन्हें संक्षिप्त करने के लिए, सभी प्रतीकात्मक प्रीप्रोसेसिंग परिणाम एकत्र करें।

preprocessed_inputs = [all_numeric_inputs]

स्ट्रिंग इनपुट के लिए preprocessing.StringLookup उपयोग करें। शब्द में एक स्ट्रिंग से पूर्णांक सूचकांकों तक मैप करने के लिए स्ट्रिंग फ़ंक्शन। अगले, preprocessing.CategoryEncoding का उपयोग करें मॉडल के लिए उपयुक्त float32 डेटा में अनुक्रमणिका परिवर्तित करने के लिए।

preprocessing.CategoryEncoding परत के लिए डिफ़ॉल्ट सेटिंग्स प्रत्येक इनपुट के लिए एक-गर्म वेक्टर बनाती हैं। एक layers.Embeddinglayers.Embedding भी काम करेगी। इस विषय पर अधिक के लिए प्रीप्रोसेसिंग लेयर गाइड और ट्यूटोरियल देखें।

for name, input in inputs.items():
  if input.dtype == tf.float32:
    continue

  lookup = preprocessing.StringLookup(vocabulary=np.unique(titanic_features[name]))
  one_hot = preprocessing.CategoryEncoding(max_tokens=lookup.vocab_size())

  x = lookup(input)
  x = one_hot(x)
  preprocessed_inputs.append(x)
है

inputs और processed_inputs के संग्रह के साथ, आप सभी प्रीप्रोसेसर इनपुट्स को एक साथ मिला सकते हैं, और एक मॉडल का निर्माण कर सकते हैं जो प्रीप्रोसेसिंग को हैंडल करता है:

preprocessed_inputs_cat = layers.Concatenate()(preprocessed_inputs)

titanic_preprocessing = tf.keras.Model(inputs, preprocessed_inputs_cat)

tf.keras.utils.plot_model(model = titanic_preprocessing , rankdir="LR", dpi=72, show_shapes=True)

पींग

इस model सिर्फ इनपुट प्रीप्रोसेसिंग है। आप इसे यह देखने के लिए चला सकते हैं कि यह आपके डेटा का क्या करता है। केरेस मॉडल स्वचालित रूप से पंडों DataFrames परिवर्तित नहीं करते हैं क्योंकि यह स्पष्ट नहीं है कि इसे एक DataFrames शब्दकोश में परिवर्तित किया जाना चाहिए। तो इसे दसियों के शब्दकोश में परिवर्तित करें:

titanic_features_dict = {name: np.array(value) 
                         for name, value in titanic_features.items()}

पहले प्रशिक्षण उदाहरण को स्लाइस करें और इसे इस प्रीप्रोसेसिंग मॉडल में पास करें, आपको संख्यात्मक विशेषताएं और स्ट्रिंग वन-हॉट्स सभी एक साथ मिलेंगे:

features_dict = {name:values[:1] for name, values in titanic_features_dict.items()}
titanic_preprocessing(features_dict)
<tf.Tensor: shape=(1, 33), dtype=float32, numpy=
array([[-0.61 ,  0.395, -0.479, -0.497,  0.   ,  0.   ,  0.   ,  1.   ,

         0.   ,  0.   ,  0.   ,  0.   ,  1.   ,  0.   ,  0.   ,  0.   ,
         0.   ,  0.   ,  0.   ,  0.   ,  0.   ,  0.   ,  1.   ,  0.   ,
         0.   ,  0.   ,  0.   ,  1.   ,  0.   ,  0.   ,  0.   ,  1.   ,
         0.   ]], dtype=float32)>

अब इसके शीर्ष पर मॉडल बनाएँ:

0546868230

जब आप मॉडल को प्रशिक्षित करते हैं, तो सुविधाओं के शब्दकोश को x और लेबल को y रूप में पास करें।

titanic_model.fit(x=titanic_features_dict, y=titanic_labels, epochs=10)
Epoch 1/10
20/20 [==============================] - 0s 3ms/step - loss: 0.6595
Epoch 2/10
20/20 [==============================] - 0s 3ms/step - loss: 0.5576
Epoch 3/10
20/20 [==============================] - 0s 3ms/step - loss: 0.5002
Epoch 4/10
20/20 [==============================] - 0s 3ms/step - loss: 0.4719
Epoch 5/10
20/20 [==============================] - 0s 3ms/step - loss: 0.4533
Epoch 6/10
20/20 [==============================] - 0s 3ms/step - loss: 0.4415
Epoch 7/10
20/20 [==============================] - 0s 3ms/step - loss: 0.4346
Epoch 8/10
20/20 [==============================] - 0s 3ms/step - loss: 0.4299
Epoch 9/10
20/20 [==============================] - 0s 3ms/step - loss: 0.4285
Epoch 10/10
20/20 [==============================] - 0s 3ms/step - loss: 0.4261

<tensorflow.python.keras.callbacks.History at 0x7f3f74239b70>

चूंकि प्रीप्रोसेसिंग मॉडल का हिस्सा है, आप मॉडल को बचा सकते हैं और इसे कहीं और लोड कर सकते हैं और समान परिणाम प्राप्त कर सकते हैं:

titanic_model.save('test')
reloaded = tf.keras.models.load_model('test')
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/tracking/tracking.py:111: Model.state_updates (from tensorflow.python.keras.engine.training) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/tracking/tracking.py:111: Layer.updates (from tensorflow.python.keras.engine.base_layer) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.
INFO:tensorflow:Assets written to: test/assets
WARNING:tensorflow:5 out of the last 5 calls to <function recreate_function.<locals>.restored_function_body at 0x7f3f60030950> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/tutorials/customization/performance#python_or_tensor_args and https://www.tensorflow.org/api_docs/python/tf/function for  more details.

features_dict = {name:values[:1] for name, values in titanic_features_dict.items()}

before = titanic_model(features_dict)
after = reloaded(features_dict)
assert (before-after)<1e-3
print(before)
print(after)
tf.Tensor([[-1.903]], shape=(1, 1), dtype=float32)
tf.Tensor([[-1.903]], shape=(1, 1), dtype=float32)

Tf.data का उपयोग करना

पिछले अनुभाग में आपने मॉडल का निर्माण करते समय मॉडल के अंतर्निहित डेटा फेरबदल और बैचिंग पर भरोसा किया था।

यदि आपको इनपुट डेटा पाइपलाइन पर अधिक नियंत्रण की आवश्यकता है या डेटा का उपयोग करने की आवश्यकता है जो आसानी से मेमोरी में फिट नहीं होता है: tf.data उपयोग tf.data

अधिक उदाहरणों के लिए tf.data गाइड देखें।

मेमोरी डाटा में

CSV डेटा में tf.data को लागू करने के पहले उदाहरण के रूप में पिछले अनुभाग से सुविधाओं के शब्दकोश को मैन्युअल रूप से स्लाइस करने के लिए निम्न कोड पर विचार करें। प्रत्येक सूचकांक के लिए, यह प्रत्येक सुविधा के लिए उस सूचकांक को लेता है:

import itertools

def slices(features):
  for i in itertools.count():
    # For each feature take index `i`
    example = {name:values[i] for name, values in features.items()}
    yield example

इसे चलाएं और पहला उदाहरण प्रिंट करें:

for example in slices(titanic_features_dict):
  for name, value in example.items():
    print(f"{name:19s}: {value}")
  break
sex                : male
age                : 22.0
n_siblings_spouses : 1
parch              : 0
fare               : 7.25
class              : Third
deck               : unknown
embark_town        : Southampton
alone              : n

मेमोरी डेटा लोडर में सबसे बुनियादीtf.data.Dataset Dataset.from_tensor_slices कंस्ट्रक्टर है। यह एकtf.data.Dataset देता है जोtf.data.Dataset में उपरोक्त slices फ़ंक्शन के एक सामान्यीकृत संस्करण को लागू करता है।

features_ds = tf.data.Dataset.from_tensor_slices(titanic_features_dict)

आप किसी भी अन्य अजगर की तरह एकtf.data.Dataset पर पुनरावृति कर सकते हैं:

for example in features_ds:
  for name, value in example.items():
    print(f"{name:19s}: {value}")
  break
sex                : b'male'
age                : 22.0
n_siblings_spouses : 1
parch              : 0
fare               : 7.25
class              : b'Third'
deck               : b'unknown'
embark_town        : b'Southampton'
alone              : b'n'

from_tensor_slices फ़ंक्शन नेस्टेड शब्दकोशों या ट्यूपल्स की किसी भी संरचना को संभाल सकता है। निम्न कोड (features_dict, labels) जोड़े का डेटासेट बनाता है:

titanic_ds = tf.data.Dataset.from_tensor_slices((titanic_features_dict, titanic_labels))

एक मॉडल इस का उपयोग कर प्रशिक्षित करने के लिए Dataset , आप कम से कम करने की आवश्यकता होगी shuffle और batch डेटा।

titanic_batches = titanic_ds.shuffle(len(titanic_labels)).batch(32)

Model.fit features और labels को पास करने के Model.fit , आप डेटासेट पास करते हैं:

titanic_model.fit(titanic_batches, epochs=5)
Epoch 1/5
20/20 [==============================] - 0s 4ms/step - loss: 0.4233
Epoch 2/5
20/20 [==============================] - 0s 4ms/step - loss: 0.4223
Epoch 3/5
20/20 [==============================] - 0s 4ms/step - loss: 0.4225
Epoch 4/5
20/20 [==============================] - 0s 4ms/step - loss: 0.4213
Epoch 5/5
20/20 [==============================] - 0s 4ms/step - loss: 0.4209

<tensorflow.python.keras.callbacks.History at 0x7f3f680cd9b0>

एक सिंगल फाइल से

अब तक इस ट्यूटोरियल ने इन-मेमोरी डेटा के साथ काम किया है। tf.data डेटा पाइपलाइनों के निर्माण के लिए एक अत्यधिक स्केलेबल टूलकिट है, और लोडिंग CSV फ़ाइलों से निपटने के लिए कुछ फ़ंक्शन प्रदान करता है।

titanic_file_path = tf.keras.utils.get_file("train.csv", "https://storage.googleapis.com/tf-datasets/titanic/train.csv")
Downloading data from https://storage.googleapis.com/tf-datasets/titanic/train.csv
32768/30874 [===============================] - 0s 0us/step

अब फ़ाइल से CSV डेटा पढ़ें औरtf.data.Dataset

(पूर्ण प्रलेखन के लिए, tf.data.experimental.make_csv_dataset देखें)

titanic_csv_ds = tf.data.experimental.make_csv_dataset(
    titanic_file_path,
    batch_size=5, # Artificially small to make examples easier to show.
    label_name='survived',
    num_epochs=1,
    ignore_errors=True,)

इस फ़ंक्शन में कई सुविधाजनक विशेषताएं शामिल हैं ताकि डेटा के साथ काम करना आसान हो। यह भी शामिल है:

  • शब्दकोश कुंजी के रूप में कॉलम हेडर का उपयोग करना।
  • प्रत्येक स्तंभ के प्रकार को स्वचालित रूप से निर्धारित करना।
for batch, label in titanic_csv_ds.take(1):
  for key, value in batch.items():
    print(f"{key:20s}: {value}")
  print()
  print(f"{'label':20s}: {label}")
sex                 : [b'male' b'male' b'female' b'male' b'female']
age                 : [28. 11. 29. 28. 34.]
n_siblings_spouses  : [1 0 1 0 0]
parch               : [0 0 0 0 0]
fare                : [ 24.15   18.788  26.    221.779  10.5  ]
class               : [b'Third' b'Third' b'Second' b'First' b'Second']
deck                : [b'unknown' b'unknown' b'unknown' b'C' b'F']
embark_town         : [b'Queenstown' b'Cherbourg' b'Southampton' b'Southampton' b'Southampton']
alone               : [b'n' b'y' b'n' b'y' b'y']

label               : [0 0 1 0 1]

यह मक्खी के डेटा को भी डिकम्पोज कर सकता है। यहाँ एक gzipped CSV फ़ाइल है जिसमें मेट्रो अंतरराज्यीय ट्रैफ़िक डेटासेट है

ट्रैफ़िक जाम।

विकिमीडिया से छवि

traffic_volume_csv_gz = tf.keras.utils.get_file(
    'Metro_Interstate_Traffic_Volume.csv.gz', 
    "https://archive.ics.uci.edu/ml/machine-learning-databases/00492/Metro_Interstate_Traffic_Volume.csv.gz",
    cache_dir='.', cache_subdir='traffic')
Downloading data from https://archive.ics.uci.edu/ml/machine-learning-databases/00492/Metro_Interstate_Traffic_Volume.csv.gz
409600/405373 [==============================] - 1s 2us/step

संपीड़ित फ़ाइल से सीधे पढ़ने के लिए compression_type तर्क सेट करें:

traffic_volume_csv_gz_ds = tf.data.experimental.make_csv_dataset(
    traffic_volume_csv_gz,
    batch_size=256,
    label_name='traffic_volume',
    num_epochs=1,
    compression_type="GZIP")

for batch, label in traffic_volume_csv_gz_ds.take(1):
  for key, value in batch.items():
    print(f"{key:20s}: {value[:5]}")
  print()
  print(f"{'label':20s}: {label[:5]}")
holiday             : [b'None' b'None' b'None' b'None' b'None']
temp                : [280.66 283.22 284.23 280.7  287.79]
rain_1h             : [0. 0. 0. 0. 0.]
snow_1h             : [0. 0. 0. 0. 0.]
clouds_all          : [92 90 90 64 75]
weather_main        : [b'Mist' b'Drizzle' b'Rain' b'Clouds' b'Clouds']
weather_description : [b'mist' b'light intensity drizzle' b'light rain' b'broken clouds'
 b'broken clouds']
date_time           : [b'2012-10-19 21:00:00' b'2012-10-25 21:00:00' b'2013-05-23 16:00:00'
 b'2013-11-19 14:00:00' b'2013-05-16 08:00:00']

label               : [2942 2587 6305 5242 6404]

कैशिंग

सीएसवी डेटा को पार्स करने के लिए कुछ ओवरहेड है। छोटे मॉडल के लिए यह प्रशिक्षण में अड़चन हो सकती है।

आपके उपयोग के मामले के आधार पर Dataset.cache या data.experimental.snapshot का उपयोग करना एक अच्छा विचार हो सकता है ताकि csv डेटा केवल पहले युग पर पार्स हो।

cache और snapshot विधियों के बीच मुख्य अंतर यह है कि cache फ़ाइलों का उपयोग केवल TensorFlow प्रक्रिया द्वारा किया जा सकता है जिसने उन्हें बनाया है, लेकिन snapshot फ़ाइलों को अन्य प्रक्रियाओं द्वारा पढ़ा जा सकता है।

उदाहरण के लिए, traffic_volume_csv_gz_ds 20 बार पुनरावृति, कैशिंग के बिना ~ 15 सेकंड लेता है, या कैशिंग के साथ ~ 2s।

%%time
for i, (batch, label) in enumerate(traffic_volume_csv_gz_ds.repeat(20)):
  if i % 40 == 0:
    print('.', end='')
print()
...............................................................................................
CPU times: user 15.4 s, sys: 3.98 s, total: 19.4 s
Wall time: 12.4 s

%%time
caching = traffic_volume_csv_gz_ds.cache().shuffle(1000)

for i, (batch, label) in enumerate(caching.shuffle(1000).repeat(20)):
  if i % 40 == 0:
    print('.', end='')
print()
...............................................................................................
CPU times: user 1.48 s, sys: 179 ms, total: 1.65 s
Wall time: 1.32 s

%%time
snapshot = tf.data.experimental.snapshot('titanic.tfsnap')
snapshotting = traffic_volume_csv_gz_ds.apply(snapshot).shuffle(1000)

for i, (batch, label) in enumerate(snapshotting.shuffle(1000).repeat(20)):
  if i % 40 == 0:
    print('.', end='')
print()
...............................................................................................
CPU times: user 2.09 s, sys: 449 ms, total: 2.54 s
Wall time: 1.64 s

यदि आपके डेटा लोडिंग को सीएसवी फ़ाइलों को लोड करके धीमा कर दिया जाता है, और cache और snapshot आपके उपयोग के मामले के लिए अपर्याप्त हैं, तो अपने डेटा को अधिक सुव्यवस्थित प्रारूप में पुनः एन्कोडिंग करने पर विचार करें।

कई फाइलें

इस खंड में अब तक के सभी उदाहरणों को आसानी से tf.data बिना किया जा सकता है। एक जगह जहां tf.data वास्तव में चीजों को सरल बना सकती है, जब फाइलों के संग्रह से निपटना होता है।

उदाहरण के लिए, वर्ण फ़ॉन्ट छवियां डेटासेट को csv फ़ाइलों के संग्रह के रूप में वितरित किया जाता है, जो प्रति फ़ॉन्ट एक है।

फोंट्स

द्वारा छवि विल्ली Heidelbach से Pixabay

डेटासेट डाउनलोड करें, और अंदर फाइलों पर एक नज़र डालें:

fonts_zip = tf.keras.utils.get_file(
    'fonts.zip',  "https://archive.ics.uci.edu/ml/machine-learning-databases/00417/fonts.zip",
    cache_dir='.', cache_subdir='fonts',
    extract=True)
Downloading data from https://archive.ics.uci.edu/ml/machine-learning-databases/00417/fonts.zip
160317440/160313983 [==============================] - 8s 0us/step

import pathlib
font_csvs =  sorted(str(p) for p in pathlib.Path('fonts').glob("*.csv"))

font_csvs[:10]
['fonts/AGENCY.csv',
 'fonts/ARIAL.csv',
 'fonts/BAITI.csv',
 'fonts/BANKGOTHIC.csv',
 'fonts/BASKERVILLE.csv',
 'fonts/BAUHAUS.csv',
 'fonts/BELL.csv',
 'fonts/BERLIN.csv',
 'fonts/BERNARD.csv',
 'fonts/BITSTREAMVERA.csv']
len(font_csvs)
153

फाइलों के एक समूह के साथ काम करते समय आप एक glob-style file_pattern को experimental.make_csv_dataset . file_pattern फ़ंक्शन से पास कर सकते हैं। फाइलों के क्रम को प्रत्येक पुनरावृत्ति में बदल दिया जाता है।

कितने फाइलों को समानांतर और num_parallel_reads में एक साथ पढ़ने के लिए सेट करने के लिए num_parallel_reads तर्क का उपयोग करें।

fonts_ds = tf.data.experimental.make_csv_dataset(
    file_pattern = "fonts/*.csv",
    batch_size=10, num_epochs=1,
    num_parallel_reads=20,
    shuffle_buffer_size=10000)

इन सीएसवी फ़ाइलों में एक ही पंक्ति में चित्र समतल हैं। स्तंभ नाम r{row}c{column} स्वरूपित किए जाते हैं। यहाँ पहला बैच है:

for features in fonts_ds.take(1):
  for i, (name, value) in enumerate(features.items()):
    if i>15:
      break
    print(f"{name:20s}: {value}")
print('...')
print(f"[total: {len(features)} features]")
font                : [b'HARRINGTON' b'ISOC' b'GEORGIA' b'CAMBRIA' b'PROXY' b'SNAP'
 b'COUNTRYBLUEPRINT' b'PROXY' b'VIVALDI' b'GILL']
fontVariant         : [b'HARRINGTON' b'ISOCTEUR' b'GEORGIA' b'CAMBRIA' b'PROXY 9' b'SNAP ITC'
 b'COUNTRYBLUEPRINT' b'PROXY 9' b'VIVALDI'
 b'GILL SANS ULTRA BOLD CONDENSED']
m_label             : [   94  8800  8539 10659   305  8223  8217   728   170   115]
strength            : [0.4 0.4 0.4 0.4 0.4 0.4 0.4 0.4 0.4 0.4]
italic              : [0 0 0 0 1 0 0 1 0 0]
orientation         : [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
m_top               : [49 55 35 46 52 41 38 36 36 46]
m_left              : [22 33 24 22 27 23 24 40 27 21]
originalH           : [17 30 48 37 34 59 54  9 25 41]
originalW           : [30 21 62 39 12 34 25 24 27 26]
h                   : [20 20 20 20 20 20 20 20 20 20]
w                   : [20 20 20 20 20 20 20 20 20 20]
r0c0                : [  1   1   1   1   1 255 255 213   1   1]
r0c1                : [  1   1   3   1   1 255 255   1   1   1]
r0c2                : [  1   1  88   1   1 255 255   1   1   1]
r0c3                : [  1   1 232   1   1 255 255   1   1   1]
...
[total: 412 features]

वैकल्पिक: पैकिंग फ़ील्ड

आप शायद इस तरह अलग कॉलम में प्रत्येक पिक्सेल के साथ काम नहीं करना चाहते हैं। इस डेटासेट का उपयोग करने की कोशिश करने से पहले पिक्सल को एक इमेज-टेंसर में पैक करना सुनिश्चित करें।

यहां वह कोड है जो प्रत्येक उदाहरण के लिए चित्र बनाने के लिए कॉलम नामों को पार्स करता है:

0969180d0

डेटासेट में प्रत्येक बैच में उस फ़ंक्शन को लागू करें:

fonts_image_ds = fonts_ds.map(make_images)

for features in fonts_image_ds.take(1):
  break

परिणामी छवियों को प्लॉट करें:

from matplotlib import pyplot as plt

plt.figure(figsize=(6,6), dpi=120)

for n in range(9):
  plt.subplot(3,3,n+1)
  plt.imshow(features['image'][..., n])
  plt.title(chr(features['m_label'][n]))
  plt.axis('off')

पींग

निचले स्तर के कार्य

अब तक इस ट्यूटोरियल ने सीएसवी डेटा को पढ़ने के लिए उच्चतम स्तर की उपयोगिताओं पर ध्यान केंद्रित किया है। अन्य दो एपीआई हैं जो उन्नत उपयोगकर्ताओं के लिए सहायक हो सकते हैं यदि आपका उपयोग-मामला मूल पैटर्न में फिट नहीं होता है।

  • tf.io.decode_csv - CSV कॉलम tf.io.decode_csv सूची में पाठ की पंक्तियों को पार्स करने के लिए एक फ़ंक्शन।
  • tf.data.experimental.CsvDataset - एक निम्न स्तर csv डेटासेट निर्माता।

इस अनुभाग में पुन द्वारा प्रदान की कार्यक्षमता make_csv_dataset , प्रदर्शित करने के लिए कि यह कैसे निचले स्तर कार्यक्षमता का उपयोग किया जा सकता है।

tf.io.decode_csv

यह फ़ंक्शन स्ट्रिंग, या स्ट्रिंग की सूची को स्तंभों की सूची में डिकोड करता है।

make_csv_dataset विपरीत यह फ़ंक्शन स्तंभ डेटा-प्रकारों का अनुमान लगाने का प्रयास नहीं करता है। आप प्रत्येक स्तंभ के लिए सही प्रकार के मान वाले record_defaults सूची प्रदान करके स्तंभ प्रकार निर्दिष्ट करते हैं।

टाइटैनिक डेटा को decode_csv का उपयोग करके तार के रूप में पढ़ने के लिए आप कहेंगे:

text = pathlib.Path(titanic_file_path).read_text()
lines = text.split('\n')[1:-1]

all_strings = [str()]*10
all_strings
['', '', '', '', '', '', '', '', '', '']
features = tf.io.decode_csv(lines, record_defaults=all_strings) 

for f in features:
  print(f"type: {f.dtype.name}, shape: {f.shape}")
type: string, shape: (627,)
type: string, shape: (627,)
type: string, shape: (627,)
type: string, shape: (627,)
type: string, shape: (627,)
type: string, shape: (627,)
type: string, shape: (627,)
type: string, shape: (627,)
type: string, shape: (627,)
type: string, shape: (627,)

उन्हें उनके वास्तविक प्रकारों के साथ पार्स करने के लिए, संबंधित प्रकारों के record_defaults की सूची बनाएं:

0a25254e20
0,male,22.0,1,0,7.25,Third,unknown,Southampton,n

titanic_types = [int(), str(), float(), int(), int(), float(), str(), str(), str(), str()]
titanic_types
[0, '', 0.0, 0, 0, 0.0, '', '', '', '']
features = tf.io.decode_csv(lines, record_defaults=titanic_types) 

for f in features:
  print(f"type: {f.dtype.name}, shape: {f.shape}")
type: int32, shape: (627,)
type: string, shape: (627,)
type: float32, shape: (627,)
type: int32, shape: (627,)
type: int32, shape: (627,)
type: float32, shape: (627,)
type: string, shape: (627,)
type: string, shape: (627,)
type: string, shape: (627,)
type: string, shape: (627,)

tf.data.experimental.CsvDataset

tf.data.experimental.CsvDataset वर्ग make_csv_dataset फ़ंक्शन की सुविधा सुविधाओं के बिना एक न्यूनतम CSV Dataset इंटरफ़ेस प्रदान करता है: स्तंभ शीर्षलेख पार्सिंग, स्तंभ प्रकार- make_csv_dataset , स्वचालित फेरबदल, फ़ाइल इंटरलेइंग।

यह निर्माता निम्न प्रकार से record_defaults के रूप में io.parse_csv का उपयोग करता है:

simple_titanic = tf.data.experimental.CsvDataset(titanic_file_path, record_defaults=titanic_types, header=True)

for example in simple_titanic.take(1):
  print([e.numpy() for e in example])
[0, b'male', 22.0, 1, 0, 7.25, b'Third', b'unknown', b'Southampton', b'n']

उपरोक्त कोड मूल रूप से इसके बराबर है:

def decode_titanic_line(line):
  return tf.io.decode_csv(line, titanic_types)

manual_titanic = (
    # Load the lines of text
    tf.data.TextLineDataset(titanic_file_path)
    # Skip the header row.
    .skip(1)
    # Decode the line.
    .map(decode_titanic_line)
)

for example in manual_titanic.take(1):
  print([e.numpy() for e in example])
[0, b'male', 22.0, 1, 0, 7.25, b'Third', b'unknown', b'Southampton', b'n']

कई फाइलें

experimental.CsvDataset . record_defaults का उपयोग करके फोंट डेटासेट को पार्स करने के लिए, आपको पहले record_defaults के कॉलम प्रकार निर्धारित करने record_defaults । एक फ़ाइल की पहली पंक्ति का निरीक्षण करके शुरू करें:

font_line = pathlib.Path(font_csvs[0]).read_text().splitlines()[1]
print(font_line)
AGENCY,AGENCY FB,64258,0.400000,0,0.000000,35,21,51,22,20,20,1,1,1,21,101,210,255,255,255,255,255,255,255,255,255,255,255,255,255,255,1,1,1,93,255,255,255,176,146,146,146,146,146,146,146,146,216,255,255,255,1,1,1,93,255,255,255,70,1,1,1,1,1,1,1,1,163,255,255,255,1,1,1,93,255,255,255,70,1,1,1,1,1,1,1,1,163,255,255,255,1,1,1,93,255,255,255,70,1,1,1,1,1,1,1,1,163,255,255,255,1,1,1,93,255,255,255,70,1,1,1,1,1,1,1,1,163,255,255,255,1,1,1,93,255,255,255,70,1,1,1,1,1,1,1,1,163,255,255,255,141,141,141,182,255,255,255,172,141,141,141,115,1,1,1,1,163,255,255,255,255,255,255,255,255,255,255,255,255,255,255,209,1,1,1,1,163,255,255,255,6,6,6,96,255,255,255,74,6,6,6,5,1,1,1,1,163,255,255,255,1,1,1,93,255,255,255,70,1,1,1,1,1,1,1,1,163,255,255,255,1,1,1,93,255,255,255,70,1,1,1,1,1,1,1,1,163,255,255,255,1,1,1,93,255,255,255,70,1,1,1,1,1,1,1,1,163,255,255,255,1,1,1,93,255,255,255,70,1,1,1,1,1,1,1,1,163,255,255,255,1,1,1,93,255,255,255,70,1,1,1,1,1,1,1,1,163,255,255,255,1,1,1,93,255,255,255,70,1,1,1,1,1,1,1,1,163,255,255,255,1,1,1,93,255,255,255,70,1,1,1,1,1,1,1,1,163,255,255,255,1,1,1,93,255,255,255,70,1,1,1,1,1,1,1,1,163,255,255,255,1,1,1,93,255,255,255,70,1,1,1,1,1,1,1,1,163,255,255,255,1,1,1,93,255,255,255,70,1,1,1,1,1,1,1,1,163,255,255,255

केवल पहले दो फ़ील्ड स्ट्रिंग्स हैं, बाकी इनट्स या फ़्लोट्स हैं, और आप कमेंट्स की गिनती करके कुल फ़ीचर प्राप्त कर सकते हैं:

num_font_features = font_line.count(',')+1
font_column_types = [str(), str()] + [float()]*(num_font_features-2)
है

CsvDatasaet कंस्ट्रक्टर इनपुट फ़ाइलों की एक सूची ले सकता है, लेकिन उन्हें क्रमिक रूप से पढ़ता है। CSVs की सूची में पहली फ़ाइल AGENCY.csv :

font_csvs[0]
'fonts/AGENCY.csv'

तो जब आप करने के लिए फ़ाइलों की सूची से पारित पारित CsvDataaset से रिकॉर्ड AGENCY.csv पहले पढ़ रहे हैं:

simple_font_ds = tf.data.experimental.CsvDataset(
    font_csvs, 
    record_defaults=font_column_types, 
    header=True)
for row in simple_font_ds.take(10):
  print(row[0].numpy())
b'AGENCY'
b'AGENCY'
b'AGENCY'
b'AGENCY'
b'AGENCY'
b'AGENCY'
b'AGENCY'
b'AGENCY'
b'AGENCY'
b'AGENCY'

एकाधिक फ़ाइलों को Dataset.interleave करने के लिए, Dataset.interleave उपयोग Dataset.interleave

यहां एक प्रारंभिक डेटासेट है जिसमें csv फ़ाइल नाम हैं:

font_files = tf.data.Dataset.list_files("fonts/*.csv")

यह फ़ाइल को प्रत्येक युग नाम देता है:

0bb9802b0
Epoch 1:
     b'fonts/ELEPHANT.csv'
     b'fonts/NINA.csv'
     b'fonts/COPPERPLATE.csv'
     b'fonts/GOTHICE.csv'
     b'fonts/SWIS721.csv'
    ...

Epoch 2:
     b'fonts/PALACE.csv'
     b'fonts/GABRIOLA.csv'
     b'fonts/COURIER.csv'
     b'fonts/CONSTANTIA.csv'
     b'fonts/QUICKTYPE.csv'
    ...

interleave विधि एक लेता है map_func है कि एक बच्चे के पैदा Dataset अभिभावक के प्रत्येक तत्व के लिए Dataset

यहां, आप फ़ाइलों के डेटासेट के प्रत्येक तत्व से एक CsvDataset बनाना चाहते हैं:

def make_font_csv_ds(path):
  return tf.data.experimental.CsvDataset(
    path, 
    record_defaults=font_column_types, 
    header=True)
है

Dataset इंटरलेव रिटर्न एलिमेंट्स द्वारा बच्चे की संख्या पर साइकिल Dataset लौटा दिया गया है- Dataset एस। ध्यान दें, नीचे, डेटासेट साइकल पर कैसे हो cycle_length)=3

font_rows = font_files.interleave(make_font_csv_ds,
                                  cycle_length=3)
fonts_dict = {'font_name':[], 'character':[]}

for row in font_rows.take(10):
  fonts_dict['font_name'].append(row[0].numpy().decode())
  fonts_dict['character'].append(chr(row[2].numpy()))

pd.DataFrame(fonts_dict)

प्रदर्शन

इससे पहले, यह नोट किया गया था कि स्ट्रिंग्स के एक बैच पर चलने पर io.decode_csv अधिक कुशल है।

इस तथ्य का लाभ उठाना संभव है, जब बड़े बैच आकारों का उपयोग करते हुए, सीएसवी लोडिंग प्रदर्शन में सुधार करने के लिए (लेकिन पहले कैशिंग का प्रयास करें)।

अंतर्निहित लोडर 20 के साथ, 2048-उदाहरण बैच लगभग 17s लेते हैं।

BATCH_SIZE=2048
fonts_ds = tf.data.experimental.make_csv_dataset(
    file_pattern = "fonts/*.csv",
    batch_size=BATCH_SIZE, num_epochs=1,
    num_parallel_reads=100)
%%time
for i,batch in enumerate(fonts_ds.take(20)):
  print('.',end='')

print()
....................
CPU times: user 28.9 s, sys: 2.76 s, total: 31.7 s
Wall time: 11.7 s

लगभग 5 s में तेजी से चलता है, decode_csv लिए पाठ लाइनों के बैचों को पास करना:

fonts_files = tf.data.Dataset.list_files("fonts/*.csv")
fonts_lines = fonts_files.interleave(
    lambda fname:tf.data.TextLineDataset(fname).skip(1), 
    cycle_length=100).batch(BATCH_SIZE)

fonts_fast = fonts_lines.map(lambda x: tf.io.decode_csv(x, record_defaults=font_column_types))
%%time
for i,batch in enumerate(fonts_fast.take(20)):
  print('.',end='')

print()
....................
CPU times: user 5.4 s, sys: 0 ns, total: 5.4 s
Wall time: 4.84 s

बड़े बैचों का उपयोग करके सीएसवी प्रदर्शन बढ़ाने के एक और उदाहरण के लिए ओवरफिट और अंडरफिट ट्यूटोरियल देखें

इस तरह का दृष्टिकोण काम कर सकता है, लेकिन cache और snapshot जैसे अन्य विकल्पों पर विचार करें, या अपने डेटा को अधिक सुव्यवस्थित प्रारूप में पुनः लागू करें।