This page was translated by the Cloud Translation API.
Switch to English

tf.data: টেনসরফ্লো ইনপুট পাইপলাইনগুলি তৈরি করুন

টেনসরফ্লো.আর.জে দেখুন গুগল কোলাবে চালান গিটহাবের উত্স দেখুন নোটবুক ডাউনলোড করুন

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

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

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

  • একটি ডেটা সোর্স মেমরিতে বা এক বা একাধিক ফাইলে সঞ্চিত ডেটা থেকে একটি Dataset করে।

  • একটি ডেটা ট্রান্সফর্মেশন এক বা একাধিক tf.data.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 অবজেক্টটি পাইথন পুনরুক্তযোগ্য। এটি লুপের জন্য এটি ব্যবহার করে এর উপাদানগুলি গ্রাস করা সম্ভব করে:

 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

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

 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 সমর্থন করে। 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())
 
[8 1 2 6 1 7 2 6 1 3]
[6 5 6 5 3 5 2 5 3 6]
[5 8 4 8 3 1 4 6 4 8]
[2 4 5 8 3 5 7 9 4 2]

 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
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-images-idx3-ubyte.gz
26427392/26421880 [==============================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-labels-idx1-ubyte.gz
8192/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

 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 হিসাবে 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 রূপান্তর করে।

কনস্ট্রাক্টর ইনপুট হিসাবে কলযোগ্য গ্রহণ করে, পুনরুক্তিকারী নয়। এটি জেনারেটরটি যখন শেষের দিকে পৌঁছে তখন এটি পুনরায় চালু করতে দেয়। এটি একটি alচ্ছিক args যুক্তি নেয়, যা কলযোগ্য আর্গুমেন্ট হিসাবে পাস করা হয়।

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 আর্গুমেন্টের প্রয়োজন হয় না তবে এটি বেশিরভাগ ক্ষেত্রেই পুনরায় সংযুক্ত করা হয় কারণ অনেকগুলি টেনসরফ্লো অপারেশন অজানা র‌্যাঙ্কযুক্ত টেনারগুলিকে সমর্থন করে না। যদি কোনও নির্দিষ্ট অক্ষের দৈর্ঘ্য অজানা বা পরিবর্তনশীল হয় তবে output_shapes এটি None হিসাবে সেট করুন না।

এটাও লক্ষ করা গুরুত্বপূর্ণ যে 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.978  -1.0531  0.1959 -2.1618]
1 : [ 1.9185 -0.1874  0.5084]
2 : [0.1441 0.3987 0.7737 0.9266 1.5057 0.9151]
3 : [ 0.681  -0.6155 -0.1231 -0.2429  0.6892  1.2571 -1.7588 -1.6575 -0.5375]
4 : [-0.5567  1.5298  0.7242  0.2213]
5 : [ 1.5572 -0.6856]
6 : [-1.0965 -0.336   1.2405  0.6006]

প্রথম আউটপুটটি একটি 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 মতো ব্যবহার করা যেতে পারে। নোট করুন যে কোনও ভেরিয়েবল আকৃতির সাথে ডেটাসেটের ব্যাচিংয়ের সময় আপনার Dataset.padded_batch ব্যবহার করা 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())
 
[ 2 10 18  3  6 15 25 23  0  4]

[[ 1.2665 -0.6274  0.4076  1.0146  0.      0.      0.      0.    ]
 [ 0.8091 -0.0683 -0.1464  0.2734  0.7461 -0.1009  0.      0.    ]
 [-0.9381  1.5075  0.      0.      0.      0.      0.      0.    ]
 [ 1.5705  0.4438  0.      0.      0.      0.      0.      0.    ]
 [-0.4692 -1.8328 -2.2838  0.7418  0.0172 -0.3547 -1.4502 -1.2786]
 [-1.574   0.      0.      0.      0.      0.      0.      0.    ]
 [-0.9274  1.4758  0.      0.      0.      0.      0.      0.    ]
 [-0.5043  0.7066  0.9599 -1.2986  0.      0.      0.      0.    ]
 [ 0.      0.      0.      0.      0.      0.      0.      0.    ]
 [-0.4893 -0.6937  0.      0.      0.      0.      0.      0.    ]]

