এমএল কমিউনিটি দিবস 9 নভেম্বর! TensorFlow, Jax থেকে আপডেটের জন্য আমাদের সাথে যোগ দিন, এবং আরও আরও জানুন

CSV ডেটা লোড করুন

TensorFlow.org এ দেখুন গুগল কোলাবে চালান 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
from tensorflow.keras.layers.experimental import preprocessing

মেমরি ডেটাতে

যে কোনও ছোট 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()

ডেটাসেটের পরিমাপ একটি সেট রয়েছে ঝিনুক , সমুদ্র শামুক এক ধরনের।

একটি আবাল শেল

"ঝিনুক শেল" (দ্বারা নিকি Dugan Pogue , সিসি বাই-এসএ 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: 68.1297
Epoch 2/10
104/104 [==============================] - 0s 2ms/step - loss: 13.3981
Epoch 3/10
104/104 [==============================] - 0s 1ms/step - loss: 8.9458
Epoch 4/10
104/104 [==============================] - 0s 1ms/step - loss: 8.3894
Epoch 5/10
104/104 [==============================] - 0s 1ms/step - loss: 7.8835
Epoch 6/10
104/104 [==============================] - 0s 1ms/step - loss: 7.4897
Epoch 7/10
104/104 [==============================] - 0s 1ms/step - loss: 7.1716
Epoch 8/10
104/104 [==============================] - 0s 1ms/step - loss: 6.9468
Epoch 9/10
104/104 [==============================] - 0s 1ms/step - loss: 6.7714
Epoch 10/10
104/104 [==============================] - 0s 1ms/step - loss: 6.6458
<tensorflow.python.keras.callbacks.History at 0x7f7bf0178110>

আপনি কেবলমাত্র 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: 91.9882
Epoch 2/10
104/104 [==============================] - 0s 2ms/step - loss: 52.3517
Epoch 3/10
104/104 [==============================] - 0s 1ms/step - loss: 16.0901
Epoch 4/10
104/104 [==============================] - 0s 1ms/step - loss: 5.8372
Epoch 5/10
104/104 [==============================] - 0s 1ms/step - loss: 5.0929
Epoch 6/10
104/104 [==============================] - 0s 2ms/step - loss: 5.0442
Epoch 7/10
104/104 [==============================] - 0s 1ms/step - loss: 5.0062
Epoch 8/10
104/104 [==============================] - 0s 1ms/step - loss: 4.9882
Epoch 9/10
104/104 [==============================] - 0s 2ms/step - loss: 4.9629
Epoch 10/10
104/104 [==============================] - 0s 2ms/step - loss: 4.9666
<tensorflow.python.keras.callbacks.History at 0x7f7be008f910>

মিশ্র ডেটা প্রকার

"টাইটানিক" ডেটাসেটে টাইটানিকের যাত্রীদের তথ্য রয়েছে। এই ডেটাসেটের নামমাত্র কাজ হল কে বেঁচে আছে তা ভবিষ্যদ্বাণী করা।

টাইটানিক

ভাবমূর্তি উইকিমিডিয়া থেকে

কাঁচা ডেটা সহজে একটি পান্ডাস যেমন লোড করা যাবে 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 মডেল। প্রতিটি কলাম পৃথকভাবে পরিচালনা করা প্রয়োজন।

একটি বিকল্প হিসাবে, আপনি আপনার ডেটা অফলাইনে প্রি -প্রসেস করতে পারেন (যেকোনো টুল ব্যবহার করে) শ্রেণিবদ্ধ কলামগুলিকে সংখ্যাসূচক কলামে রূপান্তর করতে পারেন, তারপর প্রসেসড আউটপুটটি আপনার টেন্সরফ্লো মডেলে প্রেরণ করুন। এই পদ্ধতির অসুবিধা হল যে আপনি যদি আপনার মডেল সংরক্ষণ এবং রপ্তানি করেন তবে প্রিপ্রোসেসিং এটির সাথে সংরক্ষণ করা হয় না। experimental.preprocessing কারণ তারা মডেল অংশ স্তর এই সমস্যা এড়ানো।

এই উদাহরণে, আপনি একটি মডেল তৈরী করব যে কার্যকরী preprocessing যুক্তিবিজ্ঞান ব্যবহার Keras কার্মিক এপিআই । এছাড়াও আপনি দ্বারা এটা করতে পারে subclassing

কার্যকরী এপিআই "সিম্বলিক" টেনসারে কাজ করে। সাধারণ "আগ্রহী" টেন্সরের একটি মান আছে। বিপরীতে এই "প্রতীকী" tensors না। পরিবর্তে তারা তাদের উপর কোন অপারেশন চালানো হয় তার হিসাব রাখে এবং হিসাবের প্রতিনিধিত্ব তৈরি করে, যা আপনি পরে চালাতে পারেন। এখানে একটি দ্রুত উদাহরণ:

# 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
<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 = preprocessing.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]

