সাহায্য Kaggle উপর TensorFlow সঙ্গে গ্রেট বেরিয়ার রিফ রক্ষা চ্যালেঞ্জ যোগদান

tf.data: TensorFlow ইনপুট পাইপলাইন তৈরি করুন

TensorFlow.org এ দেখুন GitHub-এ উৎস দেখুননোটবুক ডাউনলোড করুন

tf.data API আপনাকে সহজ, পুনর্ব্যবহারযোগ্য টুকরা থেকে জটিল ইনপুট পাইপলাইনগুলি গড়ে তুলতে সক্ষম। উদাহরণস্বরূপ, একটি চিত্র মডেলের জন্য পাইপলাইন একটি বিতরণ করা ফাইল সিস্টেমের ফাইলগুলি থেকে ডেটা একত্রিত করতে পারে, প্রতিটি ছবিতে এলোমেলোভাবে বিভ্রান্তি প্রয়োগ করতে পারে এবং প্রশিক্ষণের জন্য এলোমেলোভাবে নির্বাচিত চিত্রগুলিকে একত্রিত করতে পারে। একটি টেক্সট মডেলের জন্য পাইপলাইনে কাঁচা পাঠ্য ডেটা থেকে চিহ্নগুলি বের করা, একটি লুকআপ টেবিলের সাহায্যে এম্বেডিং শনাক্তকারীতে রূপান্তর করা এবং বিভিন্ন দৈর্ঘ্যের ক্রমগুলি একসাথে ব্যাচ করা জড়িত থাকতে পারে। tf.data এপিআই এটা সম্ভব, বিপুল পরিমাণ ডেটা হ্যান্ডেল বিভিন্ন ডেটা ফরম্যাটের থেকে পড়া, এবং জটিল রূপান্তরের সঞ্চালন করে তোলে।

tf.data API প্রবর্তন একটি tf.data.Dataset বিমূর্ততা যে উপাদানের একটি ক্রম, যা প্রতিটি উপাদান এক বা একাধিক উপাদান নিয়ে গঠিত প্রতিনিধিত্ব করে। উদাহরণস্বরূপ, একটি চিত্র পাইপলাইনে, একটি উপাদান একটি একক প্রশিক্ষণের উদাহরণ হতে পারে, যেখানে চিত্র এবং এর লেবেলের প্রতিনিধিত্ব করে এক জোড়া টেনসর উপাদান।

একটি ডেটাসেট তৈরি করার দুটি স্বতন্ত্র উপায় রয়েছে:

  • একটি তথ্য উৎস একটি নির্মান Dataset তথ্য মেমরিতে সঞ্চিত অথবা এক বা একাধিক ফাইল থেকে।

  • ডেটা রূপান্তর এক বা একাধিক থেকে একটি ডেটাসেটের নির্মান tf.data.Dataset বস্তু।

import tensorflow as tf
import pathlib
import os
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

np.set_printoptions(precision=4)

বেসিক মেকানিক্স

একটি ইনপুট পাইপলাইন তৈরি করতে হলে, আপনি একটি তথ্য উৎস দিয়ে শুরু হবে। উদাহরণস্বরূপ, একটি গঠন করা Dataset মেমরি তথ্য থেকে, আপনি ব্যবহার করতে পারেন tf.data.Dataset.from_tensors() বা tf.data.Dataset.from_tensor_slices() । বিকল্পভাবে, যদি আপনার ইনপুট ডেটা সুপারিশ TFRecord বিন্যাসে একটি ফাইলে সংরক্ষণ করা হয়, আপনি ব্যবহার করতে পারেন tf.data.TFRecordDataset()

একবার আপনি একটি আছে Dataset বস্তু, যদি আপনি একটি নতুন সেটিকে রুপান্তর করতে পারেন Dataset উপর পদ্ধতি কল chaining দ্বারা tf.data.Dataset অবজেক্ট। উদাহরণস্বরূপ, যদি আপনি প্রতি উপাদান যেমন রূপান্তরের আবেদন করতে পারেন Dataset.map() , এবং যেমন বহু-উপাদান রূপান্তরের Dataset.batch() । জন্য ডকুমেন্টেশন দেখুন tf.data.Dataset রূপান্তরের একটি সম্পূর্ণ তালিকা জন্য।

Dataset বস্তুর একটি পাইথন iterable হয়। এটি একটি লুপ ব্যবহার করে এর উপাদানগুলিকে গ্রাস করা সম্ভব করে তোলে:

dataset = tf.data.Dataset.from_tensor_slices([8, 3, 0, 8, 2, 1])
dataset
<TensorSliceDataset shapes: (), types: tf.int32>
for elem in dataset:
  print(elem.numpy())
8
3
0
8
2
1

অথবা স্পষ্টভাবে একটি পাইথন তৈরি পুনরুক্তিকারীর ব্যবহার করে iter এবং তার উপাদানগুলি ব্যবহার করে গ্রাসকারী next :

it = iter(dataset)

print(next(it).numpy())
8

অন্যথা, ডেটা সেটটি উপাদানগুলি ব্যবহার করে ধ্বংস করা যেতে পারে reduce রূপান্তর, যা একটি একক কোনো ফলাফল উত্পাদন করতে সব উপাদান হ্রাস করা হয়। নিম্নলিখিত উদাহরণে কিভাবে ব্যবহার করতে প্রকাশ reduce পূর্ণসংখ্যার একটি ডেটাসেটের সমষ্টি গনা রূপান্তর।

print(dataset.reduce(0, lambda state, value: state + value).numpy())
22

ডেটাসেট গঠন

একটি ডেটাসেটের উপাদান, যেখানে প্রতিটি উপাদান একই (নেস্টেড) উপাদান কাঠামো একটি ক্রম উৎপন্ন হয়। কাঠামো স্বতন্ত্র উপাদান দ্বারা কোন প্রকার representable হতে পারি tf.TypeSpec সহ tf.Tensor , tf.sparse.SparseTensor , tf.RaggedTensor , tf.TensorArray , অথবা tf.data.Dataset

পাইথন নির্মান যে উপাদানের (নেস্টেড) গঠন প্রকাশ করার ব্যবহার করা যেতে পারে অন্তর্ভুক্ত tuple , dict , NamedTuple এবং OrderedDict । বিশেষ করে, list ডেটা সেটটি উপাদানের গঠন প্রকাশ করার জন্য একটি বৈধ কনস্ট্রাক্ট নয়। এর কারণ হল তাড়াতাড়ি tf.data ব্যবহারকারীদের দৃঢ়ভাবে সম্পর্কে অনুভূত list (যেমন প্রেরণ ইনপুট tf.data.Dataset.from_tensors ) স্বয়ংক্রিয়ভাবে tensors এবং বস্তাবন্দী হচ্ছে list আউটপুট (ব্যবহারকারী-সংজ্ঞায়িত ফাংশন যেমন আগমন মান) একটি করতে বাধ্য হচ্ছে tuple । ফলত, যদি আপনি একটি চাই list ইনপুট একটি কাঠামো হিসাবে চিকিত্সা করা, আপনি তা রূপান্তর করতে হবে tuple এবং যদি আপনি একটি চাই list আউটপুট একটি একক উপাদান বলে, তাহলে আপনি স্পষ্টভাবে ব্যবহার করে এটি প্যাক করার প্রয়োজন tf.stack .

Dataset.element_spec সম্পত্তি আপনি প্রতিটি উপাদান উপাদান ধরণ পরিদর্শন করতে পারবেন। সম্পত্তির দৃঢ় গঠন ফেরৎ tf.TypeSpec বস্তু, উপাদান, যা একটি একক কম্পোনেন্ট, উপাদানের একটি tuple, অথবা উপাদানের একটি নেস্টেড tuple হতে পারে কাঠামো মিলে। উদাহরণ স্বরূপ:

dataset1 = tf.data.Dataset.from_tensor_slices(tf.random.uniform([4, 10]))

dataset1.element_spec
TensorSpec(shape=(10,), dtype=tf.float32, name=None)
dataset2 = tf.data.Dataset.from_tensor_slices(
   (tf.random.uniform([4]),
    tf.random.uniform([4, 100], maxval=100, dtype=tf.int32)))

dataset2.element_spec
(TensorSpec(shape=(), dtype=tf.float32, name=None),
 TensorSpec(shape=(100,), dtype=tf.int32, name=None))
dataset3 = tf.data.Dataset.zip((dataset1, dataset2))

dataset3.element_spec
(TensorSpec(shape=(10,), dtype=tf.float32, name=None),
 (TensorSpec(shape=(), dtype=tf.float32, name=None),
  TensorSpec(shape=(100,), dtype=tf.int32, name=None)))
# Dataset containing a sparse tensor.
dataset4 = tf.data.Dataset.from_tensors(tf.SparseTensor(indices=[[0, 0], [1, 2]], values=[1, 2], dense_shape=[3, 4]))

dataset4.element_spec
SparseTensorSpec(TensorShape([3, 4]), tf.int32)
# Use value_type to see the type of value represented by the element spec
dataset4.element_spec.value_type
tensorflow.python.framework.sparse_tensor.SparseTensor

Dataset রূপান্তরের কোন কাঠামো ডেটাসেট সমর্থন করি। ব্যবহার করার সময় Dataset.map() , এবং Dataset.filter() রূপান্তরের, যা প্রতিটি উপাদানে একটি ফাংশন প্রযোজ্য উপাদান গঠন ফাংশনের আর্গুমেন্ট নির্ধারণ:

dataset1 = tf.data.Dataset.from_tensor_slices(
    tf.random.uniform([4, 10], minval=1, maxval=10, dtype=tf.int32))

dataset1
<TensorSliceDataset shapes: (10,), types: tf.int32>
for z in dataset1:
  print(z.numpy())
