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

tfio.experimental.IODataset

গিটহাবের উত্স দেখুন

IODataset

উত্তরাধিকারগুলি থেকে: IODataset

নোটবুকগুলিতে ব্যবহৃত হয়

টিউটোরিয়ালে ব্যবহৃত হয়

variant_tensor একটি DT_VARIANT টেনসর যা ডেটাসেটকে উপস্থাপন করে।

element_spec এই ডেটাসেটের একটি উপাদানের প্রকারের স্পেসিফিকেশন।

dataset = tf.data.Dataset.from_tensor_slices([1, 2, 3])
dataset.element_spec
TensorSpec(shape=(), dtype=tf.int32, name=None)

পদ্ধতি

apply

এই ডেটাসেটে রূপান্তর ফাংশন প্রয়োগ করে।

apply কাস্টম Dataset ট্রান্সফর্মেশনগুলির শৃঙ্খলা সক্ষম করে, যা এমন ফাংশন হিসাবে উপস্থাপিত হয় যা একটি Dataset আর্গুমেন্ট গ্রহণ করে এবং একটি রূপান্তরিত Dataset ফিরিয়ে দেয়।

dataset = tf.data.Dataset.range(100)
def dataset_fn(ds):
  return ds.filter(lambda x: x < 5)
dataset = dataset.apply(dataset_fn)
list(dataset.as_numpy_iterator())
[0, 1, 2, 3, 4]

args
transformation_func একটি ফাংশন যা একটি Dataset আর্গুমেন্ট নেয় এবং একটি Dataset

রিটার্নস
Dataset Dataset প্রয়োগের দ্বারা ফিরে transformation_func এই ডেটা সেটটি করতে।

as_numpy_iterator

এমন একটি পুনরাবৃত্তি প্রদান করে যা ডেটাসেটের সমস্ত উপাদানকে আঙ্কায় রূপান্তর করে।

আপনার ডেটাসেটের সামগ্রীটি পরিদর্শন করতে as_numpy_iterator ব্যবহার করুন। উপাদান আকার এবং প্রকারগুলি দেখতে, as_numpy_iterator ব্যবহার না করে সরাসরি ডেটাসেট উপাদানগুলি মুদ্রণ করুন।

dataset = tf.data.Dataset.from_tensor_slices([1, 2, 3])
for element in dataset:
  print(element)
tf.Tensor(1, shape=(), dtype=int32)
tf.Tensor(2, shape=(), dtype=int32)
tf.Tensor(3, shape=(), dtype=int32)

এই পদ্ধতিটির জন্য আপনি আগ্রহী মোডে চলছে এবং ডেটাসেটের এলিমেন্ট_স্পেকটিতে কেবল TensorSpec উপাদান রয়েছে।

dataset = tf.data.Dataset.from_tensor_slices([1, 2, 3])
for element in dataset.as_numpy_iterator():
  print(element)
1
2
3
dataset = tf.data.Dataset.from_tensor_slices([1, 2, 3])
print(list(dataset.as_numpy_iterator()))
[1, 2, 3]

as_numpy_iterator() ডেটাसेट উপাদানের নেস্টেড কাঠামো সংরক্ষণ করবে।

dataset = tf.data.Dataset.from_tensor_slices({'a': ([1, 2], [3, 4]),
                                              'b': [5, 6]})
list(dataset.as_numpy_iterator()) == [{'a': (1, 3), 'b': 5},
                                      {'a': (2, 4), 'b': 6}]
True

রিটার্নস
ডেটাসেটের উপাদানগুলির উপর একটি পুনরাবৃত্তযোগ্য, তাদের টেনারগুলি নিম্পার অ্যারেতে রূপান্তরিত করে।

উত্থাপন
TypeError যদি কোনও উপাদানের একটি অ- Tensor মান থাকে।
RuntimeError আগ্রহী কার্যকর কার্যকর না করা হয়।

batch

এই ডেটাসেটের টানা উপাদানগুলিকে ব্যাচগুলিতে একত্রিত করে।

dataset = tf.data.Dataset.range(8)
dataset = dataset.batch(3)
list(dataset.as_numpy_iterator())
[array([0, 1, 2]), array([3, 4, 5]), array([6, 7])]
dataset = tf.data.Dataset.range(8)
dataset = dataset.batch(3, drop_remainder=True)
list(dataset.as_numpy_iterator())
[array([0, 1, 2]), array([3, 4, 5])]

ফলাফলের উপাদানগুলির উপাদানগুলির একটি অতিরিক্ত বাহ্যিক মাত্রা থাকবে, যা batch_size (বা শেষ উপাদানটির জন্য N % batch_size যদি batch_size ইনপুট উপাদানগুলির সংখ্যা N সমানভাবে ভাগ না করে এবং drop_remainder False )। আপনার প্রোগ্রাম একই বাইরের মাত্রা থাকার ব্যাচ উপর নির্ভর করে থাকে, তাহলে আপনি নির্ধারণ করা উচিত drop_remainder আর্গুমেন্ট প্রাপ্ত করতে True উত্পাদিত হচ্ছে থেকে ক্ষুদ্রতর ব্যাচ প্রতিরোধ।

args
batch_size একটি tf.int64 স্কেলার tf.Tensor , একটি একক ব্যাচে একত্রিত করার জন্য এই ডেটাসেটের একটানা উপাদানগুলির সংখ্যা উপস্থাপন করে।
drop_remainder ( tf.bool ।) একটি tf.bool স্কেলার tf.Tensor , batch_size উপাদানগুলির চেয়ে কম বাছাই করা ক্ষেত্রে শেষ ব্যাচটি বাদ দেওয়া উচিত কিনা তা উপস্থাপন করে; ডিফল্ট আচরণ ছোট ব্যাচ ড্রপ না হয়।

রিটার্নস
Dataset একটি Dataset

cache

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

প্রথমবার যখন ডেটাসেটটি পুনরাবৃত্তি হবে তখন এর উপাদানগুলি নির্দিষ্ট ফাইলে বা মেমরির মাধ্যমে ক্যাশে হবে। পরবর্তী পুনরাবৃত্তি ক্যাশেড ডেটা ব্যবহার করবে।

dataset = tf.data.Dataset.range(5)
dataset = dataset.map(lambda x: x**2)
dataset = dataset.cache()
# The first time reading through the data will generate the data using
# `range` and `map`.
list(dataset.as_numpy_iterator())
[0, 1, 4, 9, 16]
# Subsequent iterations read from the cache.
list(dataset.as_numpy_iterator())
[0, 1, 4, 9, 16]

কোনও ফাইলে ক্যাশ করার সময়, ক্যাশেড ডেটা চালিয়ে যায়। এমনকি ডেটা দিয়ে প্রথম পুনরাবৃত্তি ক্যাশে ফাইল থেকে পড়বে। । ক্যাশে .cache() তে কল করার আগে ইনপুট পাইপলাইন পরিবর্তন করা ক্যাশে ফাইলটি সরিয়ে না দেওয়া বা ফাইলের নাম পরিবর্তন না হওয়া পর্যন্ত কোনও প্রভাব ফেলবে না।

dataset = tf.data.Dataset.range(5)
dataset = dataset.cache("/path/to/file")  # doctest: +SKIP
list(dataset.as_numpy_iterator())  # doctest: +SKIP
[0, 1, 2, 3, 4]
dataset = tf.data.Dataset.range(10)
dataset = dataset.cache("/path/to/file")  # Same file! # doctest: +SKIP
list(dataset.as_numpy_iterator())  # doctest: +SKIP
[0, 1, 2, 3, 4]

args
filename একটি tf.string স্কেলার tf.Tensor , এই tf.Tensor ক্যাচিং উপাদানগুলির জন্য ফাইল সিস্টেমের একটি ডিরেক্টরির নাম উপস্থাপন করে। যদি কোনও ফাইলের নাম সরবরাহ না করা হয় তবে ডেটাসেট মেমরিতে ক্যাশে হবে।

রিটার্নস
Dataset একটি Dataset

cardinality

যদি জানা থাকে তবে ডেটাসেটের কার্ডিনালটিটি ফিরিয়ে দেয়।

cardinality tf.data.INFINITE_CARDINALITY ফিরিয়ে tf.data.INFINITE_CARDINALITY পারে যদি ডেটাসেটে সীমাহীন সংখ্যক উপাদান থাকে বা tf.data.UNKNOWN_CARDINALITY বিশ্লেষণটি যদি ডেটাসেটের উপাদানগুলির সংখ্যা নির্ধারণ করতে ব্যর্থ হয় (যেমন যখন ডেটাসেট উত্স কোনও ফাইল থাকে)।

dataset = tf.data.Dataset.range(42)
print(dataset.cardinality().numpy())
42
dataset = dataset.repeat()
cardinality = dataset.cardinality()
print((cardinality == tf.data.INFINITE_CARDINALITY).numpy())
True
dataset = dataset.filter(lambda x: True)
cardinality = dataset.cardinality()
print((cardinality == tf.data.UNKNOWN_CARDINALITY).numpy())
True

রিটার্নস
একটি স্কেলার tf.int64 Tensor ডেটাসেটের কার্ডিনালটির প্রতিনিধিত্ব করে। তাহলে cardinality অসীম বা অজানা, cardinality নামে ধ্রুবক ফেরৎ tf.data.INFINITE_CARDINALITY এবং tf.data.UNKNOWN_CARDINALITY যথাক্রমে।

concatenate

এই ডেটাসেটের সাথে প্রদত্ত Dataset দিয়ে একটি Dataset তৈরি করে।

a = tf.data.Dataset.range(1, 4)  # ==> [ 1, 2, 3 ]
b = tf.data.Dataset.range(4, 8)  # ==> [ 4, 5, 6, 7 ]
ds = a.concatenate(b)
list(ds.as_numpy_iterator())
[1, 2, 3, 4, 5, 6, 7]
# The input dataset and dataset to be concatenated should have the same
# nested structures and output types.
c = tf.data.Dataset.zip((a, b))
a.concatenate(c)
Traceback (most recent call last):
TypeError: Two datasets to concatenate have different types
<dtype: 'int64'> and (tf.int64, tf.int64)
d = tf.data.Dataset.from_tensor_slices(["a", "b", "c"])
a.concatenate(d)
Traceback (most recent call last):
TypeError: Two datasets to concatenate have different types
<dtype: 'int64'> and <dtype: 'string'>

args
dataset Dataset করা হবে।

রিটার্নস
Dataset একটি Dataset

enumerate

এই ডেটাসেটের উপাদানগুলি গণনা করে।

এটি পাইথনের enumerate সমান।

dataset = tf.data.Dataset.from_tensor_slices([1, 2, 3])
dataset = dataset.enumerate(start=5)
for element in dataset.as_numpy_iterator():
  print(element)
(5, 1)
(6, 2)
(7, 3)
# The nested structure of the input dataset determines the structure of
# elements in the resulting dataset.
dataset = tf.data.Dataset.from_tensor_slices([(7, 8), (9, 10)])
dataset = dataset.enumerate()
for element in dataset.as_numpy_iterator():
  print(element)
(0, array([7, 8], dtype=int32))
(1, array([ 9, 10], dtype=int32))

args
start একটি tf.int64 স্কেলার tf.Tensor , গণনার জন্য প্রারম্ভিক মান উপস্থাপন করে।

