सहायता Kaggle पर TensorFlow साथ ग्रेट बैरियर रीफ की रक्षा चैलेंज में शामिल हों

सीएसवी डेटा लोड करें

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

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

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

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

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

सेट अप

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

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

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

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

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

यहाँ एक में डेटा डाउनलोड करने के लिए कैसे है पांडा DataFrame :

abalone_train = pd.read_csv(
    "https://storage.googleapis.com/download.tensorflow.org/data/abalone_train.csv",
    names=["Length", "Diameter", "Height", "Whole weight", "Shucked weight",
           "Viscera weight", "Shell weight", "Age"])

abalone_train.head()

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

एक अबालोन खोल

"ऐबालोन खोल" (द्वारा निकी डुगन Pogue , सीसी BY-SA 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 :

abalone_model.fit(abalone_features, abalone_labels, epochs=10)
Epoch 1/10
104/104 [==============================] - 1s 2ms/step - loss: 57.8799
Epoch 2/10
104/104 [==============================] - 0s 2ms/step - loss: 11.6617
Epoch 3/10
104/104 [==============================] - 0s 2ms/step - loss: 8.5956
Epoch 4/10
104/104 [==============================] - 0s 2ms/step - loss: 8.0663
Epoch 5/10
104/104 [==============================] - 0s 2ms/step - loss: 7.6160
Epoch 6/10
104/104 [==============================] - 0s 2ms/step - loss: 7.2284
Epoch 7/10
104/104 [==============================] - 0s 2ms/step - loss: 6.9368
Epoch 8/10
104/104 [==============================] - 0s 2ms/step - loss: 6.7287
Epoch 9/10
104/104 [==============================] - 0s 2ms/step - loss: 6.5694
Epoch 10/10
104/104 [==============================] - 0s 2ms/step - loss: 6.4730
<keras.callbacks.History at 0x7fd1a0579ed0>

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

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

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

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

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

normalize = layers.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: 92.6760
Epoch 2/10
104/104 [==============================] - 0s 2ms/step - loss: 54.4503
Epoch 3/10
104/104 [==============================] - 0s 2ms/step - loss: 17.1807
Epoch 4/10
104/104 [==============================] - 0s 2ms/step - loss: 5.9306
Epoch 5/10
104/104 [==============================] - 0s 2ms/step - loss: 5.0489
Epoch 6/10
104/104 [==============================] - 0s 2ms/step - loss: 4.9627
Epoch 7/10
104/104 [==============================] - 0s 2ms/step - loss: 4.9511
Epoch 8/10
104/104 [==============================] - 0s 2ms/step - loss: 4.9162
Epoch 9/10
104/104 [==============================] - 0s 2ms/step - loss: 4.9172
Epoch 10/10
104/104 [==============================] - 0s 2ms/step - loss: 4.9027
<keras.callbacks.History at 0x7fd1a0286f90>

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

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

भीमकाय

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

कच्चे डेटा आसानी से एक पांडा के रूप में लोड किया जा सकता 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 मॉडल में पास कर सकते हैं। उस दृष्टिकोण का नुकसान यह है कि यदि आप अपने मॉडल को सहेजते हैं और निर्यात करते हैं तो इसके साथ प्रीप्रोसेसिंग सहेजा नहीं जाता है। केरस प्रीप्रोसेसिंग परतें इस समस्या से बचती हैं क्योंकि वे मॉडल का हिस्सा हैं।

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

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

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

# Perform a calculation using the input
result = 2*input + 1

# the result doesn't have a value
result
<KerasTensor: shape=(None,) dtype=float32 (created by layer 'tf.__operators__.add')>
calc = tf.keras.Model(inputs=input, outputs=result)
print(calc(1).numpy())
print(calc(2).numpy())
3.0
5.0

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

inputs = {}

for name, column in titanic_features.items():
  dtype = column.dtype
  if dtype == object:
    dtype = tf.string
  else:
    dtype = tf.float32

  inputs[name] = tf.keras.Input(shape=(1,), name=name, dtype=dtype)

inputs
{'sex': <KerasTensor: shape=(None, 1) dtype=string (created by layer 'sex')>,
 'age': <KerasTensor: shape=(None, 1) dtype=float32 (created by layer 'age')>,
 'n_siblings_spouses': <KerasTensor: shape=(None, 1) dtype=float32 (created by layer 'n_siblings_spouses')>,
 'parch': <KerasTensor: shape=(None, 1) dtype=float32 (created by layer 'parch')>,
 'fare': <KerasTensor: shape=(None, 1) dtype=float32 (created by layer 'fare')>,
 'class': <KerasTensor: shape=(None, 1) dtype=string (created by layer 'class')>,
 'deck': <KerasTensor: shape=(None, 1) dtype=string (created by layer 'deck')>,
 'embark_town': <KerasTensor: shape=(None, 1) dtype=string (created by layer 'embark_town')>,
 'alone': <KerasTensor: shape=(None, 1) dtype=string (created by layer 'alone')>}

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

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

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

all_numeric_inputs
<KerasTensor: shape=(None, 4) dtype=float32 (created by layer 'normalization_1')>

सभी प्रतीकात्मक प्रीप्रोसेसिंग परिणामों को बाद में संयोजित करने के लिए एकत्र करें।

preprocessed_inputs = [all_numeric_inputs]

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

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

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

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

  x = lookup(input)
  x = one_hot(x)
  preprocessed_inputs.append(x)
WARNING:tensorflow:vocab_size is deprecated, please use vocabulary_size.
WARNING:tensorflow:max_tokens is deprecated, please use num_tokens instead.
WARNING:tensorflow:vocab_size is deprecated, please use vocabulary_size.
WARNING:tensorflow:max_tokens is deprecated, please use num_tokens instead.
WARNING:tensorflow:vocab_size is deprecated, please use vocabulary_size.
WARNING:tensorflow:max_tokens is deprecated, please use num_tokens instead.
WARNING:tensorflow:vocab_size is deprecated, please use vocabulary_size.
WARNING:tensorflow:max_tokens is deprecated, please use num_tokens instead.
WARNING:tensorflow:vocab_size is deprecated, please use vocabulary_size.
WARNING:tensorflow:max_tokens is deprecated, please use num_tokens instead.

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

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 बस इनपुट पूर्व प्रसंस्करण में शामिल है। आप इसे यह देखने के लिए चला सकते हैं कि यह आपके डेटा के साथ क्या करता है। Keras मॉडल स्वचालित रूप से पांडा न करने वाली DataFrames क्योंकि यह स्पष्ट नहीं है कि यह एक टेन्सर करने के लिए या tensors के शब्दकोश में परिवर्तित किया जाना चाहिए। तो इसे टेंसर के शब्दकोश में परिवर्तित करें:

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, 28), dtype=float32, numpy=
array([[-0.61 ,  0.395, -0.479, -0.497,  0.   ,  0.   ,  1.   ,  0.   ,

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

अब इसके ऊपर मॉडल बनाएं:

def titanic_model(preprocessing_head, inputs):
  body = tf.keras.Sequential([
    layers.Dense(64),
    layers.Dense(1)
  ])

  preprocessed_inputs = preprocessing_head(inputs)
  result = body(preprocessed_inputs)
  model = tf.keras.Model(inputs, result)

  model.compile(loss=tf.losses.BinaryCrossentropy(from_logits=True),
                optimizer=tf.optimizers.Adam())
  return model

titanic_model = titanic_model(titanic_preprocessing, inputs)

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

titanic_model.fit(x=titanic_features_dict, y=titanic_labels, epochs=10)
Epoch 1/10
20/20 [==============================] - 1s 5ms/step - loss: 0.5580
Epoch 2/10
20/20 [==============================] - 0s 4ms/step - loss: 0.5019
Epoch 3/10
20/20 [==============================] - 0s 4ms/step - loss: 0.4702
Epoch 4/10
20/20 [==============================] - 0s 4ms/step - loss: 0.4495
Epoch 5/10
20/20 [==============================] - 0s 4ms/step - loss: 0.4394
Epoch 6/10
20/20 [==============================] - 0s 4ms/step - loss: 0.4340
Epoch 7/10
20/20 [==============================] - 0s 4ms/step - loss: 0.4272
Epoch 8/10
20/20 [==============================] - 0s 5ms/step - loss: 0.4254
Epoch 9/10
20/20 [==============================] - 0s 5ms/step - loss: 0.4244
Epoch 10/10
20/20 [==============================] - 0s 5ms/step - loss: 0.4222
<keras.callbacks.History at 0x7fd2212c7fd0>

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

titanic_model.save('test')
reloaded = tf.keras.models.load_model('test')
2021-11-20 02:24:26.384348: W tensorflow/python/util/util.cc:368] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.
INFO:tensorflow:Assets written to: test/assets
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.918]], shape=(1, 1), dtype=float32)
tf.Tensor([[-1.918]], shape=(1, 1), dtype=float32)