একটি আরো বাস্তবসম্মত উদাহরণস্বরূপ, মোড়কে চেষ্টা 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 [==============================] - 2s 0us/step

image.ImageDataGenerator তৈরি করুন 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(
    img_gen.flow_from_directory, args=[flowers], 
    output_types=(tf.float32, tf.float32), 
    output_shapes=([32,256,256,3], [32,5])
)

ds
 
<FlatMapDataset shapes: ((32, 256, 256, 3), (32, 5)), types: (tf.float32, tf.float32)>

TFRecord ডেটা গ্রহণ করা

একটি শেষ-শেষের উদাহরণের জন্য টিএফআরকার্ডগুলি লোড করা দেখুন।

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

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

 # 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

TFRecordDataset প্রারম্ভকালীন filenames নামের আর্গুমেন্ট হয় স্ট্রিং, স্ট্রিংগুলির একটি তালিকা বা স্ট্রিংগুলির tf.Tensor হতে পারে। সুতরাং প্রশিক্ষণ এবং বৈধতার জন্য যদি আপনার কাছে দুটি সেট ফাইল থাকে তবে আপনি একটি কারখানা পদ্ধতি তৈরি করতে পারেন যা ডেটাसेट তৈরি করে, ইনপুট যুক্তি হিসাবে ফাইলের নাম গ্রহণ করে:

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

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

 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
Downloading data from https://storage.googleapis.com/download.tensorflow.org/data/illiad/derby.txt
811008/809730 [==============================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/download.tensorflow.org/data/illiad/butler.txt
811008/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 ব্যবহার 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

 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'

সিএসভি ডেটা গ্রহণ করা

আরও উদাহরণের জন্য সিএসভি ফাইল লোড করা এবং পান্ডাস ডেটা ফ্রেমগুলি লোড করা দেখুন।

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

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

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

যদি আপনার ডেটা একই Dataset.from_tensor_slices পদ্ধতিটি 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 মডিউলটি এক বা একাধিক সিএসভি ফাইল থেকে রেকর্ডগুলি বের করার জন্য পদ্ধতি সরবরাহ করে যা আরএফসি 4180 মেনে চলে।

experimental.make_csv_dataset ফাংশন হ'ল সিএসভি ফাইলের সেট পড়ার জন্য উচ্চ স্তরের ইন্টারফেস। এটি কলামের ধরণের অনুমিতি এবং ব্যাচিং এবং শাফলিংয়ের মতো আরও অনেকগুলি বৈশিষ্ট্য সমর্থন করে যাতে ব্যবহারকে সহজ করে তোলে।

 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': [0 1 0 0]
features:
  'sex'               : [b'male' b'female' b'male' b'male']
  'age'               : [28. 42. 43. 21.]
  'n_siblings_spouses': [0 0 0 0]
  'parch'             : [0 0 0 0]
  'fare'              : [47.1    13.      8.05    8.6625]
  'class'             : [b'First' b'Second' b'Third' b'Third']
  'deck'              : [b'unknown' b'unknown' b'unknown' b'unknown']
  'embark_town'       : [b'Southampton' b'Southampton' b'Southampton' b'Southampton']
  'alone'             : [b'y' b'y' b'y' b'y']

আপনার যদি কেবল কলামগুলির একটি উপসেট প্রয়োজন হয় তবে আপনি 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 1 1]
  'fare'              : [24.15    0.     13.8583 53.1   ]
  'class'             : [b'Third' b'Second' b'Second' b'First']

এছাড়াও একটি নিম্ন-স্তরের experimental.CsvDataset s সিএসভিড্যাটাসেট শ্রেণি রয়েছে যা সূক্ষ্ম দানাদার নিয়ন্ত্রণ সরবরাহ করে। এটি কলামের ধরণের অনুক্রম সমর্থন করে না। পরিবর্তে আপনাকে অবশ্যই প্রতিটি কলামের ধরণ উল্লেখ করতে হবে।

 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 ফাইলের প্রতিটি লাইনটির প্রতিটি কলাম দেয়, এটি পছন্দসই নয় example উদাহরণস্বরূপ, যদি ফাইলটি একটি শিরোলেখ দিয়ে শুরু করা হয় যা উপেক্ষা করা উচিত, অথবা যদি ইনপুটটিতে কিছু কলামের প্রয়োজন না হয়। এই লাইনগুলি এবং ক্ষেত্রগুলি যথাক্রমে 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/dandelion/7243478942_30bf542a2d_m.jpg'
