TFDS এখন Croissant 🥐 ফরম্যাট সমর্থন করে! আরও জানতে ডকুমেন্টেশন পড়ুন।

এই পৃষ্ঠাটি Cloud Translation API অনুবাদ করেছে।

TFDS এবং নির্ণয়বাদ

TensorFlow.org-এ দেখুন

Google Colab-এ চালান

GitHub এ দেখুন

নোটবুক ডাউনলোড করুন

এই নথি ব্যাখ্যা করে:

TFDS নির্ণয়বাদের গ্যারান্টি দেয়
কোন ক্রমে TFDS উদাহরণ পড়ে
বিভিন্ন সতর্কতা এবং গোটচা

সেটআপ

ডেটাসেট

TFDS কীভাবে ডেটা পড়ে তা বোঝার জন্য কিছু প্রসঙ্গ প্রয়োজন।

প্রজন্মের সময় TFDS আদর্শায়িত মধ্যে মূল ডেটা লিখতে .tfrecord ফাইল। বড় ডেটাসেট জন্য, একাধিক .tfrecord ফাইল তৈরি করা হয়, প্রতিটি একাধিক উদাহরণ রয়েছে। আমরা কল প্রতিটি .tfrecord একটি ঠিকরা দায়ের।

এই নির্দেশিকাটি ইমেজনেট ব্যবহার করে যার 1024টি শার্ড রয়েছে:

import re
import tensorflow_datasets as tfds

imagenet = tfds.builder('imagenet2012')

num_shards = imagenet.info.splits['train'].num_shards
num_examples = imagenet.info.splits['train'].num_examples
print(f'imagenet has {num_shards} shards ({num_examples} examples)')

imagenet has 1024 shards (1281167 examples)

ডেটাসেট উদাহরণ আইডি খোঁজা

আপনি যদি কেবলমাত্র নির্ধারণবাদ সম্পর্কে জানতে চান তবে আপনি নিম্নলিখিত বিভাগে এড়িয়ে যেতে পারেন।

প্রতিটি ডেটা সেটটি উদাহরণ স্বতন্ত্র একটি দ্বারা চিহ্নিত করা হয় id (যেমন 'imagenet2012-train.tfrecord-01023-of-01024__32' )। আপনি এই পুনরুদ্ধার করতে পারেন id ক্ষণস্থায়ী দ্বারা read_config.add_tfds_id = True যা যোগ হবে 'tfds_id' থেকে অভি কী tf.data.Dataset ।

এই টিউটোরিয়ালে, আমরা একটি ছোট util সংজ্ঞায়িত করেছি যা ডেটাসেটের উদাহরণ আইডি প্রিন্ট করবে (আরও মানব-পাঠযোগ্য হতে পূর্ণসংখ্যাতে রূপান্তরিত):

def load_dataset(builder, **as_dataset_kwargs):
  """Load the dataset with the tfds_id."""
  read_config = as_dataset_kwargs.pop('read_config', tfds.ReadConfig())
  read_config.add_tfds_id = True  # Set `True` to return the 'tfds_id' key
  return builder.as_dataset(read_config=read_config, **as_dataset_kwargs)

def print_ex_ids(
    builder,
    *,
    take: int,
    skip: int = None,
    **as_dataset_kwargs,
) -> None:
  """Print the example ids from the given dataset split."""
  ds = load_dataset(builder, **as_dataset_kwargs)
  if skip:
    ds = ds.skip(skip)
  ds = ds.take(take)
  exs = [ex['tfds_id'].numpy().decode('utf-8') for ex in ds]
  exs = [id_to_int(tfds_id, builder=builder) for tfds_id in exs]
  print(exs)

def id_to_int(tfds_id: str, builder) -> str:
  """Format the tfds_id in a more human-readable."""
  match = re.match(r'\w+-(\w+).\w+-(\d+)-of-\d+__(\d+)', tfds_id)
  split_name, shard_id, ex_id = match.groups()
  split_info = builder.info.splits[split_name]
  return sum(split_info.shard_lengths[:int(shard_id)]) + int(ex_id)

পড়ার সময় নির্ণয়বাদ