[3 1 4 9 2 5 1 3 1 1]
[4 8 6 1 5 2 4 6 2 4]
[6 4 7 7 6 7 8 9 2 5]
[3 6 3 8 2 2 3 8 1 6]
dataset2 = tf.data.Dataset.from_tensor_slices(
   (tf.random.uniform([4]),
    tf.random.uniform([4, 100], maxval=100, dtype=tf.int32)))

dataset2
<TensorSliceDataset shapes: ((), (100,)), types: (tf.float32, tf.int32)>
dataset3 = tf.data.Dataset.zip((dataset1, dataset2))

dataset3
<ZipDataset shapes: ((10,), ((), (100,))), types: (tf.int32, (tf.float32, tf.int32))>
for a, (b,c) in dataset3:
  print('shapes: {a.shape}, {b.shape}, {c.shape}'.format(a=a, b=b, c=c))
shapes: (10,), (), (100,)
shapes: (10,), (), (100,)
shapes: (10,), (), (100,)
shapes: (10,), (), (100,)

ইনপুট ডেটা পড়া

NumPy অ্যারে ব্যবহার করছে

দেখুন NumPy অ্যারে লোড হচ্ছে আরো উদাহরণ জন্য।

স্মৃতিতে আপনার ইনপুট ডেটা তড়কা সব, একটি তৈরি করতে সহজ উপায় যদি Dataset তাদের কাছ থেকে তাদের রূপান্তর হয় tf.Tensor বস্তু এবং ব্যবহার Dataset.from_tensor_slices()