রিটার্নস
Dataset একটি Dataset

filter

predicate অনুযায়ী এই ডেটাসেট ফিল্টার করে।

dataset = tf.data.Dataset.from_tensor_slices([1, 2, 3])
dataset = dataset.filter(lambda x: x < 3)
list(dataset.as_numpy_iterator())
[1, 2]
# `tf.math.equal(x, y)` is required for equality comparison
def filter_fn(x):
  return tf.math.equal(x, 1)
dataset = dataset.filter(filter_fn)
list(dataset.as_numpy_iterator())
[1]

args
predicate একটি বুলিয়ান একটি ডেটাসেট উপাদান ম্যাপিং একটি ফাংশন।

রিটার্নস
Dataset Dataset এই ডেটা সেটটি, যার জন্য উপাদান ধারণকারী predicate হয় True

flat_map

এই ডেটাসেট জুড়ে মানচিত্রের মানচিত্র_ফঙ্ক এবং map_func করে।

আপনার ডেটাসেটের ক্রম একই থাকে কিনা তা নিশ্চিত করতে চাইলে flat_map ব্যবহার করুন। উদাহরণস্বরূপ, ব্যাচগুলির একটি ডেটাसेटকে তাদের উপাদানগুলির একটি ডেটাসেটে সমতল করতে:

dataset = tf.data.Dataset.from_tensor_slices(
               [[1, 2, 3], [4, 5, 6], [7, 8, 9]])
dataset = dataset.flat_map(lambda x: Dataset.from_tensor_slices(x))
list(dataset.as_numpy_iterator())
[1, 2, 3, 4, 5, 6, 7, 8, 9]

tf.data.Dataset.interleave() একটি সাধারণীকরণ ছাড়া কিছুই না flat_map , যেহেতু flat_map হিসাবে একই আউটপুট উত্পাদন করে tf.data.Dataset.interleave(cycle_length=1)

args
map_func একটি ফাংশন একটি ডেটাসেটে একটি ডেটাসেট উপাদান ম্যাপিং।

রিটার্নস
Dataset একটি Dataset

from_audio

উৎস দেখুন

একটি অডিও ফাইল থেকে একটি IODataset তৈরি করে।

নিম্নলিখিত অডিও ফাইল ফর্ম্যাটগুলি সমর্থিত:

  • WAV
  • FLAC
  • জন্য Vorbis
  • MP3 টি

args
filename একটি স্ট্রিং, একটি অডিও ফাইলের ফাইলের নাম।
name IOTensor এর জন্য একটি নামের উপসর্গ (nameচ্ছিক)।

রিটার্নস
একটি IODataset

from_avro

উৎস দেখুন

অভ্র ফাইলের ডেটাসেট অবজেক্ট থেকে একটি IODataset তৈরি করে।

args
filename একটি স্ট্রিং, একটি অভ্র ফাইলের ফাইলের নাম।
schema একটি স্ট্রিং, একটি অভ্র ফাইলের স্কিমা।
columns অভ্র ফাইলের মধ্যে কলামের নামের একটি তালিকা।
name IOTensor এর জন্য একটি নামের উপসর্গ (nameচ্ছিক)।

রিটার্নস
একটি IODataset

from_ffmpeg

উৎস দেখুন

IODataset মাধ্যমে একটি মিডিয়া ফাইল থেকে একটি IODataset তৈরি করে

args
filename একটি স্ট্রিং, একটি মিডিয়া ফাইলের ফাইলের নাম।
stream একটি স্ট্রিং, স্ট্রিম সূচক (যেমন, "ভি: 0")। নোট ভিডিও, অডিও এবং সাবটাইটেল সূচকটি 0 দিয়ে আলাদাভাবে শুরু হয়।
name IOTensor এর জন্য একটি নামের উপসর্গ (nameচ্ছিক)।

রিটার্নস
একটি IODataset

from_generator

এমন একটি Dataset তৈরি করে যার উপাদানগুলি generator দ্বারা উত্পাদিত।

generator আর্গুমেন্টটি অবশ্যই কলযোগ্য বস্তু হতে হবে যা এমন একটি বস্তু ফেরত দেয় যা iter() প্রোটোকলকে সমর্থন করে (যেমন একটি জেনারেটর ফাংশন)। generator দ্বারা উত্পাদিত উপাদানগুলি অবশ্যই প্রদত্ত output_types এবং ( output_shapes ) output_shapes যুক্তির সাথে সামঞ্জস্যপূর্ণ হতে হবে।

import itertools

def gen():
  for i in itertools.count(1):
    yield (i, [1] * i)

dataset = tf.data.Dataset.from_generator(
     gen,
     (tf.int64, tf.int64),
     (tf.TensorShape([]), tf.TensorShape([None])))

list(dataset.take(3).as_numpy_iterator())
[(1, array([1])), (2, array([1, 1])), (3, array([1, 1, 1]))]

args
generator কলযোগ্য বস্তু যা এমন একটি বস্তু দেয় যা iter() প্রোটোকল সমর্থন করে। যদি args নির্দিষ্ট না করা থাকে তবে generator অবশ্যই কোনও যুক্তি গ্রহণ করা উচিত নয়; যেমন সেখানে মান অন্যথায় এটা অনেক আর্গুমেন্ট হিসাবে নিতে হবে args
output_types generator দ্বারা উত্পাদিত উপাদানের প্রতিটি উপাদানগুলির সাথে সম্পর্কিত tf.DType অবজেক্টগুলির একটি নেস্টেড কাঠামো।
output_shapes ( tf.TensorShape ।) tf.TensorShape অবজেক্টগুলির generator দ্বারা উত্পাদিত উপাদানের প্রতিটি উপাদানগুলির সাথে সম্পর্কিত একটি নেস্টেড কাঠামো।
args ( tf.Tensor ।) tf.Tensor অবজেক্টের একটি tf.Tensor যা মূল্যায়ন করা হবে এবং tf.Tensor অ্যারে আর্গুমেন্ট হিসাবে generator প্রেরণ করা হবে।

রিটার্নস
Dataset একটি Dataset

from_hdf5

উৎস দেখুন

IODataset ফাইলের ডেটাসেট অবজেক্ট থেকে একটি IODataset তৈরি করে।

args
filename একটি স্ট্রিং, এইচডিএফ 5 ফাইলের ফাইলের নাম।
dataset একটি স্ট্রিং, এইচডিএফ 5 ফাইলের মধ্যে ডেটাসেটের নাম।
spec একটি tf.TensorSpec বা ডেটাসেটের একটি dtype (যেমন, tf.int64)। গ্রাফ মোডে, স্পেক প্রয়োজন। আগ্রহী মোডে, স্পেস স্বয়ংক্রিয়ভাবে অনুসন্ধান করা হয়।
name IOTensor এর জন্য একটি নামের উপসর্গ (nameচ্ছিক)।

রিটার্নস
একটি IODataset

from_json

উৎস দেখুন

একটি IODataset ফাইল থেকে একটি IODataset তৈরি করে।

args
filename একটি স্ট্রিং, একটি জসন ফাইলের ফাইলের নাম।
columns কলাম নামের একটি তালিকা। ডিফল্টরূপে (কিছুই নয়) সমস্ত কলাম পড়বে।
mode একটি স্ট্রিং, জেসন ফাইল খোলার জন্য মোড (রেকর্ড বা কোনও নয়)।
name IOTensor এর জন্য একটি নামের উপসর্গ (nameচ্ছিক)।

রিটার্নস
একটি IODataset

from_kafka

উৎস দেখুন

অফসেট পরিসীমা সহ IODataset সার্ভার থেকে একটি IODataset তৈরি করে।

args
topic একটি tf.string সাবস্ক্রিপশনযুক্ত একটি tf.string টেন্সর।
partition ডিফল্ট 0 দ্বারা পার্টিশন tf.int64 একটি tf.int64 টেন্সর।
start একটি tf.int64 টেন্সর ডিফল্ট 0 অনুসারে, অফসেটটি tf.int64
stop ডিফল্ট -1 দ্বারা অফসেট tf.int64 একটি tf.int64 টেন্সর।
servers ডিফল্ট localhost:9092 অনুসারে বুটস্ট্র্যাপ সার্ভারগুলির একটি listচ্ছিক তালিকা localhost:9092
configuration [কী = মান] ফর্ম্যাটে কনফিগারেশন সম্বলিত একটি বিকল্প tf.string তিন ধরণের কনফিগারেশন রয়েছে: গ্লোবাল কনফিগারেশন: দয়া করে লিবার্ডকাফকা ডকের 'গ্লোবাল কনফিগারেশন বৈশিষ্ট্য' দেখুন। উদাহরণগুলির মধ্যে অন্তর্ভুক্ত রয়েছে ["সক্ষম.auto.commit = মিথ্যা", "হার্টবিট.ইনটারওয়াল.এমস = 2000"] বিষয় কনফিগারেশন: দয়া করে লিবার্ডকাফকা ডকিতে 'টপিক কনফিগারেশন বৈশিষ্ট্য' উল্লেখ করুন। নোট করুন সমস্ত বিষয় কনফিগারেশন configuration.topic. সঙ্গে উপসর্গ configuration.topic. উচিত configuration.topic. । উদাহরণগুলির মধ্যে রয়েছে "" conf.topic.auto.offset.reset = প্রাচীনতম "]
name IODataset (alচ্ছিক) এর একটি নামের উপসর্গ।

রিটার্নস
একটি IODataset

from_kinesis

উৎস দেখুন

IODataset স্ট্রিম থেকে একটি IODataset তৈরি করে।

args
stream একটি স্ট্রিং, স্ট্রিমের নাম।
shard একটি স্ট্রিং, কাইনিসের শারড।
name IODataset (alচ্ছিক) জন্য একটি নামের উপসর্গ।

রিটার্নস
একটি IODataset

from_libsvm

উৎস দেখুন

একটি তৈরি করে IODataset একটি libsvm ফাইল থেকে।

args
filename এক বা একাধিক ফাইলের নাম tf.string একটি tf.string টেনসর।
num_features বৈশিষ্ট্য সংখ্যা। dtype (ptionচ্ছিক): আউটপুট বৈশিষ্ট্য সেন্সর প্রকার। Tf.float32 এ ডিফল্ট। লেবেল_ডাইপ (ptionচ্ছিক): আউটপুট লেবেল টেনসারের ধরণ। Tf.int64 এ ডিফল্ট।
compression_type (ঐচ্ছিক।) একটি tf.string স্কালে এক মূল্যায়নের "" (কোন কম্প্রেশন), "ZLIB" , বা "GZIP"
name IOTensor এর জন্য একটি নামের উপসর্গ (nameচ্ছিক)।

রিটার্নস
একটি IODataset

from_lmdb

উৎস দেখুন

একটি তৈরি করে IODataset একটি lmdb ফাইল থেকে।

args
filename একটি স্ট্রিং, একটি এলএমডিবি ফাইলের ফাইলের নাম।
name IOTensor এর জন্য একটি নামের উপসর্গ (nameচ্ছিক)।

রিটার্নস
একটি IODataset

from_mnist

উৎস দেখুন

এমএনআইএসটি চিত্র এবং / অথবা লেবেল ফাইলগুলি থেকে একটি IODataset তৈরি করে।