STRING এর জন্য ইনপুট ব্যবহার preprocessing.StringLookup একটি শব্দভান্ডার মধ্যে পূর্ণসংখ্যা সূচকের স্ট্রিং থেকে ম্যাপ ফাংশন। এর পরে, ব্যবহার preprocessing.CategoryEncoding মধ্যে ইনডেক্স রূপান্তর করতে float32 মডেল জন্য তথ্য উপযুক্ত।

জন্য ডিফল্ট সেটিংস preprocessing.CategoryEncoding স্তর প্রতিটি ইনপুট জন্য একটি এক গরম ভেক্টর তৈরি করুন। একজন layers.Embedding এছাড়াও কাজ করবে। দেখুন স্তর নির্দেশিকা preprocessing এবং টিউটোরিয়াল এই বিষয়ে আরো জন্য।

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

png

এই 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, 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)>

এখন এর উপরে মডেল তৈরি করুন:

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 3ms/step - loss: 0.5665
Epoch 2/10
20/20 [==============================] - 0s 3ms/step - loss: 0.4980
Epoch 3/10
20/20 [==============================] - 0s 3ms/step - loss: 0.4643
Epoch 4/10
20/20 [==============================] - 0s 3ms/step - loss: 0.4463
Epoch 5/10
20/20 [==============================] - 0s 3ms/step - loss: 0.4333
Epoch 6/10
20/20 [==============================] - 0s 3ms/step - loss: 0.4297
Epoch 7/10
20/20 [==============================] - 0s 3ms/step - loss: 0.4252
Epoch 8/10
20/20 [==============================] - 0s 4ms/step - loss: 0.4234
Epoch 9/10
20/20 [==============================] - 0s 4ms/step - loss: 0.4213
Epoch 10/10
20/20 [==============================] - 0s 4ms/step - loss: 0.4202
<tensorflow.python.keras.callbacks.History at 0x7f7c8ff43510>

যেহেতু প্রিপ্রোসেসিং মডেলের অংশ, আপনি মডেলটি সংরক্ষণ করতে পারেন এবং অন্য কোথাও এটি পুনরায় লোড করতে পারেন এবং অভিন্ন ফলাফল পেতে পারেন:

titanic_model.save('test')
reloaded = tf.keras.models.load_model('test')
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.843]], shape=(1, 1), dtype=float32)
tf.Tensor([[-1.843]], shape=(1, 1), dtype=float32)

Tf.data ব্যবহার করে

আগের বিভাগে আপনি মডেলকে প্রশিক্ষণের সময় মডেলের অন্তর্নির্মিত ডেটা শাফলিং এবং ব্যাচিংয়ের উপর নির্ভর করেছিলেন।

ব্যবহার: আপনি ইনপুট ডেটা পাইপলাইন বা তথ্য সহজেই মেমরিতে মাপসই করা হবে না ব্যবহার করার জন্য প্রয়োজন উপর আরো বেশি নিয়ন্ত্রণ প্রয়োজন tf.data

আরো উদাহরণ দেখুন tf.data নির্দেশিকা

মেমরি ডেটা চালু

প্রয়োগের একটি প্রথম উদাহরণ হিসাবে tf.data করা CSV তথ্য পূর্ববর্তী অধ্যায় থেকে বৈশিষ্ট্য অভিধান আপ ম্যানুয়ালি ফালি নিম্নলিখিত কোড বিবেচনা। প্রতিটি সূচকের জন্য, প্রতিটি বৈশিষ্ট্যের জন্য সেই সূচকটি গ্রহণ করে:

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 4ms/step - loss: 0.4199
Epoch 2/5
20/20 [==============================] - 0s 4ms/step - loss: 0.4199
Epoch 3/5
20/20 [==============================] - 0s 4ms/step - loss: 0.4192
Epoch 4/5
20/20 [==============================] - 0s 4ms/step - loss: 0.4189
Epoch 5/5
20/20 [==============================] - 0s 4ms/step - loss: 0.4185
<tensorflow.python.keras.callbacks.History at 0x7f7c8e8ee810>