এই বিভাগের deterministim গ্যারান্টি ব্যাখ্যা tfds.load ।

সঙ্গে `shuffle_files=False` (ডিফল্ট)

ডিফল্ট TFDS deterministically উদাহরণ উত্পাদ মাধ্যমে ( shuffle_files=False )

# Same as: imagenet.as_dataset(split='train').take(20)
print_ex_ids(imagenet, split='train', take=20)
print_ex_ids(imagenet, split='train', take=20)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 1251, 1252, 1253, 1254]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 1251, 1252, 1253, 1254]

কর্মক্ষমতা জন্য, TFDS ব্যবহার করে একই সময়ে একাধিক shards পড়া tf.data.Dataset.interleave । আমরা এই উদাহরণে দেখতে যে TFDS 16 উদাহরণ পড়ার পর ঠিকরা 2 স্যুইচ ( ..., 14, 15, 1251, 1252, ... )। নিচে ইন্টারলিভের উপর আরো।

একইভাবে, সাবস্প্লিট এপিআইও নির্ধারক:

print_ex_ids(imagenet, split='train[67%:84%]', take=20)
print_ex_ids(imagenet, split='train[67%:84%]', take=20)

[858382, 858383, 858384, 858385, 858386, 858387, 858388, 858389, 858390, 858391, 858392, 858393, 858394, 858395, 858396, 858397, 859533, 859534, 859535, 859536]
[858382, 858383, 858384, 858385, 858386, 858387, 858388, 858389, 858390, 858391, 858392, 858393, 858394, 858395, 858396, 858397, 859533, 859534, 859535, 859536]

আপনি যদি একটির বেশি যুগান্তকারী করুন না প্রশিক্ষণ, উপরে সেটআপ বাঞ্ছনীয় নয় হিসাবে সব সময়কাল একই আদেশ shards পড়তে হবে (তাই যদৃচ্ছতা সীমাবদ্ধ ds = ds.shuffle(buffer) মাপের বাফার)।

সঙ্গে `shuffle_files=True`

সঙ্গে shuffle_files=True , shards প্রতিটি যুগে জন্য, এলোমেলো হয়, তাই পড়া আর নির্ণায়ক নয়।

print_ex_ids(imagenet, split='train', shuffle_files=True, take=20)
print_ex_ids(imagenet, split='train', shuffle_files=True, take=20)

[568017, 329050, 329051, 329052, 329053, 329054, 329056, 329055, 568019, 568020, 568021, 568022, 568023, 568018, 568025, 568024, 568026, 568028, 568030, 568031]
[43790, 43791, 43792, 43793, 43796, 43794, 43797, 43798, 43795, 43799, 43800, 43801, 43802, 43803, 43804, 43805, 43806, 43807, 43809, 43810]

ডিটারমিনিস্টিক ফাইল শাফলিং পেতে নীচের রেসিপিটি দেখুন।

ডিটারমিনিজম সতর্কতা: ইন্টারলিভ আর্গস

পরিবর্তন read_config.interleave_cycle_length , read_config.interleave_block_length উদাহরণ অর্ডার পরিবর্তন করতে হবে।

TFDS উপর নির্ভর tf.data.Dataset.interleave শুধুমাত্র একবারে কয়েক shards লোড করতে কর্মক্ষমতা উন্নত করতে এবং মেমরি ব্যবহার কমে যায়।

উদাহরণের ক্রমটি শুধুমাত্র ইন্টারলিভ আর্গের একটি নির্দিষ্ট মানের জন্য একই হওয়ার গ্যারান্টি দেওয়া হয়। দেখুন ইন্টারলিভ ডক কি বুঝতে cycle_length এবং block_length মিলা খুব।

cycle_length=16 , block_length=16 (ডিফল্ট, উপরোক্ত হিসাবে একই):

print_ex_ids(imagenet, split='train', take=20)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 1251, 1252, 1253, 1254]

cycle_length=3 , block_length=2 :

read_config = tfds.ReadConfig(
    interleave_cycle_length=3,
    interleave_block_length=2,
)
print_ex_ids(imagenet, split='train', read_config=read_config, take=20)

