Tensorflow操作，用于在单个会话提要中组合迭代器字符串句柄

我希望以一种使用数据api且不会导致张量泄漏（即随时间增加图形操作数）的方式，使用多个数据集的不同组合生成小批量。例如，小批量1可能是

a1、a2、b1、b2

，然后是

a3、a4、c1、c2的小批量2

是否可以通过“字符串句柄feed_dict方法”在多个初始化的数据集迭代器上运行单个会话（请参见feedableat）。是否存在组合两个Iterator.string\u句柄对象的操作？下面我有一个简单的工作示例，它显示了sys.exit结束后的问题

import tensorflow as tf  # v.1.4
import sys

# Predetermine minibatch size.
num_per_class = 6

# Create example datasets.
ds0 = tf.data.Dataset.range(0, 100, 2)
ds1 = tf.data.Dataset.range(1, 101, 2)

# Minibatchify. Note: could use adjustable tensor for minibatch size.
ds0 = ds0.apply(tf.contrib.data.batch_and_drop_remainder(num_per_class))
ds1 = ds1.apply(tf.contrib.data.batch_and_drop_remainder(num_per_class))

# Run forever.
ds0 = ds0.repeat()
ds1 = ds1.repeat()

# Dataset iterators.
ds0_itr = ds0.make_initializable_iterator()
ds1_itr = ds1.make_initializable_iterator()

# Switcher handle placeholder, iterator and ultimate minibatch datums.
switcher_h = tf.placeholder(tf.string, shape=[])
switcher_h_itr = tf.data.Iterator.from_string_handle(switcher_h,
                                                     ds0.output_types,
                                                     ds0.output_shapes)
mb_datums = switcher_h_itr.get_next()

# Start session.
sess = tf.Session()

# Dataset iterator handles.
ds0_h = sess.run(ds0_itr.string_handle())
ds1_h = sess.run(ds1_itr.string_handle())

# *Separate* dataset feed_dicts.
ds0_fd = {switcher_h: ds0_h}
ds1_fd = {switcher_h: ds1_h}

# Initialize dataset iterators.
sess.run([ds0_itr.initializer, ds1_itr.initializer])

# Print some datums from either (XOR) dataset.
print('ds0 data:  {}'.format(sess.run(mb_datums, ds0_fd)))
print('ds1 data:  {}'.format(sess.run(mb_datums, ds1_fd)))

# DESIRE A MINIBATCH OF SIZE 12:  6 FROM EACH.
sys.exit()
ds01_fd = {switcher_h: OP_TO_COMBINE_STRING_HANDLES(ds0_h, ds1_h)}
print('ds0+ds1:  {}'.format(sess.run(mb_datums, ds01_fd)))

我知道它很古老，但对于像我一样理解这个问题并且不想自己解决的其他人来说：下面是一个最小的示例，它使用一个数据集从另外两个数据集中动态选择或“get_next（）”：

import numpy as np
import tensorflow as tf

x = np.full(100, 1)
y = np.full(100, 2)

x_i = tf.data.Dataset.from_tensor_slices(x).make_one_shot_iterator()
y_i = tf.data.Dataset.from_tensor_slices(y).make_one_shot_iterator()

with tf.Session() as sesh:
  [x_h, y_h] = sesh.run([x_i.string_handle(), y_i.string_handle()])

  z_d = tf.data.Dataset.from_tensor_slices(np.random.sample(100))
  z_d = z_d.map(lambda x: tf.gather([x_h, y_h], tf.cast(tf.round(x), tf.int32)))
  z_i = z_d.make_one_shot_iterator()

  picker_i = tf.data.Iterator.from_string_handle(z_i.get_next(), tf.int64).get_next()

  for i in range(100):
    print(sesh.run([picker_i]))  

我知道您希望通过组合来自多个
Dataset
对象的元素来创建批处理。您能否更具体地说明如何生成这些不同的组合？我想自适应地组合数据集（不是预先确定的）。我希望避免对我的（无序/预取/缓存）管道进行任何代价高昂的重新初始化。我不想在执行开始后定义新的ops（张量泄漏）。请注意，mb_基准张量为我的训练ops提供数据，因此我不能为每个数据集单独设置切换器。关于交错。交错非常大的数据集需要很长的时间。我想我可以从单独的数据集中收集minibatch数据，然后交错这些数据，但这会在每次数据集的比率发生变化时创建几个额外的操作。