tf.डेटा का उपयोग करना

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

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

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

मेमोरी डेटा में चालू है

आवेदन करने के पहले उदाहरण के रूप में 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 कि औजार के ऊपर का एक सामान्यीकृत संस्करण slices समारोह, TensorFlow में।

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

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

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 समारोह नेस्टेड शब्दकोशों या tuples के किसी भी संरचना संभाल कर सकते हैं। निम्नलिखित कोड का एक डाटासेट बनाता है (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)

गुजर के बजाय features और labels के लिए Model.fit , आप डाटासेट पारित:

titanic_model.fit(titanic_batches, epochs=5)
Epoch 1/5
20/20 [==============================] - 0s 5ms/step - loss: 0.4215
Epoch 2/5
20/20 [==============================] - 0s 5ms/step - loss: 0.4208
Epoch 3/5
20/20 [==============================] - 0s 5ms/step - loss: 0.4205
Epoch 4/5
20/20 [==============================] - 0s 5ms/step - loss: 0.4204
Epoch 5/5
20/20 [==============================] - 0s 5ms/step - loss: 0.4185
<keras.callbacks.History at 0x7fd22046cf50>

एक ही फाइल से

अब तक इस ट्यूटोरियल ने इन-मेमोरी डेटा के साथ काम किया है। 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
40960/30874 [=======================================] - 0s 0us/step