একটি একক ফাইল থেকে

এখন পর্যন্ত এই টিউটোরিয়ালটি ইন-মেমরি ডেটা নিয়ে কাজ করেছে। 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'female' b'male' b'male' b'male']
age                 : [28. 28. 70.  1. 28.]
n_siblings_spouses  : [1 0 1 5 1]
parch               : [0 0 1 2 0]
fare                : [82.171  7.225 71.    46.9   15.85 ]
class               : [b'First' b'Third' b'First' b'Third' b'Third']
deck                : [b'unknown' b'unknown' b'B' b'unknown' b'unknown']
embark_town         : [b'Cherbourg' b'Cherbourg' b'Southampton' b'Southampton' b'Southampton']
alone               : [b'n' b'y' b'n' b'n' b'n']

label               : [0 1 0 0 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 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                : [275.36 264.13 265.53 278.63 289.91]
rain_1h             : [0.   0.   0.   0.   1.52]
snow_1h             : [0. 0. 0. 0. 0.]
clouds_all          : [90 90 75 90 80]
weather_main        : [b'Rain' b'Clouds' b'Clouds' b'Rain' b'Mist']
weather_description : [b'light rain' b'overcast clouds' b'broken clouds' b'light rain' b'mist']
date_time           : [b'2013-03-10 19:00:00' b'2013-01-02 19:00:00' b'2012-12-06 06:00:00'
 b'2013-04-25 18:00:00' b'2013-07-31 04:00:00']

label               : [2743 2687 5545 5020  822]

ক্যাশিং

সিএসভি ডেটা পার্স করার জন্য কিছু ওভারহেড আছে। ছোট মডেলগুলির জন্য এটি প্রশিক্ষণে বাধা হতে পারে।

আপনার ব্যবহার কেস উপর নির্ভর করে এটি ব্যবহার করতে একটি ভাল ধারণা হতে পারে Dataset.cache বা data.experimental.snapshot যাতে CSV ডেটা শুধুমাত্র প্রথম অধিযুগ উপর পার্স করা হয়।

মধ্যে মূল পার্থক্য cache এবং snapshot পদ্ধতি যে cache ফাইল শুধুমাত্র TensorFlow প্রক্রিয়া যা তাদেরকে সৃষ্টি করেছেন দ্বারা ব্যবহার করা যেতে পারে, কিন্তু snapshot ফাইল অন্যান্য প্রক্রিয়ার মাধ্যমে পড়া যায়।

উদাহরণস্বরূপ, উপর iterating 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 14.9 s, sys: 3.58 s, total: 18.5 s
Wall time: 11 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.42 s, sys: 115 ms, total: 1.53 s
Wall time: 1.22 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.26 s, sys: 431 ms, total: 2.69 s
Wall time: 1.62 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
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 ধাঁচের পাস করতে পারেন 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'GLOUCESTER' b'REFERENCE' b'TREBUCHET' b'MONEY' b'GLOUCESTER' b'MONEY'
 b'GLOUCESTER' b'JUICE' b'CAMBRIA' b'BRUSH']
fontVariant         : [b'GLOUCESTER MT EXTRA CONDENSED' b'MS REFERENCE SANS SERIF'
 b'TREBUCHET MS' b'scanned' b'GLOUCESTER MT EXTRA CONDENSED' b'scanned'
 b'GLOUCESTER MT EXTRA CONDENSED' b'JUICE ITC' b'CAMBRIA'
 b'BRUSH SCRIPT MT']
m_label             : [  116 63521   507    53   402    54  8747   213 10766  8776]
strength            : [0.4 0.4 0.4 0.4 0.4 0.4 0.4 0.4 0.4 0.4]
italic              : [1 0 0 0 0 0 0 1 0 1]
orientation         : [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
m_top               : [41 21 23  0 31  0 22 20 25 44]
m_left              : [25 26 23  0 15  0 20 27 23 24]
originalH           : [42 68 64 32 63 27 68 61 73 25]
originalW           : [18 30 30 19 22 16 18 33 32 36]
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 1 1 1 1 1]
r0c1                : [ 1  1  1 91  1  1  1  1  1  1]
r0c2                : [  1   1   1 239   1   1   1   1   1  40]
r0c3                : [  1   1   1 255   1   1   1   1   1  74]
...
[total: 412 features]