args
images একটি স্ট্রিং, এমএনআইএসটি চিত্রগুলির ফাইলের নাম।
labels একটি স্ট্রিং, এমএনআইএসটি লেবেলের ফাইলের ফাইলের নাম।
name IODataset (alচ্ছিক) এর একটি নামের উপসর্গ।

রিটার্নস
একটি IODataset

from_numpy

উৎস দেখুন

নম্পি অ্যারে থেকে একটি IODataset তৈরি করে।

from_numpy ব্যবহারকারীকে ডিক, টিপল, বা আঙ্কুল অ্যারে_লকের পৃথক উপাদান থেকে একটি ডেটাসেট তৈরি করতে দেয়। Dataset নির্মিত মাধ্যমে from_numpy array_like ইনপুট উপাদান হিসাবে একই dtypes হয়েছে। Dataset আকারগুলি অ্যারে_ লাইকের ইনপুট উপাদানগুলির সাথে সমান, শেপগুলির প্রথম মাত্রাগুলি কোনওটিতে সেট করা থাকে। কারণটি হ'ল পুনরাবৃত্ত ফলাফলের প্রথম মাত্রা যা উপাদানগুলির মোট সংখ্যায় বিভাজ্য হতে পারে না।

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

import numpy as np
import tensorflow as tf
import tensorflow_io as tfio
a = (np.asarray([[0., 1.], [2., 3.], [4., 5.], [6., 7.], [8., 9.]]),
     np.asarray([[10, 11], [12, 13], [14, 15], [16, 17], [18, 19]]))
d = tfio.experimental.IODataset.from_numpy(a).batch(2)
for i in d:
  print(i.numpy())
# numbers of elements = [2, 2, 1] <= (5 / 2)
#
# ([[0., 1.], [2., 3.]], [[10, 11], [12, 13]]) # <= batch index 0
# ([[4., 5.], [6., 7.]], [[14, 15], [16, 17]]) # <= batch index 1
# ([[8., 9.]],           [[18, 19]])           # <= batch index 2

আরোগুলি: ক: ডিক্ট, টিপল, বা অ্যারে_লাইজ নম্পি অ্যারে যদি ইনপুট টাইপটি অ্যারে_লাইক হয়; যদি ইনপুট প্রকারটি ডেক বা টিপল হয় তবে নির্লিপ্ত অ্যারেগুলির ডেক বা টিপল। নাম: IOTensor এর একটি নামের উপসর্গ (alচ্ছিক)।

রিটার্নস
একজন IODataset উল্লেখিত array_like একই dtypes সঙ্গে a

from_numpy_file

উৎস দেখুন

একটি তৈরি করে IODataset একটি Numpy ফাইল থেকে।

from_numpy_file ব্যবহারকারীকে একটি ন্যালি ফাইল (এনপিপি বা এনপিজেড) থেকে ডেটাসেট তৈরি করতে দেয়। Dataset মাধ্যমে তৈরি from_numpy_file numpy ফাইলে উপাদান হিসাবে একই dtypes হয়েছে। ডাটাসেটের আকারগুলি নমপি ফাইলের উপাদানের সাথে সমান, শেপগুলির প্রথম মাত্রাগুলি কোনওটিতে সেট না করে। কারণটি হ'ল পুনরাবৃত্ত ফলাফলের প্রথম মাত্রা যা উপাদানগুলির মোট সংখ্যায় বিভাজ্য হতে পারে না। যদি নাম্পি ফাইলটিতে নামবিহীন উপাদান থাকে, তবে নুপির অ্যারেগুলির একটি দ্বিগুণ পরিমাণ ফিরে আসে, অন্যথায় নামযুক্ত উপাদানগুলির জন্য ডিক্ট ফিরিয়ে দেওয়া হয়।

Args:
  filename: filename of numpy file (npy or npz).
  spec: A tuple of tf.TensorSpec or dtype, or a dict of
    `name:tf.TensorSpec` or `name:dtype` pairs to specify the dtypes
    in each element of the numpy file. In eager mode spec is automatically
    probed. In graph spec must be provided. If a tuple is provided for
    spec then it is assumed that numpy file consists of `arr_0`, `arr_2`...
    If a dict is provided then numpy file should consists of named
    elements.
  name: A name prefix for the IOTensor (optional).

<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Returns</th></tr>
<tr class="alt">
<td colspan="2">
A `IODataset` with the same dtypes as of the array_like in numpy
file (npy or npz).
</td>
</tr>

</table>



<h3 id="from_parquet"><code>from_parquet</code></h3>

<a target="_blank" href="https://github.com/tensorflow/io/blob/v0.15.0/tensorflow_io/core/python/ops/io_dataset.py#L258-L275">View source</a>

<pre class="devsite-click-to-copy prettyprint lang-py tfo-signature-link">
<code>@classmethod</code>
<code>from_parquet(
    filename, columns=None, **kwargs
)
</code></pre>

Creates an `IODataset` from a Parquet file.


<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Args</th></tr>

<tr>
<td>
`filename`
</td>
<td>
A string, the filename of a Parquet file.
</td>
</tr><tr>
<td>
`columns`
</td>
<td>
A list of column names. By default (None)
all columns will be read.
</td>
</tr><tr>
<td>
`name`
</td>
<td>
A name prefix for the IOTensor (optional).
</td>
</tr>
</table>



<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Returns</th></tr>
<tr class="alt">
<td colspan="2">
A `IODataset`.
</td>
</tr>

</table>



<h3 id="from_pcap"><code>from_pcap</code></h3>

<a target="_blank" href="https://github.com/tensorflow/io/blob/v0.15.0/tensorflow_io/core/python/ops/io_dataset.py#L295-L308">View source</a>

<pre class="devsite-click-to-copy prettyprint lang-py tfo-signature-link">
<code>@classmethod</code>
<code>from_pcap(
    filename, **kwargs
)
</code></pre>

Creates an `IODataset` from a pcap file.


<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Args</th></tr>

<tr>
<td>
`filename`
</td>
<td>
A string, the filename of a pcap file.
</td>
</tr><tr>
<td>
`name`
</td>
<td>
A name prefix for the IOTensor (optional).
</td>
</tr>
</table>



<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Returns</th></tr>
<tr class="alt">
<td colspan="2">
A `IODataset`.
</td>
</tr>

</table>



<h3 id="from_prometheus"><code>from_prometheus</code></h3>

<a target="_blank" href="https://github.com/tensorflow/io/blob/v0.15.0/tensorflow_io/core/python/experimental/io_dataset_ops.py#L195-L221">View source</a>

<pre class="devsite-click-to-copy prettyprint lang-py tfo-signature-link">
<code>@classmethod</code>
<code>from_prometheus(
    query, length, offset=None, endpoint=None, spec=None
)
</code></pre>

Creates an `GraphIODataset` from a prometheus endpoint.


<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Args</th></tr>

<tr>
<td>
`query`
</td>
<td>
A string, the query string for prometheus.
</td>
</tr><tr>
<td>
`length`
</td>
<td>
An integer, the length of the query (in seconds).
</td>
</tr><tr>
<td>
`offset`
</td>
<td>
An integer, the a millisecond-precision timestamp, by default
the time when graph runs.
</td>
</tr><tr>
<td>
`endpoint`
</td>
<td>
A string, the server address of prometheus, by default
`http://localhost:9090`.
</td>
</tr><tr>
<td>
`spec`
</td>
<td>
A structured tf.TensorSpec of the dataset.
The format should be {"job": {"instance": {"name": tf.TensorSpec} } }.
In graph mode, spec is needed. In eager mode,
spec is probed automatically.
</td>
</tr><tr>
<td>
`name`
</td>
<td>
A name prefix for the IODataset (optional).
</td>
</tr>
</table>



<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Returns</th></tr>
<tr class="alt">
<td colspan="2">
A `IODataset`.
</td>
</tr>

</table>



<h3 id="from_sql"><code>from_sql</code></h3>

<a target="_blank" href="https://github.com/tensorflow/io/blob/v0.15.0/tensorflow_io/core/python/experimental/io_dataset_ops.py#L223-L238">View source</a>

<pre class="devsite-click-to-copy prettyprint lang-py tfo-signature-link">
<code>@classmethod</code>
<code>from_sql(
    query, endpoint=None, spec=None
)
</code></pre>

Creates an `GraphIODataset` from a postgresql server endpoint.


<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Args</th></tr>

<tr>
<td>
`query`
</td>
<td>
A string, the sql query string.
</td>
</tr><tr>
<td>
`endpoint`
</td>
<td>
A string, the server address of postgresql server.
</td>
</tr><tr>
<td>
`spec`
</td>
<td>
A structured (tuple) tf.TensorSpec of the dataset.
In graph mode, spec is needed. In eager mode,
spec is probed automatically.
</td>
</tr><tr>
<td>
`name`
</td>
<td>
A name prefix for the IODataset (optional).
</td>
</tr>
</table>



<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Returns</th></tr>
<tr class="alt">
<td colspan="2">
A `IODataset`.
</td>
</tr>

</table>



<h3 id="from_tensor_slices"><code>from_tensor_slices</code></h3>

<pre class="devsite-click-to-copy prettyprint lang-py tfo-signature-link">
<code>@staticmethod</code>
<code>from_tensor_slices(
    tensors
)
</code></pre>

Creates a `Dataset` whose elements are slices of the given tensors.

The given tensors are sliced along their first dimension. This operation
preserves the structure of the input tensors, removing the first dimension
of each tensor and using it as the dataset dimension. All input tensors
must have the same size in their first dimensions.

<pre class="devsite-click-to-copy prettyprint lang-py">
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;"># Slicing a 1D tensor produces scalar tensor elements.</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">dataset = tf.data.Dataset.from_tensor_slices([1, 2, 3])</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">list(dataset.as_numpy_iterator())</code>
<code class="no-select nocode">[1, 2, 3]</code>
</pre>


<pre class="devsite-click-to-copy prettyprint lang-py">
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;"># Slicing a 2D tensor produces 1D tensor elements.</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">dataset = tf.data.Dataset.from_tensor_slices([[1, 2], [3, 4]])</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">list(dataset.as_numpy_iterator())</code>
<code class="no-select nocode">[array([1, 2], dtype=int32), array([3, 4], dtype=int32)]</code>
</pre>


<pre class="devsite-click-to-copy prettyprint lang-py">
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;"># Slicing a tuple of 1D tensors produces tuple elements containing</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;"># scalar tensors.</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">dataset = tf.data.Dataset.from_tensor_slices(([1, 2], [3, 4], [5, 6]))</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">list(dataset.as_numpy_iterator())</code>
<code class="no-select nocode">[(1, 3, 5), (2, 4, 6)]</code>
</pre>