[0, 1, 1251, 1252, 2502, 2503, 2, 3, 1253, 1254, 2504, 2505, 4, 5, 1255, 1256, 2506, 2507, 6, 7]

দ্বিতীয় উদাহরণে, আমরা দেখতে যে ডেটা সেটটি 2 (পড়া block_length=2 একটি ঠিকরা মধ্যে) উদাহরণ, তারপর পরবর্তী ঠিকরা স্যুইচ করুন। প্রতি 2 * 3 ( cycle_length=3 ) উদাহরণ, এটা ফেরত প্রথম ঠিকরা (যায় shard0-ex0, shard0-ex1, shard1-ex0, shard1-ex1, shard2-ex0, shard2-ex1, shard0-ex2, shard0-ex3, shard1-ex2, shard1-ex3, shard2-ex2,... )।

সাবপ্লিট এবং উদাহরণ ক্রম

প্রতিটি উদাহরণ একটি আইডি আছে 0, 1, ..., num_examples-1 । Subsplit এপিআই (যেমন উদাহরণ একটি ফালি নির্বাচন train[:x] নির্বাচন 0, 1, ..., x-1 )।

যাইহোক, সাবস্প্লিটের মধ্যে, ক্রমবর্ধমান আইডি অর্ডারে উদাহরণগুলি পড়া হয় না (শার্ড এবং ইন্টারলিভের কারণে)।

আরো নির্দিষ্টভাবে, ds.take(x) এবং split='train[:x]' সমতুল্য নয়!

উপরের ইন্টারলেভ উদাহরণে এটি সহজেই দেখা যায় যেখানে উদাহরণগুলি বিভিন্ন শার্ড থেকে আসে।

print_ex_ids(imagenet, split='train', take=25)  # tfds.load(..., split='train').take(25)
print_ex_ids(imagenet, split='train[:25]', take=-1)  # tfds.load(..., split='train[:25]')

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 1251, 1252, 1253, 1254, 1255, 1256, 1257, 1258, 1259]
[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]

16 (block_length) উদাহরণ পর .take(25) পরবর্তী ঠিকরা পরিবর্তন যখন train[:25] প্রথম ঠিকরা থেকে উদাহরণ পড়া চালিয়ে যান।

রেসিপি

ডিটারমিনিস্টিক ফাইল শাফলিং পান

ডিটারমিনিস্টিক শাফলিং করার 2টি উপায় রয়েছে:

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

read_config = tfds.ReadConfig(
    shuffle_seed=32,
)

# Deterministic order, different from the default shuffle_files=False above
print_ex_ids(imagenet, split='train', shuffle_files=True, read_config=read_config, take=22)
print_ex_ids(imagenet, split='train', shuffle_files=True, read_config=read_config, take=22)

[176411, 176412, 176413, 176414, 176415, 176416, 176417, 176418, 176419, 176420, 176421, 176422, 176423, 176424, 176425, 176426, 710647, 710648, 710649, 710650, 710651, 710652]
[176411, 176412, 176413, 176414, 176415, 176416, 176417, 176418, 176419, 176420, 176421, 176422, 176423, 176424, 176425, 176426, 710647, 710648, 710649, 710650, 710651, 710652]

ব্যবহার experimental_interleave_sort_fn এই পূর্ণ নিয়ন্ত্রণ যার উপর shards পড়া হয় এবং যা অনুক্রমে, বরং উপর ভরসা করার চেয়ে দেয় ds.shuffle অর্ডার।

def _reverse_order(file_instructions):
  return list(reversed(file_instructions))

read_config = tfds.ReadConfig(
    experimental_interleave_sort_fn=_reverse_order,
)

# Last shard (01023-of-01024) is read first
print_ex_ids(imagenet, split='train', read_config=read_config, take=5)

[1279916, 1279917, 1279918, 1279919, 1279920]

নির্ধারক অগ্রিম পাইপলাইন পান

এই এক আরো জটিল. কোন সহজ, সন্তোষজনক সমাধান নেই।