b'/home/kbuilder/.keras/datasets/flower_photos/tulips/4525067924_177ea3bfb4.jpg'
b'/home/kbuilder/.keras/datasets/flower_photos/tulips/7002703410_3e97b29da5_n.jpg'
b'/home/kbuilder/.keras/datasets/flower_photos/daisy/6299910262_336309ffa5_n.jpg'
b'/home/kbuilder/.keras/datasets/flower_photos/sunflowers/6140661443_bb48344226.jpg'

tf.io.read_file ফাংশন ব্যবহার করে ডেটা পড়ুন এবং পথ (image, label) জোড়ায় ফিরে (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\x01\x00H\x00H\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'tulips'

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

সাধারণ ব্যাচিং

ব্যাচিংয়ের সহজতম রূপটি একটি একক উপাদানে একটি ডেটাসেটের টানা n উপাদানগুলি ac Dataset.batch() রূপান্তরটি ঠিক একই কাজ করে tf.stack() অপারেটরের মতো একই সীমাবদ্ধতার সাথে উপাদানগুলির প্রতিটি উপাদানকে প্রয়োগ করে: অর্থাত প্রতিটি উপাদান i এর জন্য সমস্ত উপাদানগুলির অবশ্যই একই আকারের একটি সেন্সর থাকতে হবে।

 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 নোট করুন:

 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 পরিচালনা করতে, Dataset.padded_batch ট্রান্সফর্মেশন আপনাকে এক বা একাধিক মাত্রা নির্দিষ্ট করে নির্দিষ্ট আকারে বিভিন্ন আকারের Dataset.padded_batch ব্যাচ করতে সক্ষম করে যাতে তারা প্যাডযুক্ত থাকতে পারে।

 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 দ্বারা Dataset.padded_batch ) বা ধ্রুবক দৈর্ঘ্য হতে পারে। প্যাডিং মানটি ওভাররাইড করাও সম্ভব, যা 0 এ ডিফল্ট হয়।

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

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

tf.data API একই ডেটার একাধিক পর্বগুলি প্রক্রিয়া করার জন্য দুটি প্রধান উপায় সরবরাহ করে।

একাধিক Dataset.repeat() ডেটাসেটের মাধ্যমে পুনরাবৃত্তি করার সহজ উপায় 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.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() রূপান্তরটি একটি নির্দিষ্ট-আকারের বাফারকে বজায় রাখে এবং পরবর্তী 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 এর বেশি buffer_size কোনও উপাদান থাকে না।

 n,line_batch = next(iter(dataset))
print(n.numpy())
 
[ 63  48 101  12 103  52   6  39   4   9  93  91   5  86  79  64  95  33
 102  50]

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

Dataset.shuffle কোনও যুগের শেষের সিগন্যাল দেয় না যতক্ষণ না 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:

[613 609 624 553 608 583 493 617 611 610]
[217 508 579 601 319 616 606 549 618 623]
[416 567 404 622 283 458 503 602]
[ 87  68  56  16   6  62   1  89  58 106]
[98 80 43 10 67 44 19 34 13 57]

 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 0x7fe0a00a1d68>

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:

[440  15   8 599 567  18 550   5  19  17]
[ 12 501 571 473 466  21 531 596 580 555]
[  3 573  38 563  25 416 595  29  46 602]
[485 566 561  16 331 615 386  28 609  41]
[611 622 575  10 589  61 598 527  52  35]
[ 55 597  42  23  13  47  11 505  68 582]
[612 613  75  43   7 392  74 452  82 509]
[  9  44  62 491  71 343  51 590  60  98]
[  6  95 619  86 625 537 617  85 465   0]
[ 88  27  92 101 109 111 104  24  36 113]
[103 118  79  53  70  40 121 100  65  33]
[562 588 124 125  64  84  83  67 610 130]
[  4 142 131  90 518 129 143 112   2 551]
[377  91 140  76  50  48 526 553 156 591]
[105 128  69 114  93 520 154  56 145 115]

 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 0x7fe0582fbb70>

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.image.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

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

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