train, test = tf.keras.datasets.fashion_mnist.load_data()
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-labels-idx1-ubyte.gz
32768/29515 [=================================] - 0s 0us/step
40960/29515 [=========================================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-images-idx3-ubyte.gz
26427392/26421880 [==============================] - 0s 0us/step
26435584/26421880 [==============================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-labels-idx1-ubyte.gz
16384/5148 [===============================================================================================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-images-idx3-ubyte.gz
4423680/4422102 [==============================] - 0s 0us/step
4431872/4422102 [==============================] - 0s 0us/step
images, labels = train
images = images/255

dataset = tf.data.Dataset.from_tensor_slices((images, labels))
dataset
<TensorSliceDataset shapes: ((28, 28), ()), types: (tf.float64, tf.uint8)>

পাইথন জেনারেটর ব্যবহার করছে

আরেকটি সাধারণ তথ্য উৎস সহজেই হিসেবে পাকস্থলিতে গ্রহণ করা যেতে পারে tf.data.Dataset পাইথন জেনারেটর।

def count(stop):
  i = 0
  while i<stop:
    yield i
    i += 1
for n in count(5):
  print(n)
0
1
2
3
4

Dataset.from_generator কন্সট্রাকটর একটি সম্পূর্ণ ক্রিয়ামূলক করার পাইথন জেনারেটরের পরিবর্তন করে tf.data.Dataset

কনস্ট্রাক্টর একটি কলযোগ্য ইনপুট হিসাবে নেয়, একটি পুনরাবৃত্তিকারী নয়। এটি জেনারেটর শেষ হয়ে গেলে এটি পুনরায় চালু করার অনুমতি দেয়। এটি একটি ঐচ্ছিক লাগে args যুক্তি, যা callable এর আর্গুমেন্ট হিসাবে পাস করা হয়েছে।

output_types যুক্তি প্রয়োজন বোধ করা হয় কারণ tf.data একটি তৈরী করে tf.Graph অভ্যন্তরীণভাবে এবং গ্রাফ প্রান্ত একটি প্রয়োজন tf.dtype

ds_counter = tf.data.Dataset.from_generator(count, args=[25], output_types=tf.int32, output_shapes = (), )
for count_batch in ds_counter.repeat().batch(10).take(10):
  print(count_batch.numpy())
[0 1 2 3 4 5 6 7 8 9]
[10 11 12 13 14 15 16 17 18 19]
[20 21 22 23 24  0  1  2  3  4]
[ 5  6  7  8  9 10 11 12 13 14]
[15 16 17 18 19 20 21 22 23 24]
[0 1 2 3 4 5 6 7 8 9]
[10 11 12 13 14 15 16 17 18 19]
[20 21 22 23 24  0  1  2  3  4]
[ 5  6  7  8  9 10 11 12 13 14]
[15 16 17 18 19 20 21 22 23 24]

output_shapes যুক্তি প্রয়োজন হয় না কিন্তু অত্যন্ত অনেক tensorflow অপারেশন যেমন recomended হয় অজানা পদে থেকে tensors সমর্থন করি না। একটি নির্দিষ্ট অক্ষ দৈর্ঘ্যের অজানা বা পরিবর্তনশীল হয়, তাহলে হিসাবে সেট None মধ্যে output_shapes

এছাড়া খেয়াল করা জরুরী যে গুরুত্বপূর্ণ output_shapes এবং output_types অন্যান্য ডেটা সেটটি পদ্ধতি হিসাবে একই পাখির নিয়ম অনুসরণ।

এখানে একটি উদাহরণ জেনারেটর যা উভয় দিক প্রদর্শন করে, এটি অ্যারের টিপল প্রদান করে, যেখানে দ্বিতীয় অ্যারেটি অজানা দৈর্ঘ্য সহ একটি ভেক্টর।

def gen_series():
  i = 0
  while True:
    size = np.random.randint(0, 10)
    yield i, np.random.normal(size=(size,))
    i += 1
for i, series in gen_series():
  print(i, ":", str(series))
  if i > 5:
    break
0 : [-1.2659 -0.0164  0.8822  0.9887 -0.5352 -1.1873  0.6209]
1 : [-0.492  -2.3205 -0.5924 -0.2635  0.6136  1.9545  1.7315  0.4508]
2 : [0.2972]
3 : [ 0.2433  0.0502 -1.0612 -0.1499 -0.0939  0.5694  0.2207]
4 : [-1.8696 -0.4797]
5 : [ 0.3438 -0.4853 -0.36  ]
6 : [-0.9741]

প্রথম আউটপুট একটি হল int32 সেকেন্ডকে হয় float32

প্রথম আইটেম স্কেলের, আকৃতি হয় () , এবং দ্বিতীয় অজানা দৈর্ঘ্য, আকৃতি একটি ভেক্টর হয় (None,)

ds_series = tf.data.Dataset.from_generator(
    gen_series, 
    output_types=(tf.int32, tf.float32), 
    output_shapes=((), (None,)))

ds_series
<FlatMapDataset shapes: ((), (None,)), types: (tf.int32, tf.float32)>

এখন এটি একটি নিয়মিত মত ব্যবহার করা যেতে পারে tf.data.Dataset । মনে রাখবেন যে যখন একটি পরিবর্তনশীল আকৃতি সঙ্গে একটি ডেটাসেটের Batching, আপনি ব্যবহার করতে হবে Dataset.padded_batch

ds_series_batch = ds_series.shuffle(20).padded_batch(10)

ids, sequence_batch = next(iter(ds_series_batch))
print(ids.numpy())
print()
print(sequence_batch.numpy())
[ 5  7 10  4  2 13 25 18 17 27]

[[ 0.8387  0.2497  1.7194  0.      0.      0.      0.      0.      0.    ]
 [-2.3122 -1.1238 -1.3219 -0.0437 -0.0156 -1.5395  1.0858  0.      0.    ]
 [-0.8438  0.6191 -0.9143 -0.0623  0.1734 -0.5583  0.8883  0.      0.    ]
 [-0.955   0.3145  0.4488  0.6816  0.      0.      0.      0.      0.    ]
 [ 0.3774  0.      0.      0.      0.      0.      0.      0.      0.    ]
 [ 0.0288  0.5001 -1.4579  0.576  -0.8185  0.1437  0.8146 -0.9032  0.    ]
 [ 0.      0.      0.      0.      0.      0.      0.      0.      0.    ]
 [ 0.      0.      0.      0.      0.      0.      0.      0.      0.    ]
 [-0.7994 -0.8724 -0.4017  0.      0.      0.      0.      0.      0.    ]
 [-0.0224  0.9805  0.0618 -0.0507 -0.3333 -0.4813  0.7181  0.351   0.097 ]]

একটি আরো বাস্তবসম্মত উদাহরণস্বরূপ, মোড়কে চেষ্টা preprocessing.image.ImageDataGenerator হিসেবে tf.data.Dataset

প্রথমে ডেটা ডাউনলোড করুন:

flowers = tf.keras.utils.get_file(
    'flower_photos',
    'https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz',
    untar=True)
Downloading data from https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz
228818944/228813984 [==============================] - 5s 0us/step
228827136/228813984 [==============================] - 5s 0us/step

তৈরি করুন image.ImageDataGenerator

img_gen = tf.keras.preprocessing.image.ImageDataGenerator(rescale=1./255, rotation_range=20)
images, labels = next(img_gen.flow_from_directory(flowers))
Found 3670 images belonging to 5 classes.
print(images.dtype, images.shape)
print(labels.dtype, labels.shape)
float32 (32, 256, 256, 3)
float32 (32, 5)
ds = tf.data.Dataset.from_generator(
    lambda: img_gen.flow_from_directory(flowers), 
    output_types=(tf.float32, tf.float32), 
    output_shapes=([32,256,256,3], [32,5])
)

ds.element_spec
(TensorSpec(shape=(32, 256, 256, 3), dtype=tf.float32, name=None),
 TensorSpec(shape=(32, 5), dtype=tf.float32, name=None))
for images, label in ds.take(1):
  print('images.shape: ', images.shape)
  print('labels.shape: ', labels.shape)
Found 3670 images belonging to 5 classes.
images.shape:  (32, 256, 256, 3)
labels.shape:  (32, 5)

TFRecord ডেটা ব্যবহার করছে

দেখুন TFRecords লোড হচ্ছে একটি এন্ড-টু-এন্ড উদাহরণস্বরূপ।

tf.data API যা আপনাকে বড় ডেটাসেট যে মেমরি মাপসই করা হবে না প্রক্রিয়া করতে পারি, যাতে ফাইল ফরম্যাটের বিভিন্ন সমর্থন করে। উদাহরণ স্বরূপ, TFRecord ফাইল ফরম্যাট হল একটি সাধারণ রেকর্ড-ভিত্তিক বাইনারি বিন্যাস যা অনেক TensorFlow অ্যাপ্লিকেশন প্রশিক্ষণ ডেটার জন্য ব্যবহার করে। tf.data.TFRecordDataset বর্গ আপনি একটি ইনপুট পাইপলাইন অংশ হিসেবে এক বা একাধিক TFRecord ফাইলের সামগ্রী উপর স্ট্রিম করতে সক্ষম করে।

ফ্রেঞ্চ স্ট্রিট নেম সাইনস (FSNS) থেকে পরীক্ষা ফাইল ব্যবহার করে এখানে একটি উদাহরণ দেওয়া হল।

# Creates a dataset that reads all of the examples from two files.
fsns_test_file = tf.keras.utils.get_file("fsns.tfrec", "https://storage.googleapis.com/download.tensorflow.org/data/fsns-20160927/testdata/fsns-00000-of-00001")
Downloading data from https://storage.googleapis.com/download.tensorflow.org/data/fsns-20160927/testdata/fsns-00000-of-00001
7905280/7904079 [==============================] - 0s 0us/step
7913472/7904079 [==============================] - 0s 0us/step

filenames আর্গুমেন্ট প্রাপ্ত করতে TFRecordDataset সূচনাকারী পারেন একটি স্ট্রিং, স্ট্রিং একটি তালিকা, অথবা একটি হতে পারে tf.Tensor স্ট্রিং। তাই আপনার কাছে প্রশিক্ষণ এবং বৈধতার উদ্দেশ্যে দুটি সেট ফাইল থাকলে, আপনি একটি ফ্যাক্টরি পদ্ধতি তৈরি করতে পারেন যা ডেটাসেট তৈরি করে, ফাইলের নামগুলিকে ইনপুট আর্গুমেন্ট হিসাবে গ্রহণ করে:

dataset = tf.data.TFRecordDataset(filenames = [fsns_test_file])
dataset
<TFRecordDatasetV2 shapes: (), types: tf.string>

অনেক TensorFlow প্রকল্প ধারাবাহিকভাবে ব্যবহার tf.train.Example তাদের TFRecord ফাইল রেকর্ড। এগুলি পরিদর্শন করার আগে ডিকোড করা দরকার:

raw_example = next(iter(dataset))
parsed = tf.train.Example.FromString(raw_example.numpy())

parsed.features.feature['image/text']
bytes_list {
  value: "Rue Perreyon"
}

টেক্সট ডেটা গ্রাস করছে

দেখুন লেখা লোড হচ্ছে শেষ উদাহরণ শেষ জন্য।

অনেক ডেটাসেট এক বা একাধিক টেক্সট ফাইল হিসাবে বিতরণ করা হয়। tf.data.TextLineDataset একটি সহজ উপায় এক বা একাধিক টেক্সট ফাইল থেকে লাইন বের করে আনতে প্রদান করে। এক বা একাধিক ফাইলের নামের দেওয়া, একটি TextLineDataset প্রতি ঐ ফাইল লাইনে একটি স্ট্রিং-মূল্যবান উপাদান উত্পাদন করা হবে।

directory_url = 'https://storage.googleapis.com/download.tensorflow.org/data/illiad/'
file_names = ['cowper.txt', 'derby.txt', 'butler.txt']

file_paths = [
    tf.keras.utils.get_file(file_name, directory_url + file_name)
    for file_name in file_names
]
Downloading data from https://storage.googleapis.com/download.tensorflow.org/data/illiad/cowper.txt
819200/815980 [==============================] - 0s 0us/step
827392/815980 [==============================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/download.tensorflow.org/data/illiad/derby.txt
811008/809730 [==============================] - 0s 0us/step
819200/809730 [==============================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/download.tensorflow.org/data/illiad/butler.txt
811008/807992 [==============================] - 0s 0us/step
819200/807992 [==============================] - 0s 0us/step
dataset = tf.data.TextLineDataset(file_paths)

এখানে প্রথম ফাইলের প্রথম কয়েকটি লাইন রয়েছে:

for line in dataset.take(5):
  print(line.numpy())
b"\xef\xbb\xbfAchilles sing, O Goddess! Peleus' son;"
b'His wrath pernicious, who ten thousand woes'
b"Caused to Achaia's host, sent many a soul"
b'Illustrious into Ades premature,'
b'And Heroes gave (so stood the will of Jove)'

ফাইলের মধ্যে বিকল্প লাইন করার জন্য ব্যবহার Dataset.interleave । এটি একসাথে ফাইলগুলিকে এলোমেলো করা সহজ করে তোলে। এখানে প্রতিটি অনুবাদের প্রথম, দ্বিতীয় এবং তৃতীয় লাইন রয়েছে:

files_ds = tf.data.Dataset.from_tensor_slices(file_paths)
lines_ds = files_ds.interleave(tf.data.TextLineDataset, cycle_length=3)

for i, line in enumerate(lines_ds.take(9)):
  if i % 3 == 0:
    print()
  print(line.numpy())
b"\xef\xbb\xbfAchilles sing, O Goddess! Peleus' son;"
b"\xef\xbb\xbfOf Peleus' son, Achilles, sing, O Muse,"
b'\xef\xbb\xbfSing, O goddess, the anger of Achilles son of Peleus, that brought'

b'His wrath pernicious, who ten thousand woes'
b'The vengeance, deep and deadly; whence to Greece'
b'countless ills upon the Achaeans. Many a brave soul did it send'

b"Caused to Achaia's host, sent many a soul"
b'Unnumbered ills arose; which many a soul'
b'hurrying down to Hades, and many a hero did it yield a prey to dogs and'

ডিফল্টরূপে, একটি TextLineDataset যদি ফাইল, একটি শিরোলেখ লাইন দিয়ে শুরু হয় বা মন্তব্য রয়েছে, প্রতিটি ফাইল, যা কাম্য নাও হতে পারে, উদাহরণস্বরূপ প্রতিটি লাইন উৎপাদ। এই লাইন ব্যবহার মুছে ফেলা হতে পারে Dataset.skip() বা Dataset.filter() রূপান্তরের। এখানে, আপনি প্রথম লাইনটি এড়িয়ে যান, তারপর শুধুমাত্র জীবিতদের খুঁজে বের করতে ফিল্টার করুন।

titanic_file = tf.keras.utils.get_file("train.csv", "https://storage.googleapis.com/tf-datasets/titanic/train.csv")
titanic_lines = tf.data.TextLineDataset(titanic_file)
Downloading data from https://storage.googleapis.com/tf-datasets/titanic/train.csv
32768/30874 [===============================] - 0s 0us/step
40960/30874 [=======================================] - 0s 0us/step
for line in titanic_lines.take(10):
  print(line.numpy())
b'survived,sex,age,n_siblings_spouses,parch,fare,class,deck,embark_town,alone'
b'0,male,22.0,1,0,7.25,Third,unknown,Southampton,n'
b'1,female,38.0,1,0,71.2833,First,C,Cherbourg,n'
b'1,female,26.0,0,0,7.925,Third,unknown,Southampton,y'
b'1,female,35.0,1,0,53.1,First,C,Southampton,n'
b'0,male,28.0,0,0,8.4583,Third,unknown,Queenstown,y'
b'0,male,2.0,3,1,21.075,Third,unknown,Southampton,n'
b'1,female,27.0,0,2,11.1333,Third,unknown,Southampton,n'
b'1,female,14.0,1,0,30.0708,Second,unknown,Cherbourg,n'
b'1,female,4.0,1,1,16.7,Third,G,Southampton,n'
def survived(line):
  return tf.not_equal(tf.strings.substr(line, 0, 1), "0")

survivors = titanic_lines.skip(1).filter(survived)
for line in survivors.take(10):
  print(line.numpy())
b'1,female,38.0,1,0,71.2833,First,C,Cherbourg,n'
b'1,female,26.0,0,0,7.925,Third,unknown,Southampton,y'
b'1,female,35.0,1,0,53.1,First,C,Southampton,n'
b'1,female,27.0,0,2,11.1333,Third,unknown,Southampton,n'
b'1,female,14.0,1,0,30.0708,Second,unknown,Cherbourg,n'
b'1,female,4.0,1,1,16.7,Third,G,Southampton,n'
b'1,male,28.0,0,0,13.0,Second,unknown,Southampton,y'
b'1,female,28.0,0,0,7.225,Third,unknown,Cherbourg,y'
b'1,male,28.0,0,0,35.5,First,A,Southampton,y'
b'1,female,38.0,1,5,31.3875,Third,unknown,Southampton,n'

CSV ডেটা ব্যবহার করা হচ্ছে

দেখুন CSV ফাইল লোড করা হচ্ছে , এবং লোড হচ্ছে পান্ডাস DataFrames আরো উদাহরণ জন্য।

CSV ফাইল ফরম্যাট প্লেইন টেক্সটে ট্যাবুলার ডেটা সংরক্ষণের জন্য একটি জনপ্রিয় ফর্ম্যাট।

উদাহরণ স্বরূপ:

titanic_file = tf.keras.utils.get_file("train.csv", "https://storage.googleapis.com/tf-datasets/titanic/train.csv")
df = pd.read_csv(titanic_file)
df.head()

তাহলে স্মৃতিতে আপনার ডেটা তড়কা একই Dataset.from_tensor_slices অভিধান উপর পদ্ধতি কাজ, এই তথ্য যার ফলে সহজে আমদানি করা হবে:

titanic_slices = tf.data.Dataset.from_tensor_slices(dict(df))

for feature_batch in titanic_slices.take(1):
  for key, value in feature_batch.items():
    print("  {!r:20s}: {}".format(key, value))
'survived'          : 0
  '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'

প্রয়োজনে ডিস্ক থেকে লোড করা আরও মাপযোগ্য পদ্ধতি।

tf.data মডিউল এক বা একাধিক CSV ফাইল থেকে নির্যাস রেকর্ড পদ্ধতি মেনে চলতে প্রদান করে বোঝায় যা RFC 4180

experimental.make_csv_dataset ফাংশন CSV ফাইল সেট পড়ার জন্য উচ্চ স্তরের ইন্টারফেসে হয়। এটি কলাম টাইপ ইনফারেন্স এবং অন্যান্য অনেক বৈশিষ্ট্যকে সমর্থন করে, যেমন ব্যাচিং এবং শাফলিং, ব্যবহারকে সহজ করতে।

titanic_batches = tf.data.experimental.make_csv_dataset(
    titanic_file, batch_size=4,
    label_name="survived")
for feature_batch, label_batch in titanic_batches.take(1):
  print("'survived': {}".format(label_batch))
  print("features:")
  for key, value in feature_batch.items():
    print("  {!r:20s}: {}".format(key, value))
'survived': [1 1 0 0]
features:
  'sex'               : [b'male' b'female' b'male' b'male']
  'age'               : [45.  2. 22. 37.]
  'n_siblings_spouses': [0 0 0 1]
  'parch'             : [0 1 0 0]
  'fare'              : [ 8.05   12.2875  7.7958 26.    ]
  'class'             : [b'Third' b'Third' b'Third' b'Second']
  'deck'              : [b'unknown' b'unknown' b'unknown' b'unknown']
  'embark_town'       : [b'Southampton' b'Southampton' b'Southampton' b'Southampton']
  'alone'             : [b'y' b'n' b'y' b'n']

আপনি ব্যবহার করতে পারেন select_columns যুক্তি আপনি শুধুমাত্র কলামের একটি উপসেট প্রয়োজন।

titanic_batches = tf.data.experimental.make_csv_dataset(
    titanic_file, batch_size=4,
    label_name="survived", select_columns=['class', 'fare', 'survived'])
for feature_batch, label_batch in titanic_batches.take(1):
  print("'survived': {}".format(label_batch))
  for key, value in feature_batch.items():
    print("  {!r:20s}: {}".format(key, value))
'survived': [1 0 0 0]
  'fare'              : [30.      7.0542  8.05   79.2   ]
  'class'             : [b'First' b'Third' b'Third' b'First']

এখানে একটা ছোট হাতের স্তর experimental.CsvDataset বর্গ যা তীক্ষ্ণ স্বরূপ খসখসে নিয়ন্ত্রণ প্রদান করে। এটি কলাম টাইপ অনুমান সমর্থন করে না। পরিবর্তে আপনাকে অবশ্যই প্রতিটি কলামের ধরন নির্দিষ্ট করতে হবে।

titanic_types  = [tf.int32, tf.string, tf.float32, tf.int32, tf.int32, tf.float32, tf.string, tf.string, tf.string, tf.string] 
dataset = tf.data.experimental.CsvDataset(titanic_file, titanic_types , header=True)

for line in dataset.take(10):
  print([item.numpy() for item in line])
[0, b'male', 22.0, 1, 0, 7.25, b'Third', b'unknown', b'Southampton', b'n']
[1, b'female', 38.0, 1, 0, 71.2833, b'First', b'C', b'Cherbourg', b'n']
[1, b'female', 26.0, 0, 0, 7.925, b'Third', b'unknown', b'Southampton', b'y']
[1, b'female', 35.0, 1, 0, 53.1, b'First', b'C', b'Southampton', b'n']
[0, b'male', 28.0, 0, 0, 8.4583, b'Third', b'unknown', b'Queenstown', b'y']
[0, b'male', 2.0, 3, 1, 21.075, b'Third', b'unknown', b'Southampton', b'n']
[1, b'female', 27.0, 0, 2, 11.1333, b'Third', b'unknown', b'Southampton', b'n']
[1, b'female', 14.0, 1, 0, 30.0708, b'Second', b'unknown', b'Cherbourg', b'n']
[1, b'female', 4.0, 1, 1, 16.7, b'Third', b'G', b'Southampton', b'n']
[0, b'male', 20.0, 0, 0, 8.05, b'Third', b'unknown', b'Southampton', b'y']

কিছু কলাম খালি থাকলে, এই নিম্ন-স্তরের ইন্টারফেস আপনাকে কলামের প্রকারের পরিবর্তে ডিফল্ট মান প্রদান করতে দেয়।

%%writefile missing.csv
1,2,3,4
,2,3,4
1,,3,4
1,2,,4
1,2,3,
,,,
Writing missing.csv
# Creates a dataset that reads all of the records from two CSV files, each with
# four float columns which may have missing values.

record_defaults = [999,999,999,999]
dataset = tf.data.experimental.CsvDataset("missing.csv", record_defaults)
dataset = dataset.map(lambda *items: tf.stack(items))
dataset
<MapDataset shapes: (4,), types: tf.int32>
for line in dataset:
  print(line.numpy())
[1 2 3 4]
[999   2   3   4]
[  1 999   3   4]
[  1   2 999   4]
[  1   2   3 999]
[999 999 999 999]

ডিফল্টরূপে, একটি CsvDataset ফাইল প্রতিটি লাইন, যা কাম্য নাও হতে পারে, উদাহরণস্বরূপ যদি ফাইল, একটি শিরোলেখ লাইন যে উপেক্ষা করা উচিত দিয়ে শুরু হয় অথবা কিছু কলাম ইনপুটে প্রয়োজন নেই যদি প্রতিটি কলামের উৎপাদ। এই লাইন এবং ক্ষেত্রের সাথে মুছে ফেলা হতে পারে header এবং select_cols যথাক্রমে আর্গুমেন্ট।

# Creates a dataset that reads all of the records from two CSV files with
# headers, extracting float data from columns 2 and 4.
record_defaults = [999, 999] # Only provide defaults for the selected columns
dataset = tf.data.experimental.CsvDataset("missing.csv", record_defaults, select_cols=[1, 3])
dataset = dataset.map(lambda *items: tf.stack(items))
dataset
<MapDataset shapes: (2,), types: tf.int32>
for line in dataset:
  print(line.numpy())
[2 4]
[2 4]
[999   4]
[2 4]
[  2 999]
[999 999]

ফাইলের সেট গ্রাস করছে

ফাইলগুলির একটি সেট হিসাবে বিতরণ করা অনেক ডেটাসেট রয়েছে, যেখানে প্রতিটি ফাইল একটি উদাহরণ।

flowers_root = tf.keras.utils.get_file(
    'flower_photos',
    'https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz',
    untar=True)
flowers_root = pathlib.Path(flowers_root)

রুট ডিরেক্টরিতে প্রতিটি শ্রেণীর জন্য একটি ডিরেক্টরি রয়েছে:

for item in flowers_root.glob("*"):
  print(item.name)
sunflowers
daisy
LICENSE.txt
roses
tulips
dandelion

প্রতিটি ক্লাস ডিরেক্টরির ফাইলগুলি উদাহরণ:

list_ds = tf.data.Dataset.list_files(str(flowers_root/'*/*'))

for f in list_ds.take(5):
  print(f.numpy())
b'/home/kbuilder/.keras/datasets/flower_photos/daisy/2045022175_ad087f5f60_n.jpg'
b'/home/kbuilder/.keras/datasets/flower_photos/tulips/19425920580_cdc8f49aed_n.jpg'
b'/home/kbuilder/.keras/datasets/flower_photos/dandelion/160456948_38c3817c6a_m.jpg'
b'/home/kbuilder/.keras/datasets/flower_photos/tulips/17012955700_7141d29eee.jpg'
b'/home/kbuilder/.keras/datasets/flower_photos/sunflowers/4933823300_39fd4420b6.jpg'

ব্যবহার করে তথ্য পড়ুন tf.io.read_file ফাংশন এবং পথ থেকে ট্যাগ নিষ্কর্ষ, ফিরে (image, label) জোড়া:

def process_path(file_path):
  label = tf.strings.split(file_path, os.sep)[-2]
  return tf.io.read_file(file_path), label

labeled_ds = list_ds.map(process_path)
for image_raw, label_text in labeled_ds.take(1):
  print(repr(image_raw.numpy()[:100]))
  print()
  print(label_text.numpy())
b'\xff\xd8\xff\xe0\x00\x10JFIF\x00\x01\x01\x00\x00\x01\x00\x01\x00\x00\xff\xe2\x0cXICC_PROFILE\x00\x01\x01\x00\x00\x0cHLino\x02\x10\x00\x00mntrRGB XYZ \x07\xce\x00\x02\x00\t\x00\x06\x001\x00\x00acspMSFT\x00\x00\x00\x00IEC sRGB\x00\x00\x00\x00\x00\x00'

b'dandelion'

ব্যাচিং ডেটাসেট উপাদান

সহজ ব্যাচিং

স্ট্যাকগুলি Batching সহজ ফর্ম n একটি একক উপাদান মধ্যে একটি ডেটাসেটের পরপর উপাদান। Dataset.batch() রূপান্তর ঠিক এই আছে, যেমন একই সীমাবদ্ধতার সঙ্গে tf.stack() অপারেটর, উপাদানের প্রতিটি উপাদানের প্রয়োগ: অর্থাত প্রতিটি উপাদানের কথা, সব উপাদান সঠিক একই আকৃতি একটি টেন্সর থাকতে হবে।

inc_dataset = tf.data.Dataset.range(100)
dec_dataset = tf.data.Dataset.range(0, -100, -1)
dataset = tf.data.Dataset.zip((inc_dataset, dec_dataset))
batched_dataset = dataset.batch(4)

for batch in batched_dataset.take(4):
  print([arr.numpy() for arr in batch])
[array([0, 1, 2, 3]), array([ 0, -1, -2, -3])]
[array([4, 5, 6, 7]), array([-4, -5, -6, -7])]
[array([ 8,  9, 10, 11]), array([ -8,  -9, -10, -11])]
[array([12, 13, 14, 15]), array([-12, -13, -14, -15])]

যদিও tf.data চেষ্টা আকৃতি তথ্য সঞ্চারিত, এর ডিফল্ট সেটিংস Dataset.batch একটি অজানা ব্যাচ আকার ফলাফলের কারণ গত ব্যাচ না ভরে যাবে। উল্লেখ্য None আকৃতির S:

batched_dataset
<BatchDataset shapes: ((None,), (None,)), types: (tf.int64, tf.int64)>

ব্যবহার করুন drop_remainder যে গত ব্যাচ উপেক্ষা এবং সম্পূর্ণ আকৃতি প্রসারণ পেতে যুক্তি:

batched_dataset = dataset.batch(7, drop_remainder=True)
batched_dataset
<BatchDataset shapes: ((7,), (7,)), types: (tf.int64, tf.int64)>

প্যাডিং সহ ব্যাচিং টেনসর

উপরের রেসিপিটি টেনসরগুলির জন্য কাজ করে যেগুলির সকলের একই আকার রয়েছে। যাইহোক, অনেক মডেল (যেমন সিকোয়েন্স মডেল) ইনপুট ডেটার সাথে কাজ করে যার বিভিন্ন আকার থাকতে পারে (যেমন বিভিন্ন দৈর্ঘ্যের সিকোয়েন্স)। এই ক্ষেত্রে হ্যান্ডেল করতে, Dataset.padded_batch রূপান্তর এক বা একাধিক মাত্রা যা তারা padded হতে পারে নির্দিষ্ট করে বিভিন্ন আকৃতি ব্যাচ tensors করতে সক্ষম করে।

dataset = tf.data.Dataset.range(100)
dataset = dataset.map(lambda x: tf.fill([tf.cast(x, tf.int32)], x))
dataset = dataset.padded_batch(4, padded_shapes=(None,))

for batch in dataset.take(2):
  print(batch.numpy())
  print()
[[0 0 0]
 [1 0 0]
 [2 2 0]
 [3 3 3]]

[[4 4 4 4 0 0 0]
 [5 5 5 5 5 0 0]
 [6 6 6 6 6 6 0]
 [7 7 7 7 7 7 7]]

Dataset.padded_batch রূপান্তর আপনি প্রতিটি উপাদানের প্রতিটি আয়তনের জন্য বিভিন্ন প্যাডিং সেট করতে পারবেন, এবং এটি পরিবর্তনশীল দৈর্ঘ্যের (দিয়ে বোঝানো হতে পারে None বা ধ্রুবক দৈর্ঘ্যের উপরোক্ত উদাহরণের)। প্যাডিং মানকে ওভাররাইড করাও সম্ভব, যা ডিফল্ট 0 তে।

প্রশিক্ষণ কর্মপ্রবাহ

একাধিক যুগ প্রক্রিয়াকরণ

tf.data দুই এপিআই অফার প্রধান উপায় একই তথ্য একাধিক সময়কাল প্রক্রিয়া।

একাধিক সময়কাল মধ্যে একটি ডেটাসেটের পুনরুক্তি সহজ উপায় ব্যবহার করা Dataset.repeat() রূপান্তর। প্রথমে, টাইটানিক ডেটার একটি ডেটাসেট তৈরি করুন:

titanic_file = tf.keras.utils.get_file("train.csv", "https://storage.googleapis.com/tf-datasets/titanic/train.csv")
titanic_lines = tf.data.TextLineDataset(titanic_file)
def plot_batch_sizes(ds):
  batch_sizes = [batch.shape[0] for batch in ds]
  plt.bar(range(len(batch_sizes)), batch_sizes)
  plt.xlabel('Batch number')
  plt.ylabel('Batch size')

প্রয়োগ করা হচ্ছে Dataset.repeat() কোন যুক্তি দিয়ে রূপান্তর ইনপুট অনির্দিষ্টকালের জন্য পুনরাবৃত্তি করবেন।

Dataset.repeat রূপান্তর এক যুগান্তকারী সমাপ্তি ও পরবর্তী যুগে সূচিত ছাড়া এর আর্গুমেন্টগুলি যোগসূত্র। এই কারণে একটি Dataset.batch পর প্রয়োগ Dataset.repeat ব্যাচ উত্পাদ করবে অতিক্রম করে যুগান্তকারী গণ্ডি:

titanic_batches = titanic_lines.repeat(3).batch(128)
plot_batch_sizes(titanic_batches)

png

আপনি স্পষ্ট যুগান্তকারী বিচ্ছেদ প্রয়োজন হয়, তাহলে করা Dataset.batch পুনরাবৃত্তি আগে:

titanic_batches = titanic_lines.batch(128).repeat(3)

plot_batch_sizes(titanic_batches)

png

আপনি যদি প্রতিটি যুগের শেষে একটি কাস্টম গণনা করতে চান (যেমন পরিসংখ্যান সংগ্রহ করতে) তাহলে প্রতিটি যুগে ডেটাসেট পুনরাবৃত্তি পুনরায় চালু করা সহজ:

epochs = 3
dataset = titanic_lines.batch(128)

for epoch in range(epochs):
  for batch in dataset:
    print(batch.shape)
  print("End of epoch: ", epoch)
(128,)
(128,)
(128,)
(128,)
(116,)
End of epoch:  0
(128,)
(128,)
(128,)
(128,)
(116,)
End of epoch:  1
(128,)
(128,)
(128,)
(128,)
(116,)
End of epoch:  2

এলোমেলোভাবে ইনপুট ডেটা শাফেলিং

Dataset.shuffle() রূপান্তর একটি নির্দিষ্ট আকার বাফার বজায় রাখে এবং যে বাফার থেকে এলোমেলোভাবে অবিশেষে পরবর্তী উপাদান পছন্দ করে।

ডেটাসেটে একটি সূচক যুক্ত করুন যাতে আপনি প্রভাব দেখতে পারেন:

lines = tf.data.TextLineDataset(titanic_file)
counter = tf.data.experimental.Counter()

dataset = tf.data.Dataset.zip((counter, lines))
dataset = dataset.shuffle(buffer_size=100)
dataset = dataset.batch(20)
dataset
<BatchDataset shapes: ((None,), (None,)), types: (tf.int64, tf.string)>

যেহেতু buffer_size 100, এবং ব্যাচ আকার 20, প্রথম ব্যাচের 120 ওভার একটি সূচক সঙ্গে কোন উপাদানগুলি রয়েছে।

n,line_batch = next(iter(dataset))
print(n.numpy())
[ 83  24   4  14   6  53  37   2  18  71  27  40  77  76 110  11  30  47
  46  28]

সঙ্গে Dataset.batch অর্ডার আপেক্ষিক Dataset.repeat বিষয়।

Dataset.shuffle যুগান্তকারী শেষ সংকেত না, যে পর্যন্ত এলোমেলো বাফার খালি। সুতরাং একটি পুনরাবৃত্তির আগে স্থাপন করা একটি শাফেল পরবর্তীতে যাওয়ার আগে একটি যুগের প্রতিটি উপাদান দেখাবে:

dataset = tf.data.Dataset.zip((counter, lines))
shuffled = dataset.shuffle(buffer_size=100).batch(10).repeat(2)

print("Here are the item ID's near the epoch boundary:\n")
for n, line_batch in shuffled.skip(60).take(5):
  print(n.numpy())
Here are the item ID's near the epoch boundary:

[612 458 485 439 305 506 624 570 625 523]
[529 544 597 620 610 615 592 487 566 454]
[611 572 585   0 520 601 398 594]
[ 65  22  75  78  73  55 105  86   8  94]
[ 14  52   4  36  85  66  69 100  38  33]
shuffle_repeat = [n.numpy().mean() for n, line_batch in shuffled]
plt.plot(shuffle_repeat, label="shuffle().repeat()")
plt.ylabel("Mean item ID")
plt.legend()
<matplotlib.legend.Legend at 0x7fcea41e1a50>

png

কিন্তু একটি এলোমেলো করার আগে একটি পুনরাবৃত্তি যুগের সীমানাকে একসাথে মিশ্রিত করে:

dataset = tf.data.Dataset.zip((counter, lines))
shuffled = dataset.repeat(2).shuffle(buffer_size=100).batch(10)

print("Here are the item ID's near the epoch boundary:\n")
for n, line_batch in shuffled.skip(55).take(15):
  print(n.numpy())
Here are the item ID's near the epoch boundary:

[593 580 524 619 506 555 617 526  24 520]
[586 445 356  26 600  20  16 528 504  39]
[583 594 576  37 560  13 626 314  41 501]
[571  46 574 542  32  52   4  10  40  35]
[590 541  34 625  56 609 529 446 618  50]
[ 64 611 582 538 443  72 604  23 613  79]
[ 36  14  17 557   2  59 622  25 395 565]
[400 483 588  89  51 599  67 591  12 458]
[ 69  33 373 101  29  98 102 468 104  94]
[548  21  68  30  61  49 581 513  44 360]
[ 75 121  97 603  58  62 577  15 452  80]
[426  48  65  90 105 616 124 100  66 134]
[ 99  74 620 136  82 587  88  96  31 127]
[138  87 151 131 143 471  86 140 146 117]
[  0 514 119 130  45   8   9 110 107  55]
repeat_shuffle = [n.numpy().mean() for n, line_batch in shuffled]

plt.plot(shuffle_repeat, label="shuffle().repeat()")
plt.plot(repeat_shuffle, label="repeat().shuffle()")
plt.ylabel("Mean item ID")
plt.legend()
<matplotlib.legend.Legend at 0x7fcdd84fd5d0>

png

ডেটা প্রিপ্রসেস করা হচ্ছে

Dataset.map(f) রূপান্তর একটি প্রদত্ত ফাংশন প্রয়োগের দ্বারা একটি নতুন ডেটা সেটটি উত্পাদন করে f ইনপুট ডেটা সেটটি প্রতিটি উপাদানে। এটা তোলে উপর ভিত্তি করে তৈরি map() ফাংশন যা সাধারণভাবে কার্যকরী প্রোগ্রামিং ভাষায় তালিকা (এবং অন্যান্য কাঠামো) প্রয়োগ করা হয়। ফাংশন f লাগে tf.Tensor বস্তু যে ইনপুট একটি একক উপাদান প্রতিনিধিত্ব, এবং ফেরৎ tf.Tensor যে বস্তু নতুন ডেটাসেটের মধ্যে একটি একক উপাদান প্রতিনিধিত্ব করবে। এটির বাস্তবায়ন একটি উপাদানকে অন্য উপাদানে রূপান্তর করতে মানক টেনসরফ্লো অপারেশন ব্যবহার করে।

এই বিভাগে কিভাবে ব্যবহার করতে সাধারণ উদাহরণ জুড়ে Dataset.map()

ইমেজ ডেটা ডিকোডিং এবং এটির আকার পরিবর্তন করা

রিয়েল-ওয়ার্ল্ড ইমেজ ডেটার উপর একটি নিউরাল নেটওয়ার্ককে প্রশিক্ষণ দেওয়ার সময়, বিভিন্ন আকারের ছবিগুলিকে একটি সাধারণ আকারে রূপান্তর করতে প্রায়ই প্রয়োজন হয়, যাতে সেগুলি একটি নির্দিষ্ট আকারে ব্যাচ করা যায়।

ফুলের ফাইলের নাম ডেটাসেট পুনর্নির্মাণ করুন:

list_ds = tf.data.Dataset.list_files(str(flowers_root/'*/*'))

একটি ফাংশন লিখুন যা ডেটাসেট উপাদানগুলিকে ম্যানিপুলেট করে।

# Reads an image from a file, decodes it into a dense tensor, and resizes it
# to a fixed shape.
def parse_image(filename):
  parts = tf.strings.split(filename, os.sep)
  label = parts[-2]

  image = tf.io.read_file(filename)
  image = tf.io.decode_jpeg(image)
  image = tf.image.convert_image_dtype(image, tf.float32)
  image = tf.image.resize(image, [128, 128])
  return image, label

এটি কাজ করে তা পরীক্ষা করুন।

file_path = next(iter(list_ds))
image, label = parse_image(file_path)

def show(image, label):
  plt.figure()
  plt.imshow(image)
  plt.title(label.numpy().decode('utf-8'))
  plt.axis('off')

show(image, label)

png

ডেটাসেটের উপর এটি ম্যাপ করুন।

images_ds = list_ds.map(parse_image)

for image, label in images_ds.take(2):
  show(image, label)

png

png

নির্বিচারে পাইথন যুক্তি প্রয়োগ করা হচ্ছে

পারফরম্যান্সের কারণে, যখনই সম্ভব আপনার ডেটা প্রিপ্রসেস করার জন্য TensorFlow অপারেশনগুলি ব্যবহার করুন। যাইহোক, কখনও কখনও আপনার ইনপুট ডেটা পার্স করার সময় বহিরাগত পাইথন লাইব্রেরি কল করা দরকারী। আপনি ব্যবহার করতে পারেন tf.py_function() একটি অপারেশন Dataset.map() রূপান্তর।

উদাহরণস্বরূপ, যদি আপনি একটি র্যান্ডম ঘূর্ণন প্রয়োগ করতে চান, tf.image মডিউল শুধুমাত্র হয়েছে tf.image.rot90 যা ইমেজ বৃদ্ধি জন্য খুবই উপযোগী নয়।

প্রকট tf.py_function , ব্যবহার করার চেষ্টা করুন scipy.ndimage.rotate পরিবর্তে ফাংশন:

import scipy.ndimage as ndimage

def random_rotate_image(image):
  image = ndimage.rotate(image, np.random.uniform(-30, 30), reshape=False)
  return image
image, label = next(iter(images_ds))
image = random_rotate_image(image)
show(image, label)
Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).

png

সঙ্গে এই ফাংশন ব্যবহার করার জন্য Dataset.map একই আদেশ সহকারে সঙ্গে প্রয়োগ Dataset.from_generator , আপনি যখন আপনি ফাংশন প্রয়োগ আগমন আকার এবং ধরনের বর্ণনা করা প্রয়োজন:

def tf_random_rotate_image(image, label):
  im_shape = image.shape
  [image,] = tf.py_function(random_rotate_image, [image], [tf.float32])
  image.set_shape(im_shape)
  return image, label
rot_ds = images_ds.map(tf_random_rotate_image)

for image, label in rot_ds.take(2):
  show(image, label)
Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).
Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).

png

png

পার্সিং tf.Example প্রোটোকল বাফার বার্তা

অনেক ইনপুট পাইপলাইনগুলি নিষ্কর্ষ tf.train.Example একটি TFRecord ফরম্যাট থেকে প্রোটোকল বাফার বার্তা। প্রতিটি tf.train.Example রেকর্ড এক বা একাধিক "বৈশিষ্ট্য" রয়েছে, এবং ইনপুট পাইপলাইন সাধারণত tensors মধ্যে এই বৈশিষ্ট্যগুলি পরিবর্তন করে।

fsns_test_file = tf.keras.utils.get_file("fsns.tfrec", "https://storage.googleapis.com/download.tensorflow.org/data/fsns-20160927/testdata/fsns-00000-of-00001")
dataset = tf.data.TFRecordDataset(filenames = [fsns_test_file])
dataset
<TFRecordDatasetV2 shapes: (), types: tf.string>

আপনার সাথে কাজ করতে tf.train.Example একটি এর protos বাহিরে tf.data.Dataset ডেটা বুঝতে:

raw_example = next(iter(dataset))
parsed = tf.train.Example.FromString(raw_example.numpy())

feature = parsed.features.feature
raw_img = feature['image/encoded'].bytes_list.value[0]
img = tf.image.decode_png(raw_img)
plt.imshow(img)
plt.axis('off')
_ = plt.title(feature["image/text"].bytes_list.value[0])

png

raw_example = next(iter(dataset))
def tf_parse(eg):
  example = tf.io.parse_example(
      eg[tf.newaxis], {
          'image/encoded': tf.io.FixedLenFeature(shape=(), dtype=tf.string),
          'image/text': tf.io.FixedLenFeature(shape=(), dtype=tf.string)
      })
  return example['image/encoded'][0], example['image/text'][0]
img, txt = tf_parse(raw_example)
print(txt.numpy())
print(repr(img.numpy()[:20]), "...")
b'Rue Perreyon'
b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x02X' ...
decoded = dataset.map(tf_parse)
decoded
<MapDataset shapes: ((), ()), types: (tf.string, tf.string)>
image_batch, text_batch = next(iter(decoded.batch(10)))
image_batch.shape
TensorShape([10])

সময় সিরিজ জানালা

শেষ সময় সিরিজ উদাহরণে শেষ জন্য, দেখুন: সময় সিরিজ পূর্বাভাস

টাইম সিরিজ ডেটা প্রায়ই সময় অক্ষ অক্ষত সঙ্গে সংগঠিত হয়.

একটি সহজ ব্যবহার করুন Dataset.range প্রকট:

range_ds = tf.data.Dataset.range(100000)

সাধারণত, এই ধরণের ডেটার উপর ভিত্তি করে মডেলগুলি একটি সংলগ্ন সময়ের স্লাইস চাইবে।

সবচেয়ে সহজ পদ্ধতি হবে ডেটা ব্যাচ করা:

ব্যবহার batch

batches = range_ds.batch(10, drop_remainder=True)

for batch in batches.take(5):
  print(batch.numpy())
[0 1 2 3 4 5 6 7 8 9]
[10 11 12 13 14 15 16 17 18 19]
[20 21 22 23 24 25 26 27 28 29]
[30 31 32 33 34 35 36 37 38 39]
[40 41 42 43 44 45 46 47 48 49]

অথবা ভবিষ্যতের এক ধাপ ঘন ভবিষ্যদ্বাণী করতে, আপনি একে অপরের সাপেক্ষে বৈশিষ্ট্য এবং লেবেলগুলিকে এক ধাপে স্থানান্তর করতে পারেন:

def dense_1_step(batch):
  # Shift features and labels one step relative to each other.
  return batch[:-1], batch[1:]

predict_dense_1_step = batches.map(dense_1_step)

for features, label in predict_dense_1_step.take(3):
  print(features.numpy(), " => ", label.numpy())
[0 1 2 3 4 5 6 7 8]  =>  [1 2 3 4 5 6 7 8 9]
[10 11 12 13 14 15 16 17 18]  =>  [11 12 13 14 15 16 17 18 19]
[20 21 22 23 24 25 26 27 28]  =>  [21 22 23 24 25 26 27 28 29]

একটি নির্দিষ্ট অফসেটের পরিবর্তে একটি সম্পূর্ণ উইন্ডো ভবিষ্যদ্বাণী করতে আপনি ব্যাচ দুটি ভাগে বিভক্ত করতে পারেন:

batches = range_ds.batch(15, drop_remainder=True)

def label_next_5_steps(batch):
  return (batch[:-5],   # Inputs: All except the last 5 steps
          batch[-5:])   # Labels: The last 5 steps

predict_5_steps = batches.map(label_next_5_steps)

for features, label in predict_5_steps.take(3):
  print(features.numpy(), " => ", label.numpy())
[0 1 2 3 4 5 6 7 8 9]  =>  [10 11 12 13 14]
[15 16 17 18 19 20 21 22 23 24]  =>  [25 26 27 28 29]
[30 31 32 33 34 35 36 37 38 39]  =>  [40 41 42 43 44]

এক ব্যাচ বৈশিষ্ট্য এবং অন্য লেবেল মধ্যে কিছু ওভারল্যাপ অনুমতি দিতে, ব্যবহার Dataset.zip :

feature_length = 10
label_length = 3

features = range_ds.batch(feature_length, drop_remainder=True)
labels = range_ds.batch(feature_length).skip(1).map(lambda labels: labels[:label_length])

predicted_steps = tf.data.Dataset.zip((features, labels))

for features, label in predicted_steps.take(5):
  print(features.numpy(), " => ", label.numpy())
[0 1 2 3 4 5 6 7 8 9]  =>  [10 11 12]
[10 11 12 13 14 15 16 17 18 19]  =>  [20 21 22]
[20 21 22 23 24 25 26 27 28 29]  =>  [30 31 32]
[30 31 32 33 34 35 36 37 38 39]  =>  [40 41 42]
[40 41 42 43 44 45 46 47 48 49]  =>  [50 51 52]

ব্যবহার window

ব্যবহার করার সময় Dataset.batch কাজ, সেখানে পরিস্থিতিতে যেখানে আপনি তীক্ষ্ণ স্বরূপ নিয়ন্ত্রণ প্রয়োজন হতে পারে। Dataset.window পদ্ধতি সম্পূর্ণ নিয়ন্ত্রণ দেয়, কিন্তু কিছু যত্ন প্রয়োজন হয়: এটি একটি ফেরৎ Dataset এর Datasets । দেখুন ডেটা সেটটি গঠন বিস্তারিত জানার জন্য।

window_size = 5

windows = range_ds.window(window_size, shift=1)
for sub_ds in windows.take(5):
  print(sub_ds)
<_VariantDataset shapes: (), types: tf.int64>
<_VariantDataset shapes: (), types: tf.int64>
<_VariantDataset shapes: (), types: tf.int64>
<_VariantDataset shapes: (), types: tf.int64>
<_VariantDataset shapes: (), types: tf.int64>

Dataset.flat_map পদ্ধতি ডেটাসেট একটি ডেটা সেটটি গ্রহণ করা এবং একটি একক ডেটা সেটটি সেটিকে চেপ্টা পারেন:

for x in windows.flat_map(lambda x: x).take(30):
   print(x.numpy(), end=' ')
0 1 2 3 4 1 2 3 4 5 2 3 4 5 6 3 4 5 6 7 4 5 6 7 8 5 6 7 8 9

প্রায় সব ক্ষেত্রে, আপনি করতে চাইবেন .batch প্রথম ডেটা সেটটি:

def sub_to_batch(sub):
  return sub.batch(window_size, drop_remainder=True)

for example in windows.flat_map(sub_to_batch).take(5):
  print(example.numpy())
[0 1 2 3 4]
[1 2 3 4 5]
[2 3 4 5 6]
[3 4 5 6 7]
[4 5 6 7 8]

এখন, আপনি দেখতে পারেন shift যুক্তি নিয়ন্ত্রণগুলি কত প্রতিটি জানালা প্যাচসমূহ উপর।

এটি একসাথে রেখে আপনি এই ফাংশনটি লিখতে পারেন:

def make_window_dataset(ds, window_size=5, shift=1, stride=1):
  windows = ds.window(window_size, shift=shift, stride=stride)

  def sub_to_batch(sub):
    return sub.batch(window_size, drop_remainder=True)

  windows = windows.flat_map(sub_to_batch)
  return windows
ds = make_window_dataset(range_ds, window_size=10, shift = 5, stride=3)

for example in ds.take(10):
  print(example.numpy())
[ 0  3  6  9 12 15 18 21 24 27]
[ 5  8 11 14 17 20 23 26 29 32]
[10 13 16 19 22 25 28 31 34 37]
[15 18 21 24 27 30 33 36 39 42]
[20 23 26 29 32 35 38 41 44 47]
[25 28 31 34 37 40 43 46 49 52]
[30 33 36 39 42 45 48 51 54 57]
[35 38 41 44 47 50 53 56 59 62]
[40 43 46 49 52 55 58 61 64 67]
[45 48 51 54 57 60 63 66 69 72]

তারপর লেবেলগুলি বের করা সহজ, আগের মতো:

dense_labels_ds = ds.map(dense_1_step)

for inputs,labels in dense_labels_ds.take(3):
  print(inputs.numpy(), "=>", labels.numpy())
[ 0  3  6  9 12 15 18 21 24] => [ 3  6  9 12 15 18 21 24 27]
[ 5  8 11 14 17 20 23 26 29] => [ 8 11 14 17 20 23 26 29 32]
[10 13 16 19 22 25 28 31 34] => [13 16 19 22 25 28 31 34 37]

রিস্যাম্পলিং

খুব শ্রেণী-ভারসাম্যহীন একটি ডেটাসেটের সাথে কাজ করার সময়, আপনি ডেটাসেটটি পুনরায় নমুনা করতে চাইতে পারেন। tf.data দুটি পদ্ধতি এই কাজ করতে প্রদান করে। ক্রেডিট কার্ড জালিয়াতি ডেটাসেট এই ধরণের সমস্যার একটি ভাল উদাহরণ।

zip_path = tf.keras.utils.get_file(
    origin='https://storage.googleapis.com/download.tensorflow.org/data/creditcard.zip',
    fname='creditcard.zip',
    extract=True)

csv_path = zip_path.replace('.zip', '.csv')
Downloading data from https://storage.googleapis.com/download.tensorflow.org/data/creditcard.zip
69156864/69155632 [==============================] - 1s 0us/step
69165056/69155632 [==============================] - 1s 0us/step
creditcard_ds = tf.data.experimental.make_csv_dataset(
    csv_path, batch_size=1024, label_name="Class",
    # Set the column types: 30 floats and an int.
    column_defaults=[float()]*30+[int()])

এখন, ক্লাসের বিতরণ পরীক্ষা করুন, এটি অত্যন্ত তির্যক:

def count(counts, batch):
  features, labels = batch
  class_1 = labels == 1
  class_1 = tf.cast(class_1, tf.int32)

  class_0 = labels == 0
  class_0 = tf.cast(class_0, tf.int32)

  counts['class_0'] += tf.reduce_sum(class_0)
  counts['class_1'] += tf.reduce_sum(class_1)

  return counts
counts = creditcard_ds.take(10).reduce(
    initial_state={'class_0': 0, 'class_1': 0},
    reduce_func = count)

counts = np.array([counts['class_0'].numpy(),
                   counts['class_1'].numpy()]).astype(np.float32)

fractions = counts/counts.sum()
print(fractions)
[0.9973 0.0027]

ভারসাম্যহীন ডেটাসেটের সাথে প্রশিক্ষণের একটি সাধারণ পদ্ধতি হল এটির ভারসাম্য বজায় রাখা। tf.data কয়েক পদ্ধতি যা এই কর্মপ্রবাহ সক্ষম রয়েছে:

ডেটাসেট স্যাম্পলিং

একটি ডেটাসেটের রীস্যাম্পেলিং বোঝার দিকে একটা পদক্ষেপ ব্যবহার করা sample_from_datasets । আপনি যদি কোনো আলাদা থাকে তখন এই আরো প্রযোজ্য data.Dataset প্রতিটি বর্গ জন্য।

এখানে, ক্রেডিট কার্ড জালিয়াতি ডেটা থেকে সেগুলি তৈরি করতে ফিল্টার ব্যবহার করুন:

negative_ds = (
  creditcard_ds
    .unbatch()
    .filter(lambda features, label: label==0)
    .repeat())
positive_ds = (
  creditcard_ds
    .unbatch()
    .filter(lambda features, label: label==1)
    .repeat())
for features, label in positive_ds.batch(10).take(1):
  print(label.numpy())
[1 1 1 1 1 1 1 1 1 1]

ব্যবহার করতে tf.data.experimental.sample_from_datasets ডেটাসেট, এবং প্রতিটি জন্য ওজন পাস:

balanced_ds = tf.data.experimental.sample_from_datasets(
    [negative_ds, positive_ds], [0.5, 0.5]).batch(10)
WARNING:tensorflow:From /tmp/ipykernel_11206/929671245.py:2: sample_from_datasets_v2 (from tensorflow.python.data.experimental.ops.interleave_ops) is deprecated and will be removed in a future version.
Instructions for updating:
Use `tf.data.Dataset.sample_from_datasets(...)`.

এখন ডেটাসেট 50/50 সম্ভাব্যতার সাথে প্রতিটি শ্রেণীর উদাহরণ তৈরি করে:

for features, labels in balanced_ds.take(10):
  print(labels.numpy())
[1 1 0 1 0 1 0 0 1 1]
[0 0 0 0 0 0 1 1 1 0]
[0 1 1 0 1 0 0 0 0 1]
[1 1 1 0 0 0 0 0 0 1]
[0 1 1 1 1 1 1 1 1 0]
[0 0 1 0 0 1 1 1 1 1]
[1 1 1 1 1 0 1 1 1 0]
[0 0 0 0 0 0 0 1 1 0]
[0 1 1 1 0 1 1 1 1 0]
[0 1 0 1 0 1 0 1 0 1]

প্রত্যাখ্যান পুনরায় নমুনা

উপরোক্ত সঙ্গে একটা সমস্যা experimental.sample_from_datasets পদ্ধতির যে এটি একটি পৃথক প্রয়োজন tf.data.Dataset প্রতি ক্লাসে। ব্যবহার Dataset.filter কাজ করে, কিন্তু সব ডেটা ফলাফল দুইবার লোড করা হচ্ছে।

data.experimental.rejection_resample ফাংশন এটা rebalance করার, যখন শুধুমাত্র এটি একবার লোড একটি ডেটাসেটের প্রয়োগ করা যেতে পারে। ভারসাম্য অর্জন করতে ডেটাসেট থেকে উপাদানগুলি বাদ দেওয়া হবে।

data.experimental.rejection_resample একটি লাগে class_func যুক্তি। এই class_func প্রতিটি ডেটা সেটটি উপাদান প্রয়োগ করা হয়, এবং তা নির্ধারণ করতে যা বর্গ একটি উদাহরণ মিট উদ্দেশ্যে জন্যে ব্যবহার করা হয়।

উপাদান creditcard_ds ইতিমধ্যেই আছে (features, label) জোড়া। সুতরাং class_func কেবলমাত্র সেই লেবেল ফিরে যাওয়ার দরকার:

def class_func(features, label):
  return label

resampler এছাড়াও একটি লক্ষ্য বন্টন প্রয়োজন, এবং ঐচ্ছিকভাবে একটি প্রাথমিক বিতরণ অনুমান:

resampler = tf.data.experimental.rejection_resample(
    class_func, target_dist=[0.5, 0.5], initial_dist=fractions)
WARNING:tensorflow:From /tmp/ipykernel_11206/2462412449.py:2: rejection_resample (from tensorflow.python.data.experimental.ops.resampling) is deprecated and will be removed in a future version.
Instructions for updating:
Use `tf.data.Dataset.rejection_resample(...)`.

পৃথক উদাহরণ resampler পুলিশ যাতে আপনি আবশ্যক unbatch resampler প্রয়োগ করার আগে ডেটা সেটটি:

resample_ds = creditcard_ds.unbatch().apply(resampler).batch(10)
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/data/ops/dataset_ops.py:6097: Print (from tensorflow.python.ops.logging_ops) is deprecated and will be removed after 2018-08-20.
Instructions for updating:
Use tf.print instead of tf.Print. Note that tf.print returns a no-output operator that directly prints the output. Outside of defuns or eager mode, this operator will not be executed unless it is directly specified in session.run or used as a control dependency for other operators. This is only a concern in graph mode. Below is an example of how to ensure tf.print executes in graph mode:

Resampler আয় সৃষ্টি (class, example) আউটপুট থেকে জোড়া class_func । এই ক্ষেত্রে, example ইতিমধ্যে একটি ছিল (feature, label) যুগল, তাই ব্যবহার map লেবেলের অতিরিক্ত কপি ড্রপ:

balanced_ds = resample_ds.map(lambda extra_label, features_and_label: features_and_label)

এখন ডেটাসেট 50/50 সম্ভাব্যতার সাথে প্রতিটি শ্রেণীর উদাহরণ তৈরি করে:

for features, labels in balanced_ds.take(10):
  print(labels.numpy())
Proportion of examples rejected by sampler is high: [0.997265637][0.997265637 0.00273437495][0 1]
Proportion of examples rejected by sampler is high: [0.997265637][0.997265637 0.00273437495][0 1]
Proportion of examples rejected by sampler is high: [0.997265637][0.997265637 0.00273437495][0 1]
Proportion of examples rejected by sampler is high: [0.997265637][0.997265637 0.00273437495][0 1]
Proportion of examples rejected by sampler is high: [0.997265637][0.997265637 0.00273437495][0 1]
Proportion of examples rejected by sampler is high: [0.997265637][0.997265637 0.00273437495][0 1]
Proportion of examples rejected by sampler is high: [0.997265637][0.997265637 0.00273437495][0 1]
Proportion of examples rejected by sampler is high: [0.997265637][0.997265637 0.00273437495][0 1]
Proportion of examples rejected by sampler is high: [0.997265637][0.997265637 0.00273437495][0 1]
Proportion of examples rejected by sampler is high: [0.997265637][0.997265637 0.00273437495][0 1]
[1 1 1 0 1 1 1 0 1 1]
[0 1 1 0 1 1 0 0 1 0]
[1 0 1 1 0 1 0 0 0 1]
[0 1 0 1 0 1 1 0 0 0]
[0 0 0 1 0 1 1 0 0 0]
[1 0 1 0 0 1 1 1 1 0]
[0 1 1 1 1 1 0 1 0 0]
[1 1 1 0 0 1 1 1 0 0]
[0 1 1 0 1 0 1 0 0 0]
[0 0 1 0 1 1 1 1 0 1]

ইটারেটার চেকপয়েন্টিং

Tensorflow সমর্থন চেকপয়েন্ট গ্রহণ তাই যখন আপনার ট্রেনিং প্রক্রিয়াটির পুনরায় আরম্ভ এটা তার উন্নতি অধিকাংশ পুনরুদ্ধার করতে সর্বশেষ চেকপয়েন্ট পুনরুদ্ধার করতে পারেন যে। মডেল ভেরিয়েবল চেকপয়েন্ট করার পাশাপাশি, আপনি ডেটাসেট ইটারেটরের অগ্রগতিও চেকপয়েন্ট করতে পারেন। আপনার যদি একটি বড় ডেটাসেট থাকে এবং প্রতিটি রিস্টার্টের শুরু থেকে ডেটাসেট শুরু করতে না চান তাহলে এটি কার্যকর হতে পারে। উল্লেখ্য তবে পুনরুক্তিকারীর চেকপয়েন্ট বড় হতে পারে যে, যেমন রূপান্তরের যেহেতু shuffle এবং prefetch পুনরুক্তিকারীর মধ্যে বাফার উপলব্ধ উপাদানের প্রয়োজন।

একটি চেকপয়েন্ট আপনার পুনরুক্তিকারীর অন্তর্ভুক্ত করার জন্য, এর পুনরুক্তিকারীর পাস tf.train.Checkpoint কন্সট্রাকটর।

range_ds = tf.data.Dataset.range(20)

iterator = iter(range_ds)
ckpt = tf.train.Checkpoint(step=tf.Variable(0), iterator=iterator)
manager = tf.train.CheckpointManager(ckpt, '/tmp/my_ckpt', max_to_keep=3)

print([next(iterator).numpy() for _ in range(5)])

save_path = manager.save()

print([next(iterator).numpy() for _ in range(5)])

ckpt.restore(manager.latest_checkpoint)

print([next(iterator).numpy() for _ in range(5)])
[0, 1, 2, 3, 4]
[5, 6, 7, 8, 9]
[5, 6, 7, 8, 9]

tf.keras সহ tf.data ব্যবহার করা

tf.keras এপিআই সরলীকৃত তৈরি এবং মেশিন লার্নিং মডেলগুলির নির্বাহ অনেক দিক। তার .fit() এবং .evaluate() এবং .predict() API গুলি ইনপুট হিসাবে ডেটাসেট সমর্থন করি। এখানে একটি দ্রুত ডেটাসেট এবং মডেল সেটআপ রয়েছে:

train, test = tf.keras.datasets.fashion_mnist.load_data()

images, labels = train
images = images/255.0
labels = labels.astype(np.int32)
fmnist_train_ds = tf.data.Dataset.from_tensor_slices((images, labels))
fmnist_train_ds = fmnist_train_ds.shuffle(5000).batch(32)

model = tf.keras.Sequential([
  tf.keras.layers.Flatten(),
  tf.keras.layers.Dense(10)
])

model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), 
              metrics=['accuracy'])