अब फ़ाइल से सीएसवी डेटा पढ़ सकते हैं और एक बनाने 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'male' b'male' b'female']
age                 : [28. 70. 19.  6. 24.]
n_siblings_spouses  : [0 1 0 0 0]
parch               : [0 1 0 1 0]
fare                : [ 7.75  71.     7.775 12.475 13.   ]
class               : [b'Third' b'First' b'Third' b'Third' b'Second']
deck                : [b'unknown' b'B' b'unknown' b'E' b'unknown']
embark_town         : [b'Queenstown' b'Southampton' b'Southampton' b'Southampton' b'Southampton']
alone               : [b'y' b'n' b'y' b'n' b'y']

label               : [0 0 0 1 0]

यह मक्खी पर डेटा को डीकंप्रेस भी कर सकता है। यहाँ एक 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 1us/step
417792/405373 [==============================] - 1s 1us/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                : [284.77 257.79 260.01 286.13 290.47]
rain_1h             : [0.   0.   0.   0.   0.25]
snow_1h             : [0. 0. 0. 0. 0.]
clouds_all          : [90 20 75  1 92]
weather_main        : [b'Mist' b'Clouds' b'Clouds' b'Clear' b'Rain']
weather_description : [b'mist' b'few clouds' b'broken clouds' b'sky is clear' b'light rain']
date_time           : [b'2012-10-25 17:00:00' b'2013-01-15 06:00:00' b'2012-12-24 08:00:00'
 b'2013-05-08 02:00:00' b'2013-08-12 06:00:00']

label               : [6488 5434 2174  298 5939]

कैशिंग

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

आपके उपयोग के मामले के आधार पर इसका इस्तेमाल करने के लिए एक अच्छा विचार हो सकता 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 16.8 s, sys: 4.07 s, total: 20.8 s
Wall time: 12.7 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.46 s, sys: 243 ms, total: 1.7 s
Wall time: 1.34 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()
WARNING:tensorflow:From <timed exec>:1: snapshot (from tensorflow.python.data.experimental.ops.snapshot) is deprecated and will be removed in a future version.
Instructions for updating:
Use `tf.data.Dataset.snapshot(...)`.
...............................................................................................
CPU times: user 2.26 s, sys: 490 ms, total: 2.75 s
Wall time: 1.65 s

अपने डेटा लोड हो रहा है लोड हो रहा है csv फ़ाइलें, और समय धीमा हो जाता है, तो 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
160325632/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

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

का प्रयोग करें 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'NINA' b'FORTE' b'CALIFORNIAN' b'JAVANESE' b'FORTE' b'BAITI' b'HARLOW'
 b'NIRMALA' b'JAVANESE' b'NINA']