<pre class="devsite-click-to-copy prettyprint lang-py">
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;"># Dictionary structure is also preserved.</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">dataset = tf.data.Dataset.from_tensor_slices({&quot;a&quot;: [1, 2], &quot;b&quot;: [3, 4]})</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">list(dataset.as_numpy_iterator()) == [{&#x27;a&#x27;: 1, &#x27;b&#x27;: 3},</code>
<code class="devsite-terminal" data-terminal-prefix="...">                                      {&#x27;a&#x27;: 2, &#x27;b&#x27;: 4}]</code>
<code class="no-select nocode">True</code>
</pre>


<pre class="devsite-click-to-copy prettyprint lang-py">
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;"># Two tensors can be combined into one Dataset object.</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">features = tf.constant([[1, 3], [2, 1], [3, 3]]) # ==&gt; 3x2 tensor</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">labels = tf.constant([&#x27;A&#x27;, &#x27;B&#x27;, &#x27;A&#x27;]) # ==&gt; 3x1 tensor</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">dataset = Dataset.from_tensor_slices((features, labels))</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;"># Both the features and the labels tensors can be converted</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;"># to a Dataset object separately and combined after.</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">features_dataset = Dataset.from_tensor_slices(features)</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">labels_dataset = Dataset.from_tensor_slices(labels)</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">dataset = Dataset.zip((features_dataset, labels_dataset))</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;"># A batched feature and label set can be converted to a Dataset</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;"># in similar fashion.</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">batched_features = tf.constant([[[1, 3], [2, 3]],</code>
<code class="devsite-terminal" data-terminal-prefix="...">                                [[2, 1], [1, 2]],</code>
<code class="devsite-terminal" data-terminal-prefix="...">                                [[3, 3], [3, 2]]], shape=(3, 2, 2))</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">batched_labels = tf.constant([[&#x27;A&#x27;, &#x27;A&#x27;],</code>
<code class="devsite-terminal" data-terminal-prefix="...">                              [&#x27;B&#x27;, &#x27;B&#x27;],</code>
<code class="devsite-terminal" data-terminal-prefix="...">                              [&#x27;A&#x27;, &#x27;B&#x27;]], shape=(3, 2, 1))</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">dataset = Dataset.from_tensor_slices((batched_features, batched_labels))</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">for element in dataset.as_numpy_iterator():</code>
<code class="devsite-terminal" data-terminal-prefix="...">  print(element)</code>
<code class="no-select nocode">(array([[1, 3],</code>
<code class="no-select nocode">       [2, 3]], dtype=int32), array([[b&#x27;A&#x27;],</code>
<code class="no-select nocode">       [b&#x27;A&#x27;]], dtype=object))</code>
<code class="no-select nocode">(array([[2, 1],</code>
<code class="no-select nocode">       [1, 2]], dtype=int32), array([[b&#x27;B&#x27;],</code>
<code class="no-select nocode">       [b&#x27;B&#x27;]], dtype=object))</code>
<code class="no-select nocode">(array([[3, 3],</code>
<code class="no-select nocode">       [3, 2]], dtype=int32), array([[b&#x27;A&#x27;],</code>
<code class="no-select nocode">       [b&#x27;B&#x27;]], dtype=object))</code>
</pre>


Note that if `tensors` contains a NumPy array, and eager execution is not
enabled, the values will be embedded in the graph as one or more
`tf.constant` operations. For large datasets (> 1 GB), this can waste
memory and run into byte limits of graph serialization. If `tensors`
contains one or more large NumPy arrays, consider the alternative described
in [this guide](
https://tensorflow.org/guide/data#consuming_numpy_arrays).

<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Args</th></tr>

<tr>
<td>
`tensors`
</td>
<td>
A dataset element, with each component having the same size in
the first dimension.
</td>
</tr>
</table>



<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Returns</th></tr>

<tr>
<td>
`Dataset`
</td>
<td>
A `Dataset`.
</td>
</tr>
</table>



<h3 id="from_tensors"><code>from_tensors</code></h3>

<pre class="devsite-click-to-copy prettyprint lang-py tfo-signature-link">
<code>@staticmethod</code>
<code>from_tensors(
    tensors
)
</code></pre>

Creates a `Dataset` with a single element, comprising the given tensors.

`from_tensors` produces a dataset containing only a single element. To slice
the input tensor into multiple elements, use `from_tensor_slices` instead.

<pre class="devsite-click-to-copy prettyprint lang-py">
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">dataset = tf.data.Dataset.from_tensors([1, 2, 3])</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">list(dataset.as_numpy_iterator())</code>
<code class="no-select nocode">[array([1, 2, 3], dtype=int32)]</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">dataset = tf.data.Dataset.from_tensors(([1, 2, 3], &#x27;A&#x27;))</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">list(dataset.as_numpy_iterator())</code>
<code class="no-select nocode">[(array([1, 2, 3], dtype=int32), b&#x27;A&#x27;)]</code>
</pre>


<pre class="devsite-click-to-copy prettyprint lang-py">
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;"># You can use `from_tensors` to produce a dataset which repeats</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;"># the same example many times.</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">example = tf.constant([1,2,3])</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">dataset = tf.data.Dataset.from_tensors(example).repeat(2)</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">list(dataset.as_numpy_iterator())</code>
<code class="no-select nocode">[array([1, 2, 3], dtype=int32), array([1, 2, 3], dtype=int32)]</code>
</pre>


Note that if `tensors` contains a NumPy array, and eager execution is not
enabled, the values will be embedded in the graph as one or more
`tf.constant` operations. For large datasets (> 1 GB), this can waste
memory and run into byte limits of graph serialization. If `tensors`
contains one or more large NumPy arrays, consider the alternative described
in [this
guide](https://tensorflow.org/guide/data#consuming_numpy_arrays).

<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Args</th></tr>

<tr>
<td>
`tensors`
</td>
<td>
A dataset element.
</td>
</tr>
</table>



<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Returns</th></tr>

<tr>
<td>
`Dataset`
</td>
<td>
A `Dataset`.
</td>
</tr>
</table>



<h3 id="from_tiff"><code>from_tiff</code></h3>

<a target="_blank" href="https://github.com/tensorflow/io/blob/v0.15.0/tensorflow_io/core/python/experimental/io_dataset_ops.py#L88-L100">View source</a>

<pre class="devsite-click-to-copy prettyprint lang-py tfo-signature-link">
<code>@classmethod</code>
<code>from_tiff(
    filename, **kwargs
)
</code></pre>

Creates an `IODataset` from a TIFF file.


<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Args</th></tr>

<tr>
<td>
`filename`
</td>
<td>
A string, the filename of a TIFF file.
</td>
</tr><tr>
<td>
`name`
</td>
<td>
A name prefix for the IOTensor (optional).
</td>
</tr>
</table>



<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Returns</th></tr>
<tr class="alt">
<td colspan="2">
A `IODataset`.
</td>
</tr>

</table>



<h3 id="from_video"><code>from_video</code></h3>

<a target="_blank" href="https://github.com/tensorflow/io/blob/v0.15.0/tensorflow_io/core/python/experimental/io_dataset_ops.py#L240-L251">View source</a>

<pre class="devsite-click-to-copy prettyprint lang-py tfo-signature-link">
<code>@classmethod</code>
<code>from_video(
    filename
)
</code></pre>

Creates an `GraphIODataset` from a video file.


<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Args</th></tr>

<tr>
<td>
`filename`
</td>
<td>
A string, the sql query string.
</td>
</tr><tr>
<td>
`name`
</td>
<td>
A name prefix for the IODataset (optional).
</td>
</tr>
</table>



<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Returns</th></tr>
<tr class="alt">
<td colspan="2">
A `IODataset`.
</td>
</tr>

</table>



<h3 id="graph"><code>graph</code></h3>

<a target="_blank" href="https://github.com/tensorflow/io/blob/v0.15.0/tensorflow_io/core/python/ops/io_dataset.py#L67-L79">View source</a>

<pre class="devsite-click-to-copy prettyprint lang-py tfo-signature-link">
<code>@classmethod</code>
<code>graph(
    dtype
)
</code></pre>

Obtain a GraphIODataset to be used in graph mode.


<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Args</th></tr>

<tr>
<td>
`dtype`
</td>
<td>
Data type of the GraphIODataset.
</td>
</tr>
</table>



<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Returns</th></tr>
<tr class="alt">
<td colspan="2">
A class of `GraphIODataset`.
</td>
</tr>

</table>



<h3 id="interleave"><code>interleave</code></h3>

<pre class="devsite-click-to-copy prettyprint lang-py tfo-signature-link">
<code>interleave(
    map_func, cycle_length=None, block_length=None, num_parallel_calls=None,
    deterministic=None
)
</code></pre>

Maps `map_func` across this dataset, and interleaves the results.

For example, you can use `Dataset.interleave()` to process many input files
concurrently:

<pre class="devsite-click-to-copy prettyprint lang-py">
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;"># Preprocess 4 files concurrently, and interleave blocks of 16 records</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;"># from each file.</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">filenames = [&quot;/var/data/file1.txt&quot;, &quot;/var/data/file2.txt&quot;,</code>
<code class="devsite-terminal" data-terminal-prefix="...">             &quot;/var/data/file3.txt&quot;, &quot;/var/data/file4.txt&quot;]</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">dataset = tf.data.Dataset.from_tensor_slices(filenames)</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">def parse_fn(filename):</code>
<code class="devsite-terminal" data-terminal-prefix="...">  return tf.data.Dataset.range(10)</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">dataset = dataset.interleave(lambda x:</code>
<code class="devsite-terminal" data-terminal-prefix="...">    tf.data.TextLineDataset(x).map(parse_fn, num_parallel_calls=1),</code>
<code class="devsite-terminal" data-terminal-prefix="...">    cycle_length=4, block_length=16)</code>
</pre>


The `cycle_length` and `block_length` arguments control the order in which
elements are produced. `cycle_length` controls the number of input elements
that are processed concurrently. If you set `cycle_length` to 1, this
transformation will handle one input element at a time, and will produce
identical results to `tf.data.Dataset.flat_map`. In general,
this transformation will apply `map_func` to `cycle_length` input elements,
open iterators on the returned `Dataset` objects, and cycle through them
producing `block_length` consecutive elements from each iterator, and
consuming the next input element each time it reaches the end of an
iterator.

#### For example:

<pre class="devsite-click-to-copy prettyprint lang-py">
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">dataset = Dataset.range(1, 6)  # ==&gt; [ 1, 2, 3, 4, 5 ]</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;"># NOTE: New lines indicate &quot;block&quot; boundaries.</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">dataset = dataset.interleave(</code>
<code class="devsite-terminal" data-terminal-prefix="...">    lambda x: Dataset.from_tensors(x).repeat(6),</code>
<code class="devsite-terminal" data-terminal-prefix="...">    cycle_length=2, block_length=4)</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">list(dataset.as_numpy_iterator())</code>
<code class="no-select nocode">[1, 1, 1, 1,</code>
<code class="no-select nocode"> 2, 2, 2, 2,</code>
<code class="no-select nocode"> 1, 1,</code>
<code class="no-select nocode"> 2, 2,</code>
<code class="no-select nocode"> 3, 3, 3, 3,</code>
<code class="no-select nocode"> 4, 4, 4, 4,</code>
<code class="no-select nocode"> 3, 3,</code>
<code class="no-select nocode"> 4, 4,</code>
<code class="no-select nocode"> 5, 5, 5, 5,</code>
<code class="no-select nocode"> 5, 5]</code>
</pre>


Note: The order of elements yielded by this transformation is
deterministic, as long as `map_func` is a pure function and
`deterministic=True`. If `map_func` contains any stateful operations, the
order in which that state is accessed is undefined.

Performance can often be improved by setting `num_parallel_calls` so that
`interleave` will use multiple threads to fetch elements. If determinism
isn't required, it can also improve performance to set
`deterministic=False`.

<pre class="devsite-click-to-copy prettyprint lang-py">
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">filenames = [&quot;/var/data/file1.txt&quot;, &quot;/var/data/file2.txt&quot;,</code>
<code class="devsite-terminal" data-terminal-prefix="...">             &quot;/var/data/file3.txt&quot;, &quot;/var/data/file4.txt&quot;]</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">dataset = tf.data.Dataset.from_tensor_slices(filenames)</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">dataset = dataset.interleave(lambda x: tf.data.TFRecordDataset(x),</code>
<code class="devsite-terminal" data-terminal-prefix="...">    cycle_length=4, num_parallel_calls=tf.data.experimental.AUTOTUNE,</code>
<code class="devsite-terminal" data-terminal-prefix="...">    deterministic=False)</code>
</pre>


<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Args</th></tr>

<tr>
<td>
`map_func`
</td>
<td>
A function mapping a dataset element to a dataset.
</td>
</tr><tr>
<td>
`cycle_length`
</td>
<td>
(Optional.) The number of input elements that will be
processed concurrently. If not set, the tf.data runtime decides what it
should be based on available CPU. If `num_parallel_calls` is set to
`tf.data.experimental.AUTOTUNE`, the `cycle_length` argument identifies
the maximum degree of parallelism.
</td>
</tr><tr>
<td>
`block_length`
</td>
<td>
(Optional.) The number of consecutive elements to produce
from each input element before cycling to another input element. If not
set, defaults to 1.
</td>
</tr><tr>
<td>
`num_parallel_calls`
</td>
<td>
(Optional.) If specified, the implementation creates a
threadpool, which is used to fetch inputs from cycle elements
asynchronously and in parallel. The default behavior is to fetch inputs
from cycle elements synchronously with no parallelism. If the value
`tf.data.experimental.AUTOTUNE` is used, then the number of parallel
calls is set dynamically based on available CPU.
</td>
</tr><tr>
<td>
`deterministic`
</td>
<td>
(Optional.) A boolean controlling whether determinism
should be traded for performance by allowing elements to be produced out
of order.  If `deterministic` is `None`, the
`tf.data.Options.experimental_deterministic` dataset option (`True` by
default) is used to decide whether to produce elements
deterministically.
</td>
</tr>
</table>



<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Returns</th></tr>

<tr>
<td>
`Dataset`
</td>
<td>
A `Dataset`.
</td>
</tr>
</table>



<h3 id="list_files"><code>list_files</code></h3>

<pre class="devsite-click-to-copy prettyprint lang-py tfo-signature-link">
<code>@staticmethod</code>
<code>list_files(
    file_pattern, shuffle=None, seed=None
)
</code></pre>

A dataset of all files matching one or more glob patterns.

The `file_pattern` argument should be a small number of glob patterns.
If your filenames have already been globbed, use
`Dataset.from_tensor_slices(filenames)` instead, as re-globbing every
filename with `list_files` may result in poor performance with remote
storage systems.

Note: The default behavior of this method is to return filenames in
a non-deterministic random shuffled order. Pass a `seed` or `shuffle=False`
to get results in a deterministic order.

#### Example:

If we had the following files on our filesystem:

  - /path/to/dir/a.txt
  - /path/to/dir/b.py
  - /path/to/dir/c.py

If we pass "/path/to/dir/*.py" as the directory, the dataset
would produce:

  - /path/to/dir/b.py
  - /path/to/dir/c.py



<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Args</th></tr>

<tr>
<td>
`file_pattern`
</td>
<td>
A string, a list of strings, or a `tf.Tensor` of string type
(scalar or vector), representing the filename glob (i.e. shell wildcard)
pattern(s) that will be matched.
</td>
</tr><tr>
<td>
`shuffle`
</td>
<td>
(Optional.) If `True`, the file names will be shuffled randomly.
Defaults to `True`.
</td>
</tr><tr>
<td>
`seed`
</td>
<td>
(Optional.) A `tf.int64` scalar `tf.Tensor`, representing the random
seed that will be used to create the distribution. See
`tf.random.set_seed` for behavior.
</td>
</tr>
</table>



<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Returns</th></tr>

<tr>
<td>
`Dataset`
</td>
<td>
A `Dataset` of strings corresponding to file names.
</td>
</tr>
</table>



<h3 id="map"><code>map</code></h3>

<pre class="devsite-click-to-copy prettyprint lang-py tfo-signature-link">
<code>map(
    map_func, num_parallel_calls=None, deterministic=None
)
</code></pre>

Maps `map_func` across the elements of this dataset.

This transformation applies `map_func` to each element of this dataset, and
returns a new dataset containing the transformed elements, in the same
order as they appeared in the input. `map_func` can be used to change both
the values and the structure of a dataset's elements. For example, adding 1
to each element, or projecting a subset of element components.

<pre class="devsite-click-to-copy prettyprint lang-py">
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">dataset = Dataset.range(1, 6)  # ==&gt; [ 1, 2, 3, 4, 5 ]</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">dataset = dataset.map(lambda x: x + 1)</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">list(dataset.as_numpy_iterator())</code>
<code class="no-select nocode">[2, 3, 4, 5, 6]</code>
</pre>


The input signature of `map_func` is determined by the structure of each
element in this dataset.

<pre class="devsite-click-to-copy prettyprint lang-py">
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">dataset = Dataset.range(5)</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;"># `map_func` takes a single argument of type `tf.Tensor` with the same</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;"># shape and dtype.</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">result = dataset.map(lambda x: x + 1)</code>
</pre>


<pre class="devsite-click-to-copy prettyprint lang-py">
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;"># Each element is a tuple containing two `tf.Tensor` objects.</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">elements = [(1, &quot;foo&quot;), (2, &quot;bar&quot;), (3, &quot;baz&quot;)]</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">dataset = tf.data.Dataset.from_generator(</code>
<code class="devsite-terminal" data-terminal-prefix="...">    lambda: elements, (tf.int32, tf.string))</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;"># `map_func` takes two arguments of type `tf.Tensor`. This function</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;"># projects out just the first component.</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">result = dataset.map(lambda x_int, y_str: x_int)</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">list(result.as_numpy_iterator())</code>
<code class="no-select nocode">[1, 2, 3]</code>
</pre>


<pre class="devsite-click-to-copy prettyprint lang-py">
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;"># Each element is a dictionary mapping strings to `tf.Tensor` objects.</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">elements =  ([{&quot;a&quot;: 1, &quot;b&quot;: &quot;foo&quot;},</code>
<code class="devsite-terminal" data-terminal-prefix="...">              {&quot;a&quot;: 2, &quot;b&quot;: &quot;bar&quot;},</code>
<code class="devsite-terminal" data-terminal-prefix="...">              {&quot;a&quot;: 3, &quot;b&quot;: &quot;baz&quot;}])</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">dataset = tf.data.Dataset.from_generator(</code>
<code class="devsite-terminal" data-terminal-prefix="...">    lambda: elements, {&quot;a&quot;: tf.int32, &quot;b&quot;: tf.string})</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;"># `map_func` takes a single argument of type `dict` with the same keys</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;"># as the elements.</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">result = dataset.map(lambda d: str(d[&quot;a&quot;]) + d[&quot;b&quot;])</code>
</pre>


The value or values returned by `map_func` determine the structure of each
element in the returned dataset.

<pre class="devsite-click-to-copy prettyprint lang-py">
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">dataset = tf.data.Dataset.range(3)</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;"># `map_func` returns two `tf.Tensor` objects.</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">def g(x):</code>
<code class="devsite-terminal" data-terminal-prefix="...">  return tf.constant(37.0), tf.constant([&quot;Foo&quot;, &quot;Bar&quot;, &quot;Baz&quot;])</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">result = dataset.map(g)</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">result.element_spec</code>
<code class="no-select nocode">(TensorSpec(shape=(), dtype=tf.float32, name=None), TensorSpec(shape=(3,), dtype=tf.string, name=None))</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;"># Python primitives, lists, and NumPy arrays are implicitly converted to</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;"># `tf.Tensor`.</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">def h(x):</code>
<code class="devsite-terminal" data-terminal-prefix="...">  return 37.0, [&quot;Foo&quot;, &quot;Bar&quot;], np.array([1.0, 2.0], dtype=np.float64)</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">result = dataset.map(h)</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">result.element_spec</code>
<code class="no-select nocode">(TensorSpec(shape=(), dtype=tf.float32, name=None), TensorSpec(shape=(2,), dtype=tf.string, name=None), TensorSpec(shape=(2,), dtype=tf.float64, name=None))</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;"># `map_func` can return nested structures.</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">def i(x):</code>
<code class="devsite-terminal" data-terminal-prefix="...">  return (37.0, [42, 16]), &quot;foo&quot;</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">result = dataset.map(i)</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">result.element_spec</code>
<code class="no-select nocode">((TensorSpec(shape=(), dtype=tf.float32, name=None),</code>
<code class="no-select nocode">  TensorSpec(shape=(2,), dtype=tf.int32, name=None)),</code>
<code class="no-select nocode"> TensorSpec(shape=(), dtype=tf.string, name=None))</code>
</pre>


`map_func` can accept as arguments and return any type of dataset element.

Note that irrespective of the context in which `map_func` is defined (eager
vs. graph), tf.data traces the function and executes it as a graph. To use
Python code inside of the function you have a few options:

1) Rely on AutoGraph to convert Python code into an equivalent graph
computation. The downside of this approach is that AutoGraph can convert
some but not all Python code.

2) Use `tf.py_function`, which allows you to write arbitrary Python code but
will generally result in worse performance than 1). For example:

<pre class="devsite-click-to-copy prettyprint lang-py">
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">d = tf.data.Dataset.from_tensor_slices([&#x27;hello&#x27;, &#x27;world&#x27;])</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;"># transform a string tensor to upper case string using a Python function</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">def upper_case_fn(t: tf.Tensor):</code>
<code class="devsite-terminal" data-terminal-prefix="...">  return t.numpy().decode(&#x27;utf-8&#x27;).upper()</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">d = d.map(lambda x: tf.py_function(func=upper_case_fn,</code>
<code class="devsite-terminal" data-terminal-prefix="...">          inp=[x], Tout=tf.string))</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">list(d.as_numpy_iterator())</code>
<code class="no-select nocode">[b&#x27;HELLO&#x27;, b&#x27;WORLD&#x27;]</code>
</pre>


3) Use `tf.numpy_function`, which also allows you to write arbitrary
Python code. Note that `tf.py_function` accepts `tf.Tensor` whereas
`tf.numpy_function` accepts numpy arrays and returns only numpy arrays.
For example:

<pre class="devsite-click-to-copy prettyprint lang-py">
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">d = tf.data.Dataset.from_tensor_slices([&#x27;hello&#x27;, &#x27;world&#x27;])</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">def upper_case_fn(t: np.ndarray):</code>
<code class="devsite-terminal" data-terminal-prefix="...">  return t.decode(&#x27;utf-8&#x27;).upper()</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">d = d.map(lambda x: tf.numpy_function(func=upper_case_fn,</code>
<code class="devsite-terminal" data-terminal-prefix="...">          inp=[x], Tout=tf.string))</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">list(d.as_numpy_iterator())</code>
<code class="no-select nocode">[b&#x27;HELLO&#x27;, b&#x27;WORLD&#x27;]</code>
</pre>


Note that the use of `tf.numpy_function` and `tf.py_function`
in general precludes the possibility of executing user-defined
transformations in parallel (because of Python GIL).

Performance can often be improved by setting `num_parallel_calls` so that
`map` will use multiple threads to process elements. If deterministic order
isn't required, it can also improve performance to set
`deterministic=False`.

<pre class="devsite-click-to-copy prettyprint lang-py">
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">dataset = Dataset.range(1, 6)  # ==&gt; [ 1, 2, 3, 4, 5 ]</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">dataset = dataset.map(lambda x: x + 1,</code>
<code class="devsite-terminal" data-terminal-prefix="...">    num_parallel_calls=tf.data.experimental.AUTOTUNE,</code>
<code class="devsite-terminal" data-terminal-prefix="...">    deterministic=False)</code>
</pre>


<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Args</th></tr>

<tr>
<td>
`map_func`
</td>
<td>
A function mapping a dataset element to another dataset element.
</td>
</tr><tr>
<td>
`num_parallel_calls`
</td>
<td>
(Optional.) A `tf.int32` scalar `tf.Tensor`,
representing the number elements to process asynchronously in parallel.
If not specified, elements will be processed sequentially. If the value
`tf.data.experimental.AUTOTUNE` is used, then the number of parallel
calls is set dynamically based on available CPU.
</td>
</tr><tr>
<td>
`deterministic`
</td>
<td>
(Optional.) A boolean controlling whether determinism
should be traded for performance by allowing elements to be produced out
of order.  If `deterministic` is `None`, the
`tf.data.Options.experimental_deterministic` dataset option (`True` by
default) is used to decide whether to produce elements
deterministically.
</td>
</tr>
</table>



<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Returns</th></tr>

<tr>
<td>
`Dataset`
</td>
<td>
A `Dataset`.
</td>
</tr>
</table>



<h3 id="options"><code>options</code></h3>

<pre class="devsite-click-to-copy prettyprint lang-py tfo-signature-link">
<code>options()
</code></pre>

Returns the options for this dataset and its inputs.


<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Returns</th></tr>
<tr class="alt">
<td colspan="2">
A `tf.data.Options` object representing the dataset options.
</td>
</tr>

</table>



<h3 id="padded_batch"><code>padded_batch</code></h3>

<pre class="devsite-click-to-copy prettyprint lang-py tfo-signature-link">
<code>padded_batch(
    batch_size, padded_shapes=None, padding_values=None, drop_remainder=False
)
</code></pre>

Combines consecutive elements of this dataset into padded batches.

This transformation combines multiple consecutive elements of the input
dataset into a single element.

Like `tf.data.Dataset.batch`, the components of the resulting element will
have an additional outer dimension, which will be `batch_size` (or
`N % batch_size` for the last element if `batch_size` does not divide the
number of input elements `N` evenly and `drop_remainder` is `False`). If
your program depends on the batches having the same outer dimension, you
should set the `drop_remainder` argument to `True` to prevent the smaller
batch from being produced.

Unlike `tf.data.Dataset.batch`, the input elements to be batched may have
different shapes, and this transformation will pad each component to the
respective shape in `padded_shapes`. The `padded_shapes` argument
determines the resulting shape for each dimension of each component in an
output element:

* If the dimension is a constant, the component will be padded out to that
  length in that dimension.
* If the dimension is unknown, the component will be padded out to the
  maximum length of all elements in that dimension.

<pre class="devsite-click-to-copy prettyprint lang-py">
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">A = (tf.data.Dataset</code>
<code class="devsite-terminal" data-terminal-prefix="...">     .range(1, 5, output_type=tf.int32)</code>
<code class="devsite-terminal" data-terminal-prefix="...">     .map(lambda x: tf.fill([x], x)))</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;"># Pad to the smallest per-batch size that fits all elements.</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">B = A.padded_batch(2)</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">for element in B.as_numpy_iterator():</code>
<code class="devsite-terminal" data-terminal-prefix="...">  print(element)</code>
<code class="no-select nocode">[[1 0]</code>
<code class="no-select nocode"> [2 2]]</code>
<code class="no-select nocode">[[3 3 3 0]</code>
<code class="no-select nocode"> [4 4 4 4]]</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;"># Pad to a fixed size.</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">C = A.padded_batch(2, padded_shapes=5)</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">for element in C.as_numpy_iterator():</code>
<code class="devsite-terminal" data-terminal-prefix="...">  print(element)</code>
<code class="no-select nocode">[[1 0 0 0 0]</code>
<code class="no-select nocode"> [2 2 0 0 0]]</code>
<code class="no-select nocode">[[3 3 3 0 0]</code>
<code class="no-select nocode"> [4 4 4 4 0]]</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;"># Pad with a custom value.</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">D = A.padded_batch(2, padded_shapes=5, padding_values=-1)</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">for element in D.as_numpy_iterator():</code>
<code class="devsite-terminal" data-terminal-prefix="...">  print(element)</code>
<code class="no-select nocode">[[ 1 -1 -1 -1 -1]</code>
<code class="no-select nocode"> [ 2  2 -1 -1 -1]]</code>
<code class="no-select nocode">[[ 3  3  3 -1 -1]</code>
<code class="no-select nocode"> [ 4  4  4  4 -1]]</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;"># Components of nested elements can be padded independently.</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">elements = [([1, 2, 3], [10]),</code>
<code class="devsite-terminal" data-terminal-prefix="...">            ([4, 5], [11, 12])]</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">dataset = tf.data.Dataset.from_generator(</code>
<code class="devsite-terminal" data-terminal-prefix="...">    lambda: iter(elements), (tf.int32, tf.int32))</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;"># Pad the first component of the tuple to length 4, and the second</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;"># component to the smallest size that fits.</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">dataset = dataset.padded_batch(2,</code>
<code class="devsite-terminal" data-terminal-prefix="...">    padded_shapes=([4], [None]),</code>
<code class="devsite-terminal" data-terminal-prefix="...">    padding_values=(-1, 100))</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">list(dataset.as_numpy_iterator())</code>
<code class="no-select nocode">[(array([[ 1,  2,  3, -1], [ 4,  5, -1, -1]], dtype=int32),</code>
<code class="no-select nocode">  array([[ 10, 100], [ 11,  12]], dtype=int32))]</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;"># Pad with a single value and multiple components.</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">E = tf.data.Dataset.zip((A, A)).padded_batch(2, padding_values=-1)</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">for element in E.as_numpy_iterator():</code>
<code class="devsite-terminal" data-terminal-prefix="...">  print(element)</code>
<code class="no-select nocode">(array([[ 1, -1],</code>
<code class="no-select nocode">       [ 2,  2]], dtype=int32), array([[ 1, -1],</code>
<code class="no-select nocode">       [ 2,  2]], dtype=int32))</code>
<code class="no-select nocode">(array([[ 3,  3,  3, -1],</code>
<code class="no-select nocode">       [ 4,  4,  4,  4]], dtype=int32), array([[ 3,  3,  3, -1],</code>
<code class="no-select nocode">       [ 4,  4,  4,  4]], dtype=int32))</code>
</pre>


See also `tf.data.experimental.dense_to_sparse_batch`, which combines
elements that may have different shapes into a `tf.sparse.SparseTensor`.

<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Args</th></tr>

<tr>
<td>
`batch_size`
</td>
<td>
A `tf.int64` scalar `tf.Tensor`, representing the number of
consecutive elements of this dataset to combine in a single batch.
</td>
</tr><tr>
<td>
`padded_shapes`
</td>
<td>
(Optional.) A nested structure of `tf.TensorShape` or
`tf.int64` vector tensor-like objects representing the shape to which
the respective component of each input element should be padded prior
to batching. Any unknown dimensions will be padded to the maximum size
of that dimension in each batch. If unset, all dimensions of all
components are padded to the maximum size in the batch. `padded_shapes`
must be set if any component has an unknown rank.
</td>
</tr><tr>
<td>
`padding_values`
</td>
<td>
(Optional.) A nested structure of scalar-shaped
`tf.Tensor`, representing the padding values to use for the respective
components. None represents that the nested structure should be padded
with default values.  Defaults are `0` for numeric types and the empty
string for string types. The `padding_values` should have the
same structure as the input dataset. If `padding_values` is a single
element and the input dataset has multiple components, then the same
`padding_values` will be used to pad every component of the dataset.
If `padding_values` is a scalar, then its value will be broadcasted
to match the shape of each component.
</td>
</tr><tr>
<td>
`drop_remainder`
</td>
<td>
(Optional.) A `tf.bool` scalar `tf.Tensor`, representing
whether the last batch should be dropped in the case it has fewer than
`batch_size` elements; the default behavior is not to drop the smaller
batch.
</td>
</tr>
</table>



<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Returns</th></tr>

<tr>
<td>
`Dataset`
</td>
<td>
A `Dataset`.
</td>
</tr>
</table>



<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Raises</th></tr>

<tr>
<td>
`ValueError`
</td>
<td>
If a component has an unknown rank, and  the `padded_shapes`
argument is not set.
</td>
</tr>
</table>



<h3 id="prefetch"><code>prefetch</code></h3>

<pre class="devsite-click-to-copy prettyprint lang-py tfo-signature-link">
<code>prefetch(
    buffer_size
)
</code></pre>

Creates a `Dataset` that prefetches elements from this dataset.

Most dataset input pipelines should end with a call to `prefetch`. This
allows later elements to be prepared while the current element is being
processed. This often improves latency and throughput, at the cost of
using additional memory to store prefetched elements.

Note: Like other `Dataset` methods, prefetch operates on the
elements of the input dataset. It has no concept of examples vs. batches.
`examples.prefetch(2)` will prefetch two elements (2 examples),
while `examples.batch(20).prefetch(2)` will prefetch 2 elements
(2 batches, of 20 examples each).

<pre class="devsite-click-to-copy prettyprint lang-py">
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">dataset = tf.data.Dataset.range(3)</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">dataset = dataset.prefetch(2)</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">list(dataset.as_numpy_iterator())</code>
<code class="no-select nocode">[0, 1, 2]</code>
</pre>


<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Args</th></tr>

<tr>
<td>
`buffer_size`
</td>
<td>
A `tf.int64` scalar `tf.Tensor`, representing the maximum
number of elements that will be buffered when prefetching.
</td>
</tr>
</table>



<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Returns</th></tr>

<tr>
<td>
`Dataset`
</td>
<td>
A `Dataset`.
</td>
</tr>
</table>



<h3 id="range"><code>range</code></h3>

<pre class="devsite-click-to-copy prettyprint lang-py tfo-signature-link">
<code>@staticmethod</code>
<code>range(
    *args, **kwargs
)
</code></pre>

Creates a `Dataset` of a step-separated range of values.

<pre class="devsite-click-to-copy prettyprint lang-py">
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">list(Dataset.range(5).as_numpy_iterator())</code>
<code class="no-select nocode">[0, 1, 2, 3, 4]</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">list(Dataset.range(2, 5).as_numpy_iterator())</code>
<code class="no-select nocode">[2, 3, 4]</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">list(Dataset.range(1, 5, 2).as_numpy_iterator())</code>
<code class="no-select nocode">[1, 3]</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">list(Dataset.range(1, 5, -2).as_numpy_iterator())</code>
<code class="no-select nocode">[]</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">list(Dataset.range(5, 1).as_numpy_iterator())</code>
<code class="no-select nocode">[]</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">list(Dataset.range(5, 1, -2).as_numpy_iterator())</code>
<code class="no-select nocode">[5, 3]</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">list(Dataset.range(2, 5, output_type=tf.int32).as_numpy_iterator())</code>
<code class="no-select nocode">[2, 3, 4]</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">list(Dataset.range(1, 5, 2, output_type=tf.float32).as_numpy_iterator())</code>
<code class="no-select nocode">[1.0, 3.0]</code>
</pre>


<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Args</th></tr>

<tr>
<td>
`*args`
</td>
<td>
follows the same semantics as python's xrange.
len(args) == 1 -> start = 0, stop = args[0], step = 1.
len(args) == 2 -> start = args[0], stop = args[1], step = 1.
len(args) == 3 -> start = args[0], stop = args[1], step = args[2].
</td>
</tr><tr>
<td>
`**kwargs`
</td>
<td>

- output_type: Its expected dtype. (Optional, default: `tf.int64`).
</td>
</tr>
</table>



<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Returns</th></tr>

<tr>
<td>
`Dataset`
</td>
<td>
A `RangeDataset`.
</td>
</tr>
</table>



<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Raises</th></tr>

<tr>
<td>
`ValueError`
</td>
<td>
if len(args) == 0.
</td>
</tr>
</table>



<h3 id="reduce"><code>reduce</code></h3>

<pre class="devsite-click-to-copy prettyprint lang-py tfo-signature-link">
<code>reduce(
    initial_state, reduce_func
)
</code></pre>

Reduces the input dataset to a single element.

The transformation calls `reduce_func` successively on every element of
the input dataset until the dataset is exhausted, aggregating information in
its internal state. The `initial_state` argument is used for the initial
state and the final state is returned as the result.

<pre class="devsite-click-to-copy prettyprint lang-py">
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">tf.data.Dataset.range(5).reduce(np.int64(0), lambda x, _: x + 1).numpy()</code>
<code class="no-select nocode">5</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">tf.data.Dataset.range(5).reduce(np.int64(0), lambda x, y: x + y).numpy()</code>
<code class="no-select nocode">10</code>
</pre>


<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Args</th></tr>

<tr>
<td>
`initial_state`
</td>
<td>
An element representing the initial state of the
transformation.
</td>
</tr><tr>
<td>
`reduce_func`
</td>
<td>
A function that maps `(old_state, input_element)` to
`new_state`. It must take two arguments and return a new element
The structure of `new_state` must match the structure of
`initial_state`.
</td>
</tr>
</table>



<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Returns</th></tr>
<tr class="alt">
<td colspan="2">
A dataset element corresponding to the final state of the transformation.
</td>
</tr>

</table>



<h3 id="repeat"><code>repeat</code></h3>

<pre class="devsite-click-to-copy prettyprint lang-py tfo-signature-link">
<code>repeat(
    count=None
)
</code></pre>

Repeats this dataset so each original value is seen `count` times.

<pre class="devsite-click-to-copy prettyprint lang-py">
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">dataset = tf.data.Dataset.from_tensor_slices([1, 2, 3])</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">dataset = dataset.repeat(3)</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">list(dataset.as_numpy_iterator())</code>
<code class="no-select nocode">[1, 2, 3, 1, 2, 3, 1, 2, 3]</code>
</pre>


Note: If this dataset is a function of global state (e.g. a random number
generator), then different repetitions may produce different elements.

<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Args</th></tr>

<tr>
<td>
`count`
</td>
<td>
(Optional.) A `tf.int64` scalar `tf.Tensor`, representing the
number of times the dataset should be repeated. The default behavior (if
`count` is `None` or `-1`) is for the dataset be repeated indefinitely.
</td>
</tr>
</table>



<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Returns</th></tr>

<tr>
<td>
`Dataset`
</td>
<td>
A `Dataset`.
</td>
</tr>
</table>



<h3 id="shard"><code>shard</code></h3>

<pre class="devsite-click-to-copy prettyprint lang-py tfo-signature-link">
<code>shard(
    num_shards, index
)
</code></pre>

Creates a `Dataset` that includes only 1/`num_shards` of this dataset.

`shard` is deterministic. The Dataset produced by `A.shard(n, i)` will
contain all elements of A whose index mod n = i.

<pre class="devsite-click-to-copy prettyprint lang-py">
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">A = tf.data.Dataset.range(10)</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">B = A.shard(num_shards=3, index=0)</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">list(B.as_numpy_iterator())</code>
<code class="no-select nocode">[0, 3, 6, 9]</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">C = A.shard(num_shards=3, index=1)</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">list(C.as_numpy_iterator())</code>
<code class="no-select nocode">[1, 4, 7]</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">D = A.shard(num_shards=3, index=2)</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">list(D.as_numpy_iterator())</code>
<code class="no-select nocode">[2, 5, 8]</code>
</pre>


This dataset operator is very useful when running distributed training, as
it allows each worker to read a unique subset.

When reading a single input file, you can shard elements as follows:

```python
d = tf.data.TFRecordDataset(input_file)
d = d.shard(num_workers, worker_index)
d = d.repeat(num_epochs)
d = d.shuffle(shuffle_buffer_size)
d = d.map(parser_fn, num_parallel_calls=num_map_threads)

গুরুত্বপূর্ণ সতর্কতা:

  • কোনও যেকোন র্যান্ডমাইজিং অপারেটর ব্যবহার করার আগে (যেমন বদলানো) তীক্ষ্ণ হওয়ার বিষয়টি নিশ্চিত করুন।
  • সাধারণত ডার্সেট পাইপলাইনে শারড অপারেটরটি প্রথম দিকে ব্যবহার করা ভাল। উদাহরণস্বরূপ, TFRecord ফাইলের সেট থেকে পড়ার সময় ডেটাসেটকে ইনপুট নমুনায় রূপান্তর করার আগে তীক্ষ্ণ। এটি প্রতিটি কর্মীর প্রতিটি ফাইল পড়া এড়ানো যায়। নিম্নলিখিতটি একটি সম্পূর্ণ পাইপলাইনের মধ্যে দক্ষ শর্ডিং কৌশলটির একটি উদাহরণ:
d = Dataset.list_files(pattern)
d = d.shard(num_workers, worker_index)
d = d.repeat(num_epochs)
d = d.shuffle(shuffle_buffer_size)
d = d.interleave(tf.data.TFRecordDataset,
                 cycle_length=num_readers, block_length=1)
d = d.map(parser_fn, num_parallel_calls=num_map_threads)

args
num_shards একটি tf.int64 স্কেলার tf.Tensor , সমান্তরালভাবে পরিচালিত tf.Tensor সংখ্যা উপস্থাপন করে।
index একটি tf.int64 স্কেলার tf.Tensor , কর্মী সূচকের প্রতিনিধিত্ব করে।

রিটার্নস
Dataset একটি Dataset

উত্থাপন
InvalidArgumentError যদি num_shards বা index অবৈধ মান হয়।

shuffle

এলোমেলোভাবে এই ডেটাসেটের উপাদানগুলি পরিবর্তন করে।

এই ডেটাসেটটি buffer_size উপাদানগুলির সাথে একটি বাফার পূরণ করে, তারপরে এই বাফার থেকে এলোমেলোভাবে উপাদানগুলি নমুনা করে, নির্বাচিত উপাদানগুলিকে নতুন উপাদানগুলির সাথে প্রতিস্থাপন করে। নিখুঁত বদলানোর জন্য, ডেটাসেটের পূর্ণ আকারের চেয়ে বড় বা সমান বাফার আকার প্রয়োজন।

উদাহরণস্বরূপ, যদি আপনার ডেটা সেটটি 10,000 উপাদানগুলি রয়েছে কিন্তু buffer_size 1,000 সেট করা হয়, তারপর shuffle প্রাথমিকভাবে বাফারে শুধুমাত্র প্রথম 1,000 উপাদান থেকে একটি র্যান্ডম উপাদান নির্বাচন করব। একবার একটি উপাদান নির্বাচন করা হলে, বাফারের মধ্যে তার স্থানটি পরবর্তী (অর্থাত্ 1,001-st) উপাদান দ্বারা প্রতিস্থাপিত হবে, 1,000 এলিমেন্ট বাফারটি বজায় রাখবে।

reshuffle_each_iteration প্রতিটি যুগের জন্য শফলের ক্রম আলাদা হওয়া উচিত কিনা তা নিয়ন্ত্রণ করে। টিএফ ১. এক্স-এ, মহাবিশ্ব তৈরির অভিজাত পদ্ধতিটি repeat রূপান্তরটির মাধ্যমে হয়েছিল:

dataset = tf.data.Dataset.range(3)
dataset = dataset.shuffle(3, reshuffle_each_iteration=True)
dataset = dataset.repeat(2)  # doctest: +SKIP
[1, 0, 2, 1, 2, 0]
বি 724386693

টিএফ ২.০-তে, tf.data.Dataset অবজেক্টগুলি পাইথন পুনরাবৃত্ত হয় যা পাইথনের পুনরাবৃত্তির মাধ্যমে পর্বগুলি তৈরি করাও সম্ভব করে তোলে:

dataset = tf.data.Dataset.range(3)
dataset = dataset.shuffle(3, reshuffle_each_iteration=True)
list(dataset.as_numpy_iterator())  # doctest: +SKIP
[1, 0, 2]
list(dataset.as_numpy_iterator())  # doctest: +SKIP
[1, 2, 0]
dataset = tf.data.Dataset.range(3)
dataset = dataset.shuffle(3, reshuffle_each_iteration=False)
list(dataset.as_numpy_iterator())  # doctest: +SKIP
[1, 0, 2]
list(dataset.as_numpy_iterator())  # doctest: +SKIP
[1, 0, 2]

args
buffer_size একটি tf.int64 স্কেলার tf.Tensor , এই ডেটাসেট থেকে উপাদানগুলির সংখ্যার প্রতিনিধিত্ব করে যা থেকে নতুন ডেটাসেট নমুনা দেবে।
seed ( tf.int64 ।) একটি tf.int64 স্কেলার tf.Tensor , এলোমেলো বীজ উপস্থাপন করে যা বিতরণ তৈরি করতে ব্যবহৃত হবে। আচরণের জন্য tf.random.set_seed দেখুন।
reshuffle_each_iteration (Alচ্ছিক) ( True ডিফল্ট।)

রিটার্নস
Dataset একটি Dataset

skip

একটি Dataset তৈরি করে যা এই ডেটাসেট থেকে উপাদান count এড়িয়ে যায়।

dataset = tf.data.Dataset.range(10)
dataset = dataset.skip(7)
list(dataset.as_numpy_iterator())
[7, 8, 9]

args
count একটি tf.int64 স্কেলার tf.Tensor , এই ডেটাসেটের উপাদানগুলির সংখ্যা উপস্থাপন করে যা নতুন ডেটাসেট গঠন করতে tf.Tensor হবে। যদি count এই ডেটাসেটের আকারের চেয়ে বেশি হয় তবে নতুন ডেটাসেটে কোনও উপাদান থাকবে না। যদি count -1 হয়, সম্পূর্ণ ডেটাসেটটি এড়িয়ে যায়।

রিটার্নস
Dataset একটি Dataset

stream

উৎস দেখুন

ব্যবহারের জন্য একটি পুনরাবৃত্তযোগ্য স্ট্রিমআইওডিট্যাসেট পান।

রিটার্নস
StreamIODataset একটি শ্রেণি।

take

এই ডেটাসেট থেকে সর্বাধিক count উপাদানগুলির সাথে একটি Dataset তৈরি করে।

dataset = tf.data.Dataset.range(10)
dataset = dataset.take(3)
list(dataset.as_numpy_iterator())
[0, 1, 2]

args
count একটি tf.int64 স্কেলার tf.Tensor , এই ডেটাসেটের উপাদানগুলির সংখ্যা উপস্থাপন করে যা নতুন ডেটাসেট গঠনের জন্য নেওয়া উচিত। যদি count -1 হয়, বা যদি এই ডেটাসেটের আকারের চেয়ে বেশি count হয় তবে নতুন ডেটাসেটে এই ডেটাসেটের সমস্ত উপাদান থাকবে।

রিটার্নস
Dataset একটি Dataset

to_file

উৎস দেখুন

একটি ফাইলে ডেটাसेट লিখুন।

args
dataset এমন একটি ডেটাসেট যার লিখিত সামগ্রীতে লেখা হবে।
filename একটি স্ট্রিং, ফাইলটির ফাইলের নাম লিখতে হবে।
name IODataset (alচ্ছিক) এর একটি নামের উপসর্গ।

রিটার্নস
রেকর্ড সংখ্যা।

unbatch

একটি ডেটাসেটের উপাদানগুলি একাধিক উপাদানগুলিতে বিভক্ত করে।

উদাহরণস্বরূপ, যদি ডেটাসেটের উপাদানগুলি [B, a0, a1, ...] আকারযুক্ত হয়, যেখানে B প্রতিটি ইনপুট উপাদানগুলির জন্য B পরিবর্তিত হতে পারে, তবে ডেটাসেটের প্রতিটি উপাদানগুলির জন্য, আনব্যাচড ডেটাসেটে B ধারাবাহিক আকারের আকৃতি থাকবে [a0, a1, ...]

elements = [ [1, 2, 3], [1, 2], [1, 2, 3, 4] ]
dataset = tf.data.Dataset.from_generator(lambda: elements, tf.int64)
dataset = dataset.unbatch()
list(dataset.as_numpy_iterator())
[1, 2, 3, 1, 2, 1, 2, 3, 4]

রিটার্নস
একটি Dataset

window

উইন্ডোজের (নীড়ের) ডেটাসেটে ইনপুট উপাদানগুলিকে (বাসাগুলির) একত্রিত করে।

একটি "জানালা" আকারের ফ্ল্যাট উপাদানের একটি সসীম ডেটা সেটটি হয় size (অথবা সম্ভবত তার চেয়ে কম হলে সেখানে যথেষ্ট ইনপুট উপাদানের উইন্ডো এবং ভরাট নয় drop_remainder মূল্যায়ণ False )।

shift আর্গুমেন্ট ইনপুট উপাদানগুলির সংখ্যা নির্ধারণ করে যার দ্বারা উইন্ডো প্রতিটি পুনরাবৃত্তির উপরে চলে যায়। যদি উইন্ডো এবং উপাদানগুলি উভয়ই 0 থেকে শুরু করে সংখ্যাযুক্ত হয় তবে উইন্ডো k প্রথম উপাদানটি ইনপুট ডেটাসেটের এলিমেন্ট k * shift । বিশেষত, প্রথম উইন্ডোর প্রথম উপাদানটি সর্বদা ইনপুট ডেটাসেটের প্রথম উপাদান হবে।

stride আর্গুমেন্ট ইনপুট উপাদানের স্ট্রাইড নির্ধারণ করে এবং shift আর্গুমেন্টটি উইন্ডোটির শিফট নির্ধারণ করে।

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

dataset = tf.data.Dataset.range(7).window(2)
for window in dataset:
  print(list(window.as_numpy_iterator()))
[0, 1]
[2, 3]
[4, 5]
[6]
dataset = tf.data.Dataset.range(7).window(3, 2, 1, True)
for window in dataset:
  print(list(window.as_numpy_iterator()))
[0, 1, 2]
[2, 3, 4]
[4, 5, 6]
dataset = tf.data.Dataset.range(7).window(3, 1, 2, True)
for window in dataset:
  print(list(window.as_numpy_iterator()))
[0, 2, 4]
[1, 3, 5]
[2, 4, 6]

নোট করুন যে যখন window ট্রান্সফর্মেশনটি নেস্টেড উপাদানগুলির একটি ডেটাসেটে প্রয়োগ করা হয়, তখন এটি নেস্টেড উইন্ডোগুলির একটি ডেটাसेट তৈরি করে।

nested = ([1, 2, 3, 4], [5, 6, 7, 8])
dataset = tf.data.Dataset.from_tensor_slices(nested).window(2)
for window in dataset:
  def to_numpy(ds):
    return list(ds.as_numpy_iterator())
  print(tuple(to_numpy(component) for component in window))
([1, 2], [5, 6])
([3, 4], [7, 8])
dataset = tf.data.Dataset.from_tensor_slices({'a': [1, 2, 3, 4]})
dataset = dataset.window(2)
for window in dataset:
  def to_numpy(ds):
    return list(ds.as_numpy_iterator())
  print({'a': to_numpy(window['a'])})
{'a': [1, 2]}
{'a': [3, 4]}

args
size একটি tf.int64 স্কেলার tf.Tensor , উইন্ডোতে একত্রিত করতে ইনপুট ডেটাসেটের উপাদানগুলির সংখ্যা উপস্থাপন করে। ইতিবাচক হতে হবে।
shift ( tf.int64 ।) একটি tf.int64 স্কেলার tf.Tensor , ইনপুট উপাদানের সংখ্যা প্রতিনিধিত্ব করে যার দ্বারা উইন্ডো প্রতিটি পুনরাবৃত্তিতে সরানো হয়। size ডিফল্ট। ইতিবাচক হতে হবে।
stride (ঐচ্ছিক।) একটি tf.int64 স্কালে tf.Tensor , সহচরী উইন্ডোতে ইনপুট উপাদানের দীর্ঘ উপস্থাপন করে। ইতিবাচক হতে হবে। ডিফল্ট মান 1 এর অর্থ "প্রতিটি ইনপুট উপাদান ধরে রাখা"।
drop_remainder (ঐচ্ছিক।) একটি tf.bool স্কালে tf.Tensor , প্রতিনিধিত্বমূলক কিনা অন্তিম উইন্ডোটি যদি তার আকার চেয়ে ছোট বাদ দিতে হবে size

রিটার্নস
Dataset একটি Dataset এর (এর বাসা) উইন্ডোজ - ইনপুট উপাদানের (এর বাসা) থেকে নির্মিত ফ্ল্যাট উপাদানের একটি সসীম ডেটাসেট।

with_options

প্রদত্ত বিকল্পগুলির সেট সহ একটি নতুন tf.data.Dataset প্রদান করে।

অপশনগুলি "গ্লোবাল" সেই অর্থে যেগুলি পুরো ডেটাসেটে প্রয়োগ করে। যদি বিকল্পগুলি একাধিকবার সেট করা থাকে, ততক্ষণ এগুলি একত্রীকরণ করা হবে যতক্ষণ না বিভিন্ন বিকল্পগুলি ভিন্ন অ-ডিফল্ট মান ব্যবহার করে না।

ds = tf.data.Dataset.range(5)
ds = ds.interleave(lambda x: tf.data.Dataset.range(5),
                   cycle_length=3,
                   num_parallel_calls=3)
options = tf.data.Options()
# This will make the interleave order non-deterministic.
options.experimental_deterministic = False
ds = ds.with_options(options)

args
options একটি tf.data.Options যা ব্যবহার বিকল্পগুলি সনাক্ত করে।

রিটার্নস
Dataset প্রদত্ত বিকল্পগুলির সাথে একটি Dataset

উত্থাপন
ValueError যখন কোনও বিকল্প কোনও ডিফল্ট মানের জন্য একাধিকবার সেট করা থাকে

zip

প্রদত্ত ডেটাসেট একসাথে জিপ করে একটি Dataset তৈরি করে।

পাইথনের বিল্ট-ইন zip() ফাংশনের সাথে এই পদ্ধতিটির একই শব্দার্থকতা রয়েছে, মূল পার্থক্যটি হ'ল datasets আর্গুমেন্টটি Dataset অবজেক্টগুলির একটি নির্বিচারে নেস্টেড কাঠামো হতে পারে।

# The nested structure of the `datasets` argument determines the
# structure of elements in the resulting dataset.
a = tf.data.Dataset.range(1, 4)  # ==> [ 1, 2, 3 ]
b = tf.data.Dataset.range(4, 7)  # ==> [ 4, 5, 6 ]
ds = tf.data.Dataset.zip((a, b))
list(ds.as_numpy_iterator())
[(1, 4), (2, 5), (3, 6)]
ds = tf.data.Dataset.zip((b, a))
list(ds.as_numpy_iterator())
[(4, 1), (5, 2), (6, 3)]

# The `datasets` argument may contain an arbitrary number of datasets.
c = tf.data.Dataset.range(7, 13).batch(2)  # ==> [ [7, 8],
                                           #       [9, 10],
                                           #       [11, 12] ]
ds = tf.data.Dataset.zip((a, b, c))
for element in ds.as_numpy_iterator():
  print(element)
(1, 4, array([7, 8]))
(2, 5, array([ 9, 10]))
(3, 6, array([11, 12]))

# The number of elements in the resulting dataset is the same as
# the size of the smallest dataset in `datasets`.
d = tf.data.Dataset.range(13, 15)  # ==> [ 13, 14 ]
ds = tf.data.Dataset.zip((a, d))
list(ds.as_numpy_iterator())
[(1, 13), (2, 14)]

args
datasets ডেটাসেটগুলির একটি নেস্টেড কাঠামো।

রিটার্নস
Dataset একটি Dataset

__bool__

__iter__

এই ডেটাসেটের উপাদানগুলির জন্য একটি পুনরুক্তি তৈরি করে।

প্রত্যাবর্তিত পুনরাবৃত্তকারী পাইথন ইটারেটর প্রোটোকল প্রয়োগ করে।

রিটার্নস
এই ডেটাসেটের উপাদানগুলির জন্য একটি tf.data.Iterator

উত্থাপন
RuntimeError Tf.function এর ভিতরে না হলে এবং উত্সাহিতভাবে কার্যকর করা না।

__len__

ডেটাসেটের দৈর্ঘ্য যদি এটি জানা থাকে এবং সসীম হয় তবে তা ফিরিয়ে দেয়।

এই পদ্ধতির জন্য আপনি উত্সাহী মোডে চলছেন এবং ডেটাসেটের দৈর্ঘ্য জানা এবং অসীম নয়। যখন দৈর্ঘ্যটি অজানা বা অসীম হতে পারে, বা আপনি গ্রাফ মোডে tf.data.Dataset.cardinality পরিবর্তে tf.data.Dataset.cardinality ব্যবহার করুন।

রিটার্নস
একটি পূর্ণসংখ্যা যা ডেটাসেটের দৈর্ঘ্যের প্রতিনিধিত্ব করে।

উত্থাপন
RuntimeError যদি ডেটাসেটের দৈর্ঘ্য অজানা বা অসীম হয়, বা আগ্রহী এক্সিকিউশন সক্ষম না হয়।

__nonzero__