উদাহরণস্বরূপ, আপনি যদি এলোমেলো রোটেশন প্রয়োগ করতে চান তবে tf.image মডিউলে কেবল tf.image.rot90 যা চিত্র বৃদ্ধির জন্য খুব কার্যকর নয় 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.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 এক্সট্রা প্রোটোকল বাফার বার্তা একটি টিএফআরকার্ড ফর্ম্যাট থেকে বের করে। প্রতিটি tf.train.Example রেকর্ডে এক বা একাধিক "বৈশিষ্ট্য" থাকে এবং ইনপুট পাইপলাইন সাধারণত এই বৈশিষ্ট্যগুলিকে tf.train.Example রূপান্তর করে।

 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 tf.data.Dataset একটি tf.data.Dataset বাইরে কাজ করতে পারেন। ডেটা বুঝতে 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],   # Take the first 5 steps
          batch[-5:])   # take the remainder

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 ব্যবহার Dataset.zip :

 feature_length = 10
label_length = 5

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

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

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]
[10 11 12 13 14 15 16 17 18 19]  =>  [20 21 22 23 24]
[20 21 22 23 24 25 26 27 28 29]  =>  [30 31 32 33 34]

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=' ')
 
WARNING:tensorflow:AutoGraph could not transform <function <lambda> at 0x7fe0582dbbf8> and will run it as-is.
Cause: could not parse the source code:

for x in windows.flat_map(lambda x: x).take(30):

This error may be avoided by creating the lambda in a standalone statement.

To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert
WARNING: AutoGraph could not transform <function <lambda> at 0x7fe0582dbbf8> and will run it as-is.
Cause: could not parse the source code:

for x in windows.flat_map(lambda x: x).take(30):

This error may be avoided by creating the lambda in a standalone statement.

To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert
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 আর্গুমেন্ট প্রতিটি উইন্ডোটির উপরে কতটা 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 [==============================] - 10s 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.996 0.004]

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

ডেটাসেটের নমুনা

একটি ডেটাসেট sample_from_datasets করার জন্য একটি পদ্ধতির sample_from_datasets ব্যবহার করা। আপনার আরও আলাদা data.Dataset এটি আরও প্রযোজ্য data.Dataset প্রতিটি শ্রেণীর জন্য 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())
 
WARNING:tensorflow:AutoGraph could not transform <function <lambda> at 0x7fe0a01fd1e0> and will run it as-is.
Cause: could not parse the source code:

    .filter(lambda features, label: label==0)

This error may be avoided by creating the lambda in a standalone statement.

To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert
WARNING: AutoGraph could not transform <function <lambda> at 0x7fe0a01fd1e0> and will run it as-is.
Cause: could not parse the source code:

    .filter(lambda features, label: label==0)

This error may be avoided by creating the lambda in a standalone statement.

To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert
WARNING:tensorflow:AutoGraph could not transform <function <lambda> at 0x7fe058159620> and will run it as-is.
Cause: could not parse the source code:

    .filter(lambda features, label: label==1)

This error may be avoided by creating the lambda in a standalone statement.

To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert
WARNING: AutoGraph could not transform <function <lambda> at 0x7fe058159620> and will run it as-is.
Cause: could not parse the source code:

    .filter(lambda features, label: label==1)

This error may be avoided by creating the lambda in a standalone statement.

To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert

 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)
 

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

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

প্রত্যাখ্যান পুনরায় মডেলিং

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

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

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

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

 def class_func(features, label):
  return label
 

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

 resampler = tf.data.experimental.rejection_resample(
    class_func, target_dist=[0.5, 0.5], initial_dist=fractions)
 