Ptionচ্ছিক: প্যাকিং ক্ষেত্র

আপনি সম্ভবত প্রতিটি পিক্সেলের সাথে এভাবে আলাদা কলামে কাজ করতে চান না। এই ডেটাসেটটি ব্যবহার করার চেষ্টা করার আগে পিক্সেলগুলিকে একটি ইমেজ-টেনসারে প্যাক করতে ভুলবেন না।

এখানে কোড যা প্রতিটি উদাহরণের জন্য ছবি তৈরির জন্য কলামের নামগুলি বিশ্লেষণ করে:

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

png

নিম্ন স্তরের ফাংশন

এখন পর্যন্ত এই টিউটোরিয়ালটি সিএসভি ডেটা পড়ার জন্য সর্বোচ্চ স্তরের ইউটিলিটিগুলিতে মনোনিবেশ করেছে। আরও দুটি API রয়েছে যা উন্নত ব্যবহারকারীদের জন্য সহায়ক হতে পারে যদি আপনার ব্যবহারের ক্ষেত্রে মৌলিক নিদর্শনগুলির সাথে মানানসই না হয়।

  • tf.io.decode_csv - CSV- তে কলাম tensors একটি তালিকা মধ্যে লেখার লাইনের পার্স একটি ফাংশন।
  • 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 সংশ্লিষ্ট ধরনের:

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 বর্গ একটি ন্যূনতম যে CSV প্রদান করে Dataset সুবিধার বৈশিষ্ট্য ছাড়া ইন্টারফেস make_csv_dataset কলাম শিরোনাম পার্সিং, কলাম টাইপ-অনুমান, স্বয়ংক্রিয় প্রকাশের shuffling, ফাইল 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

শুধুমাত্র প্রথম দুটি ক্ষেত্র হল স্ট্রিং, বাকিগুলো হল ints বা floats, এবং আপনি কমা গণনা করে মোট বৈশিষ্ট্য সংখ্যা পেতে পারেন:

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

এখানে একটি প্রাথমিক ডেটাসেট রয়েছে যাতে 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/BROADWAY.csv'
     b'fonts/COPPERPLATE.csv'
     b'fonts/STENCIL.csv'
     b'fonts/COOPER.csv'
     b'fonts/GABRIOLA.csv'
    ...

Epoch 2:
     b'fonts/MONOSPAC821.csv'
     b'fonts/ONYX.csv'
     b'fonts/HARLOW.csv'
     b'fonts/TIMES.csv'
     b'fonts/JOKERMAN.csv'
    ...

interleave পদ্ধতি লাগে map_func করে একটি child- সৃষ্টি Dataset parent- প্রতিটি উপাদানের জন্য Dataset

এখানে, আপনি একটি তৈরি করতে চান CsvDataset ফাইলের ডেটাসেটের প্রতিটি উপাদান থেকে:

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

Dataset child- একটি নম্বর উপর সাইকেল দ্বারা ইন্টারলিভ আয় উপাদান দ্বারা ফিরে 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 আরও দক্ষ যখন স্ট্রিং একটি ব্যাচ চালানো হয়।

এটা তোলে এই সত্য সুবিধা গ্রহণ করতে, যখন বড় ব্যাচ মাপ ব্যবহার করে, যে 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 26.8 s, sys: 1.75 s, total: 28.6 s
Wall time: 11.1 s

টেক্সট লাইনের ব্যাচ পাসিং করতে decode_csv দ্রুত রান 5s about:

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

বড় ব্যাচ ব্যবহার করে CSV কর্মক্ষমতা বৃদ্ধি আরেকটি উদাহরণ দেখুন overfit এবং underfit টিউটোরিয়াল

পদ্ধতির এই ধরনের কাজ করে, কিন্তু মত অন্যান্য অপশন বিবেচনা করতে পারে cache এবং snapshot আরো একটি মসৃণ বিন্যাসে, অথবা আপনার ডেটা পুনরায় enncoding।