একটি ডেটাসেটের পাসিং (feature, label) জোড়া সব যে জন্য প্রয়োজন হয় Model.fit এবং Model.evaluate :

model.fit(fmnist_train_ds, epochs=2)
Epoch 1/2
1875/1875 [==============================] - 4s 2ms/step - loss: 0.5979 - accuracy: 0.7986
Epoch 2/2
1875/1875 [==============================] - 4s 2ms/step - loss: 0.4610 - accuracy: 0.8429
<keras.callbacks.History at 0x7fce40120590>

আপনি কল করে অসীম ডেটা সেটটি, উদাহরণস্বরূপ পাস যদি Dataset.repeat() , আপনি শুধু প্রয়োজন এছাড়াও পাস steps_per_epoch যুক্তি:

model.fit(fmnist_train_ds.repeat(), epochs=2, steps_per_epoch=20)
Epoch 1/2
20/20 [==============================] - 0s 2ms/step - loss: 0.4489 - accuracy: 0.8484
Epoch 2/2
20/20 [==============================] - 0s 2ms/step - loss: 0.4426 - accuracy: 0.8625
<keras.callbacks.History at 0x7fce4029cfd0>

মূল্যায়নের জন্য আপনি মূল্যায়ন ধাপের সংখ্যা পাস করতে পারেন:

loss, accuracy = model.evaluate(fmnist_train_ds)
print("Loss :", loss)
print("Accuracy :", accuracy)
1875/1875 [==============================] - 4s 2ms/step - loss: 0.4352 - accuracy: 0.8513
Loss : 0.4351990818977356
Accuracy : 0.8513000011444092

দীর্ঘ ডেটাসেটের জন্য, মূল্যায়নের জন্য ধাপের সংখ্যা সেট করুন:

loss, accuracy = model.evaluate(fmnist_train_ds.repeat(), steps=10)
print("Loss :", loss)
print("Accuracy :", accuracy)
10/10 [==============================] - 0s 2ms/step - loss: 0.4348 - accuracy: 0.8750
Loss : 0.43478837609291077
Accuracy : 0.875

লেবেল যখন ডেকে প্রয়োজন নেই Model.predict

predict_ds = tf.data.Dataset.from_tensor_slices(images).batch(32)
result = model.predict(predict_ds, steps = 10)
print(result.shape)
(320, 10)

কিন্তু লেবেলগুলি উপেক্ষা করা হয় যদি আপনি সেগুলি ধারণকারী একটি ডেটাসেট পাস করেন:

result = model.predict(fmnist_train_ds, steps = 10)
print(result.shape)
(320, 10)