unbatch পৃথক উদাহরণগুলির সাথে কাজ করে, তাই আপনাকে unbatch প্রয়োগ করার আগে অবশ্যই unbatch করতে হবে:

 resample_ds = creditcard_ds.unbatch().apply(resampler).batch(10)
 
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/data/experimental/ops/resampling.py:156: 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:


রিস্যাম্পলার রিটার্ন class_func আউটপুট থেকে (class, example) জোড়া তৈরি করে। এই ক্ষেত্রে, 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())
 
[1 0 1 1 1 1 0 1 1 1]
[0 0 1 1 1 0 1 0 1 1]
[1 0 0 1 0 0 0 0 0 1]
[1 1 1 1 1 1 0 1 1 1]
[1 1 0 1 0 0 0 0 1 0]
[1 0 0 0 1 0 1 0 1 0]
[0 0 0 0 0 0 1 0 0 0]
[0 0 0 1 1 0 0 1 0 1]
[0 0 1 1 1 1 0 0 1 1]
[0 0 1 1 0 1 0 1 1 0]

Iterator চেকপয়েন্টিং

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

আপনার tf.train.Checkpoint একটি চেকপয়েন্টে অন্তর্ভুক্ত করতে, পুনরুক্তিটি 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.keras API মেশিন লার্নিং মডেলগুলি তৈরি এবং সম্পাদন করার অনেক দিককে সহজ করে tf.keras এর .fit() এবং .evaluate() এবং .predict() API গুলি ইনপুট হিসাবে .predict() সমর্থন করে। এখানে একটি দ্রুত ডেটাসেট এবং মডেল সেটআপ রয়েছে:

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

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

 model.fit(fmnist_train_ds, epochs=2)
 
Epoch 1/2
WARNING:tensorflow:Layer flatten is casting an input tensor from dtype float64 to the layer's dtype of float32, which is new behavior in TensorFlow 2.  The layer has dtype float32 because it's dtype defaults to floatx.

If you intended to run this layer in float32, you can safely ignore this warning. If in doubt, this warning is likely only an issue if you are porting a TensorFlow 1.X model to TensorFlow 2.

To change all layers to have dtype float64 by default, call `tf.keras.backend.set_floatx('float64')`. To change just this layer, pass dtype='float64' to the layer constructor. If you are the author of this layer, you can disable autocasting by passing autocast=False to the base Layer constructor.

1875/1875 [==============================] - 4s 2ms/step - loss: 0.6031 - accuracy: 0.7937
Epoch 2/2
1875/1875 [==============================] - 3s 2ms/step - loss: 0.4620 - accuracy: 0.8416

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

যদি আপনি একটি অসীম ডেটাসেট পাস করেন, উদাহরণস্বরূপ 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.4050 - accuracy: 0.8672
Epoch 2/2
20/20 [==============================] - 0s 2ms/step - loss: 0.4077 - accuracy: 0.8703

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

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

 loss, accuracy = model.evaluate(fmnist_train_ds)
print("Loss :", loss)
print("Accuracy :", accuracy)
 
1875/1875 [==============================] - 3s 2ms/step - loss: 0.4474 - accuracy: 0.8439
Loss : 0.4474281072616577
Accuracy : 0.843916654586792

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

 loss, accuracy = model.evaluate(fmnist_train_ds.repeat(), steps=10)
print("Loss :", loss)
print("Accuracy :", accuracy)
 
10/10 [==============================] - 0s 2ms/step - loss: 0.5262 - accuracy: 0.8156
Loss : 0.5262183547019958
Accuracy : 0.815625011920929

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)

tf.estimator

ব্যবহার করতে Dataset মধ্যে input_fn একটি এর tf.estimator.Estimator , সহজভাবে আসতে Dataset থেকে input_fn এবং ফ্রেমওয়ার্ক তোমার জন্য তার উপাদান গ্রাসকারী যত্ন নিতে হবে। উদাহরণ স্বরূপ:

 import tensorflow_datasets as tfds

def train_input_fn():
  titanic = tf.data.experimental.make_csv_dataset(
      titanic_file, batch_size=32,
      label_name="survived")
  titanic_batches = (
      titanic.cache().repeat().shuffle(500)
      .prefetch(tf.data.experimental.AUTOTUNE))
  return titanic_batches
 
 embark = tf.feature_column.categorical_column_with_hash_bucket('embark_town', 32)
