tf.nest.pack_sequence_as

Возвращает заданную уплощенную последовательность, упакованную в заданную структуру.

tf.nest.pack_sequence_as(
    structure, flat_sequence, expand_composites=False
)

Используется в ноутбуках

Обратитесь к tf.nest для определения структуры.

Если structure является атомом, то flat_sequence должна быть списком из одного элемента; в этом случае возвращаемое значение равно flat_sequence[0].

Если structure является или содержит экземпляр словаря, ключи будут отсортированы для упаковки уплощенной последовательности в определённом порядке. Это также верно для экземпляров OrderedDict: порядок последовательности игнорируется, вместо этого используется порядок сортировки ключей. Такая же соглашение используется в flatten. Это правильно упаковывает словари и OrderedDict после их уплотнения, а также позволяет уплотнить OrderedDict и затем упаковать его обратно, используя соответствующий обычный словарь, или наоборот. Словари с несортируемыми ключами не могут быть уплотнены.

Примеры:

1. Словарь Python:

   structure = { "key3": "", "key1": "", "key2": "" }
   flat_sequence = ["value1", "value2", "value3"]
   tf.nest.pack_sequence_as(structure, flat_sequence)
     {'key3': 'value3', 'key1': 'value1', 'key2': 'value2'}
     

2. Для вложенной кортежа Python:

   structure = (('a','b'), ('c','d','e'), 'f')
   flat_sequence = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]
   tf.nest.pack_sequence_as(structure, flat_sequence)
     ((1.0, 2.0), (3.0, 4.0, 5.0), 6.0)
     

3. Для вложенного словаря словарей:

   structure = { "key3": {"c": ('alpha', 'beta'), "a": ('gamma')},
                 "key1": {"e": "val1", "d": "val2"} }
   flat_sequence = ['val2', 'val1', 3.0, 1.0, 2.0]
   tf.nest.pack_sequence_as(structure, flat_sequence)
     {'key3': {'c': (1.0, 2.0), 'a': 3.0}, 'key1': {'e': 'val1', 'd': 'val2'} }
     

4. Массив Numpy (рассматривается как скаляр):

   structure = ['a']
   flat_sequence = [np.array([[1, 2], [3, 4]])]
   tf.nest.pack_sequence_as(structure, flat_sequence)
     [array([[1, 2],
            [3, 4]])]
     

5. tf.Tensor (рассматривается как скаляр):

   structure = ['a']
   flat_sequence = [tf.constant([[1., 2., 3.], [4., 5., 6.]])]
   tf.nest.pack_sequence_as(structure, flat_sequence)
     [<tf.Tensor: shape=(2, 3), dtype=float32,
      numpy= array([[1., 2., 3.], [4., 5., 6.]], dtype=float32)>]
     

6. tf.RaggedTensor: Это составной тензор, представление которого состоит из уплощённого списка 'значений' и списка 'row_splits', которые указывают, как разбить уплощённый список на разные строки. Для получения дополнительной информации о tf.RaggedTensor посетите https://www.tensorflow.org/api_docs/python/tf/RaggedTensor.

С помощью expand_composites=False мы рассматриваем RaggedTensor как скаляр.

structure = { "foo": tf.ragged.constant([[1, 2], [3]]),
              "bar": tf.constant([[5]]) }
flat_sequence = [ "one", "two" ]
tf.nest.pack_sequence_as(structure, flat_sequence,
expand_composites=False)
  {'foo': 'two', 'bar': 'one'}
  

С помощью expand_composites=True мы ожидаем, что уплощенный входной содержит тензоры, составляющие разрозненный тензор, т.е. тензоры значений и row_splits.

structure = { "foo": tf.ragged.constant([[1., 2.], [3.]]),
              "bar": tf.constant([[5.]]) }
tensors = tf.nest.flatten(structure, expand_composites=True)
print(tensors)
  [<tf.Tensor: shape=(1, 1), dtype=float32, numpy=array([[5.]],
   dtype=float32)>,
   <tf.Tensor: shape=(3,), dtype=float32, numpy=array([1., 2., 3.],
   dtype=float32)>,
   <tf.Tensor: shape=(3,), dtype=int64, numpy=array([0, 2, 3])>]
verified_tensors = [tf.debugging.check_numerics(t, 'invalid tensor: ')
                    if t.dtype==tf.float32 else t
                    for t in tensors]
tf.nest.pack_sequence_as(structure, verified_tensors,
                         expand_composites=True)
  {'foo': <tf.RaggedTensor [[1.0, 2.0], [3.0]]>,
   'bar': <tf.Tensor: shape=(1, 1), dtype=float32, numpy=array([[5.]],
   dtype=float32)>}