fontVariant         : [b'NINA' b'FORTE' b'CALIFORNIAN FB' b'JAVANESE TEXT' b'FORTE'
 b'MONGOLIAN BAITI' b'HARLOW SOLID ITALIC' b'NIRMALA UI SEMILIGHT'
 b'JAVANESE TEXT' b'NINA']
m_label             : [ 932  172   55  376  215 6156   65 7286   59  302]
strength            : [0.4 0.4 0.4 0.4 0.4 0.4 0.4 0.4 0.4 0.4]
italic              : [0 1 1 1 1 0 0 0 0 0]
orientation         : [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
m_top               : [38 45 36 45 40 41 34 44 76 38]
m_left              : [20 33 24 33 28 23 20 23 25 22]
originalH           : [49 23 47 59 34 33 60 49 40 62]
originalW           : [34 40 25 49 43 33 72 38 11 20]
h                   : [20 20 20 20 20 20 20 20 20 20]
w                   : [20 20 20 20 20 20 20 20 20 20]
r0c0                : [255   1  82   1   1   1   1   1   1 255]
r0c1                : [255 255 255   1   1   1   1   1   1 255]
r0c2                : [255 255 255   1   1   1   1  42   1 255]
r0c3                : [255 255 255   1   1   1   1 135  47 255]
...
[total: 412 features]

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

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

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

import re

def make_images(features):
  image = [None]*400
  new_feats = {}

  for name, value in features.items():
    match = re.match('r(\d+)c(\d+)', name)
    if match:
      image[int(match.group(1))*20+int(match.group(2))] = value
    else:
      new_feats[name] = value

  image = tf.stack(image, axis=0)
  image = tf.reshape(image, [20, 20, -1])
  new_feats['image'] = image

  return new_feats

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

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')
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/IPython/core/pylabtools.py:151: UserWarning: Glyph 64422 (\N{ARABIC LETTER HEH GOAL ISOLATED FORM}) missing from current font.
  fig.canvas.print_figure(bytes_io, **kw)

पीएनजी

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

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

  • tf.io.decode_csv - CSV कॉलम tensors की एक सूची में पाठ की तर्ज पार्स करने के लिए एक समारोह।
  • tf.data.experimental.CsvDataset - एक निचले स्तर सीएसवी डाटासेट निर्माता।

इस अनुभाग में पुन द्वारा प्रदान की कार्यक्षमता 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 इसी प्रकार के:

print(lines[0])
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 वर्ग एक न्यूनतम सीएसवी प्रदान करता है Dataset की सुविधा सुविधाओं के बिना इंटरफ़ेस make_csv_dataset स्तंभ शीर्ष लेख पार्स, स्तंभ प्रकार-निष्कर्ष, स्वत: पुथल, फ़ाइल interleaving: समारोह।

यह निर्माता का उपयोग करता है इस प्रकार है 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 । एक फ़ाइल की पहली पंक्ति का निरीक्षण करके प्रारंभ करें:

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 निर्माता इनपुट फ़ाइलों की एक सूची ले, लेकिन उन्हें क्रमिक पढ़ सकते हैं। CSV में की सूची में पहले फाइल है 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

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

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

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

print('Epoch 1:')
for f in list(font_files)[:5]:
  print("    ", f.numpy())
print('    ...')
print()

print('Epoch 2:')
for f in list(font_files)[:5]:
  print("    ", f.numpy())
print('    ...')
Epoch 1:
     b'fonts/CENTAUR.csv'
     b'fonts/JUICE.csv'
     b'fonts/COMIC.csv'
     b'fonts/SKETCHFLOW.csv'
     b'fonts/NIAGARA.csv'
    ...

Epoch 2:
     b'fonts/EUROROMAN.csv'
     b'fonts/YI BAITI.csv'
     b'fonts/LEELAWADEE.csv'
     b'fonts/GOUDY.csv'
     b'fonts/COMPLEX.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 बच्चे के की एक संख्या से अधिक साइकिल द्वारा Interleave रिटर्न तत्वों द्वारा दिया 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-उदाहरण बैचों में लगभग 17 सेकंड लगते हैं।

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 27.4 s, sys: 1.74 s, total: 29.1 s
Wall time: 11.8 s

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

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 10.3 s, sys: 0 ns, total: 10.3 s
Wall time: 1.72 s

बड़े बैच का उपयोग करके सीएसवी प्रदर्शन में वृद्धि का एक और उदाहरण के लिए देखें overfit और underfit ट्यूटोरियल

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