cls = tf.feature_column.categorical_column_with_vocabulary_list('class', ['First', 'Second', 'Third']) 
age = tf.feature_column.numeric_column('age')
 
 import tempfile
model_dir = tempfile.mkdtemp()
model = tf.estimator.LinearClassifier(
    model_dir=model_dir,
    feature_columns=[embark, cls, age],
    n_classes=2
)
 
INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmpefmfuc4o', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true
graph_options {
  rewrite_options {
    meta_optimizer_iterations: ONE
  }
}
, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

 model = model.train(input_fn=train_input_fn, steps=100)
 
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/ops/resource_variable_ops.py:1666: calling BaseResourceVariable.__init__ (from tensorflow.python.ops.resource_variable_ops) with constraint is deprecated and will be removed in a future version.
Instructions for updating:
If using Keras pass *_constraint arguments to layers.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/training_util.py:236: Variable.initialized_value (from tensorflow.python.ops.variables) is deprecated and will be removed in a future version.
Instructions for updating:
Use Variable.read_value. Variables in 2.X are initialized automatically both in eager and graph (inside tf.defun) contexts.
INFO:tensorflow:Calling model_fn.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/feature_column/feature_column_v2.py:540: Layer.add_variable (from tensorflow.python.keras.engine.base_layer_v1) is deprecated and will be removed in a future version.
Instructions for updating:
Please use `layer.add_weight` method instead.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/optimizer_v2/ftrl.py:144: calling Constant.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.
Instructions for updating:
Call initializer instance with the dtype argument instead of passing it to the constructor
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...
INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmpefmfuc4o/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...
INFO:tensorflow:loss = 0.6931472, step = 0
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 100...
INFO:tensorflow:Saving checkpoints for 100 into /tmp/tmpefmfuc4o/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 100...
INFO:tensorflow:Loss for final step: 0.58668363.

 result = model.evaluate(train_input_fn, steps=10)

for key, value in result.items():
  print(key, ":", value)
 
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2020-07-23T01:23:29Z
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from /tmp/tmpefmfuc4o/model.ckpt-100
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [1/10]
INFO:tensorflow:Evaluation [2/10]
INFO:tensorflow:Evaluation [3/10]
INFO:tensorflow:Evaluation [4/10]
INFO:tensorflow:Evaluation [5/10]
INFO:tensorflow:Evaluation [6/10]
INFO:tensorflow:Evaluation [7/10]
INFO:tensorflow:Evaluation [8/10]
INFO:tensorflow:Evaluation [9/10]
INFO:tensorflow:Evaluation [10/10]
INFO:tensorflow:Inference Time : 0.83507s
INFO:tensorflow:Finished evaluation at 2020-07-23-01:23:30
INFO:tensorflow:Saving dict for global step 100: accuracy = 0.675, accuracy_baseline = 0.58125, auc = 0.71750116, auc_precision_recall = 0.6480325, average_loss = 0.64111984, global_step = 100, label/mean = 0.41875, loss = 0.64111984, precision = 0.85714287, prediction/mean = 0.30204886, recall = 0.26865673
INFO:tensorflow:Saving 'checkpoint_path' summary for global step 100: /tmp/tmpefmfuc4o/model.ckpt-100
accuracy : 0.675
accuracy_baseline : 0.58125
auc : 0.71750116
auc_precision_recall : 0.6480325
average_loss : 0.64111984
label/mean : 0.41875
loss : 0.64111984
precision : 0.85714287
prediction/mean : 0.30204886
recall : 0.26865673
global_step : 100

 for pred in model.predict(train_input_fn):
  for key, value in pred.items():
    print(key, ":", value)
  break
 
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from /tmp/tmpefmfuc4o/model.ckpt-100
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
logits : [-0.5965]
logistic : [0.3551]
probabilities : [0.6449 0.3551]
class_ids : [0]
classes : [b'0']
all_class_ids : [0 1]
all_classes : [b'0' b'1']