ছাড়া ds.shuffle এবং নির্ণায়ক প্রকাশের shuffling সঙ্গে, তত্ত্ব এটা উদাহরণ যা পড়া হয়েছে এবং অনুমান যা উদাহরণ প্রতিটি ঠিকরা মধ্যে মধ্যে পড়তে হয়েছে গণনা (এর কার্যকারিতা হিসেবে সম্ভব হওয়া উচিত cycle_length , block_length এবং ঠিকরা অর্ডার)। তারপর skip , take প্রতিটি ঠিকরা জন্য মাধ্যমে ইনজেকশনের যেতে পারে experimental_interleave_sort_fn ।
সঙ্গে ds.shuffle এটি সম্ভবত সম্পূর্ণ প্রশিক্ষণ পাইপলাইন replaying ছাড়া অসম্ভব। সংরক্ষণ করতে হবে ds.shuffle অনুমান করতে বাফার রাষ্ট্র যা উদাহরণ পড়া হয়েছে। উদাহরণ অ ক্রমাগত হতে পারে (যেমন shard5_ex2 , shard5_ex4 পড়া কিন্তু shard5_ex3 )।
সঙ্গে ds.shuffle , এক পথ সব shards_ids / example_ids (থেকে অনুমিত পড়ি সংরক্ষণ করতে হবে tfds_id ,) তারপর যে থেকে ফাইল নির্দেশাবলী deducing।

জন্য সহজ ক্ষেত্রে 1. করতে হবে তা হল .skip(x).take(y) ম্যাচ train[x:x+y] ম্যাচ। এটি প্রয়োজন:

সেট cycle_length=1 (তাই shards ক্রমানুসারে পড়া হয়)
সেট shuffle_files=False
ব্যবহার করবেন না ds.shuffle

এটি শুধুমাত্র বিশাল ডেটাসেটে ব্যবহার করা উচিত যেখানে প্রশিক্ষণ মাত্র 1 যুগ। উদাহরণগুলি ডিফল্ট শাফেল ক্রমে পড়া হবে।

read_config = tfds.ReadConfig(
    interleave_cycle_length=1,  # Read shards sequentially
)

print_ex_ids(imagenet, split='train', read_config=read_config, skip=40, take=22)
# If the job get pre-empted, using the subsplit API will skip at most `len(shard0)`
print_ex_ids(imagenet, split='train[40:]', read_config=read_config, take=22)

[40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61]
[40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61]

প্রদত্ত সাবস্প্লিটের জন্য কোন শার্ড/উদাহরণগুলি পড়া হয় তা খুঁজুন

সঙ্গে tfds.core.DatasetInfo , আপনি পড়তে নির্দেশাবলী সরাসরি এক্সেস আছে।

imagenet.info.splits['train[44%:45%]'].file_instructions

[FileInstruction(filename='imagenet2012-train.tfrecord-00450-of-01024', skip=700, take=-1, num_examples=551),
 FileInstruction(filename='imagenet2012-train.tfrecord-00451-of-01024', skip=0, take=-1, num_examples=1251),
 FileInstruction(filename='imagenet2012-train.tfrecord-00452-of-01024', skip=0, take=-1, num_examples=1251),
 FileInstruction(filename='imagenet2012-train.tfrecord-00453-of-01024', skip=0, take=-1, num_examples=1251),
 FileInstruction(filename='imagenet2012-train.tfrecord-00454-of-01024', skip=0, take=-1, num_examples=1252),
 FileInstruction(filename='imagenet2012-train.tfrecord-00455-of-01024', skip=0, take=-1, num_examples=1251),
 FileInstruction(filename='imagenet2012-train.tfrecord-00456-of-01024', skip=0, take=-1, num_examples=1251),
 FileInstruction(filename='imagenet2012-train.tfrecord-00457-of-01024', skip=0, take=-1, num_examples=1251),
 FileInstruction(filename='imagenet2012-train.tfrecord-00458-of-01024', skip=0, take=-1, num_examples=1251),
 FileInstruction(filename='imagenet2012-train.tfrecord-00459-of-01024', skip=0, take=-1, num_examples=1251),
 FileInstruction(filename='imagenet2012-train.tfrecord-00460-of-01024', skip=0, take=1001, num_examples=1001)]