tf.contrib.data.RandomDataset

Dataset псевдослучайных значений.

Наследуется от: RandomDataset

tf.contrib.data.RandomDataset(
    seed=None
)

Методы

apply

Просмотреть исходный код

apply(
    transformation_func
)

Применяет функцию преобразования к этому набору данных.

apply позволяет объединять в цепочку пользовательские преобразования Dataset, представленные функциями, которые принимают один аргумент Dataset и возвращают преобразованный Dataset.

Например:

dataset = (dataset.map(lambda x: x ** 2)
           .apply(group_by_window(key_func, reduce_func, window_size))
           .map(lambda x: x ** 3))

batch

Просмотреть исходный код

batch(
    batch_size, drop_remainder=False
)

Объединяет последовательные элементы этого набора данных в пакеты.

Компоненты результирующего элемента будут иметь дополнительное внешнее измерение, которое будет равно batch_size (или N % batch_size для последнего элемента, если batch_size не делит количество входных элементов N нацело и drop_remainder равно False). Если программа зависит от того, что внешнее измерение пакетов будет одинаковым, задайте аргумент drop_remainder равным True, чтобы предотвратить создание пакета меньшего размера.

cache

Просмотреть исходный код

cache(
    filename=''
)

Кэширует элементы этого набора данных.

concatenate

Просмотреть исходный код

concatenate(
    dataset
)

Создаёт Dataset, объединяя заданный набор данных с этим набором данных.

a = Dataset.range(1, 4)  # ==> [ 1, 2, 3 ]
b = Dataset.range(4, 8)  # ==> [ 4, 5, 6, 7 ]

# The input dataset and dataset to be concatenated should have the same
# nested structures and output types.
# c = Dataset.range(8, 14).batch(2)  # ==> [ [8, 9], [10, 11], [12, 13] ]
# d = Dataset.from_tensor_slices([14.0, 15.0, 16.0])
# a.concatenate(c) and a.concatenate(d) would result in error.

a.concatenate(b)  # ==> [ 1, 2, 3, 4, 5, 6, 7 ]

enumerate

Просмотреть исходный код

enumerate(
    start=0
)

Нумерует элементы этого набора данных.

Это похоже на функцию enumerate в Python.

Например:

# NOTE: The following examples use `{ ... }` to represent the
# contents of a dataset.
a = { 1, 2, 3 }
b = { (7, 8), (9, 10) }

# The nested structure of the `datasets` argument determines the
# structure of elements in the resulting dataset.
a.enumerate(start=5)) == { (5, 1), (6, 2), (7, 3) }
b.enumerate() == { (0, (7, 8)), (1, (9, 10)) }

filter

Просмотреть исходный код

filter(
    predicate
)

Фильтрует этот набор данных согласно predicate.

d = tf.data.Dataset.from_tensor_slices([1, 2, 3])

d = d.filter(lambda x: x < 3)  # ==> [1, 2]

# `tf.math.equal(x, y)` is required for equality comparison
def filter_fn(x):
  return tf.math.equal(x, 1)

d = d.filter(filter_fn)  # ==> [1]

filter_with_legacy_function

Просмотреть исходный код

filter_with_legacy_function(
    predicate
)

Фильтрует этот набор данных согласно predicate. (устарело)

Примечание: Это обходной путь для существующих вариантов использования filter, которые не работают с функциями V2. Настоятельно не рекомендуется использовать его в новом коде; существующий код следует перевести на filter, так как этот метод будет удалён в V2.

flat_map

Просмотреть исходный код

flat_map(
    map_func
)

Применяет map_func к элементам этого набора данных и уплощает результат.

Используйте flat_map, если необходимо сохранить порядок элементов набора данных. Например, чтобы преобразовать набор данных из пакетов в набор данных из отдельных элементов:

a = Dataset.from_tensor_slices([ [1, 2, 3], [4, 5, 6], [7, 8, 9] ])

a.flat_map(lambda x: Dataset.from_tensor_slices(x + 1)) # ==>
#  [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ]

tf.data.Dataset.interleave() является обобщением flat_map, поскольку flat_map создаёт тот же результат, что и tf.data.Dataset.interleave(cycle_length=1)

from_generator

Просмотреть исходный код

@staticmethod
from_generator(
    generator, output_types, output_shapes=None, args=None
)

Создаёт Dataset, элементы которого генерируются с помощью generator.

Аргумент generator должен быть вызываемым объектом, возвращающим объект, поддерживающий протокол iter() (например, генераторную функцию). Элементы, сгенерированные generator, должны быть совместимы с заданными аргументами output_types и (необязательными) output_shapes.

Например:

import itertools
tf.compat.v1.enable_eager_execution()

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

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

for value in ds.take(2):
  print value
# (1, array([1]))
# (2, array([1, 1]))

Примечание: Текущая реализация Dataset.from_generator() использует tf.numpy_function и наследует те же ограничения. В частности, она требует, чтобы операции, связанные с Dataset и Iterator, располагались на устройстве в том же процессе, что и программа Python, вызвавшая Dataset.from_generator(). Тело generator не будет сериализовано в GraphDef, и вам не следует использовать этот метод, если вам нужно сериализовать вашу модель и восстановить её в другой среде.

Примечание: Если generator зависит от изменяемых глобальных переменных или других внешних состояний, имейте в виду, что запуск может вызывать generator несколько раз (для поддержки повторения Dataset) и в любое время между вызовом Dataset.from_generator() и производством первого элемента из генератора. Изменение глобальных переменных или внешних состояний может привести к неопределённому поведению, и мы рекомендуем вам явно кэшировать любое внешнее состояние в generator перед вызовом Dataset.from_generator().

from_sparse_tensor_slices

Просмотреть исходный код

@staticmethod
from_sparse_tensor_slices(
    sparse_tensor
)

Разделяет каждый тензор ранга N tf.SparseTensor в этой строке набора данных по строкам. (Устарело)

from_tensor_slices

Просмотреть исходный код

@staticmethod
from_tensor_slices(
    tensors
)

Создаёт набор данных Dataset, элементы которого являются срезами заданных тензоров.

Обратите внимание, что если tensors содержит массив NumPy, и выполнение в режиме eager отключено, значения будут встроены в граф как одна или несколько операций tf.constant. Для больших наборов данных (> 1 ГБ) это может привести к потере памяти и ограничениям по размеру при сериализации графа. Если tensors содержит один или несколько больших массивов NumPy, рассмотрите альтернативный вариант, описанный в этом руководстве.

from_tensors

Просмотреть исходный код

@staticmethod
from_tensors(
    tensors
)

Создаёт набор данных Dataset с единственным элементом, состоящим из заданных тензоров.

Обратите внимание, что если tensors содержит массив NumPy, и выполнение в режиме eager отключено, значения будут встроены в граф как одна или несколько операций tf.constant. Для больших наборов данных (> 1 ГБ) это может привести к потере памяти и ограничениям по размеру при сериализации графа. Если tensors содержит один или несколько больших массивов NumPy, рассмотрите альтернативный вариант, описанный в этом руководстве.

interleave

Просмотреть исходный код

interleave(
    map_func, cycle_length=AUTOTUNE, block_length=1, num_parallel_calls=None
)

Применяет map_func к этому набору данных и чередует результаты.

Например, вы можете использовать Dataset.interleave() для одновременной обработки многих входных файлов:

# Preprocess 4 files concurrently, and interleave blocks of 16 records from
# each file.
filenames = ["/var/data/file1.txt", "/var/data/file2.txt", ...]
dataset = (Dataset.from_tensor_slices(filenames)
           .interleave(lambda x:
               TextLineDataset(x).map(parse_fn, num_parallel_calls=1),
               cycle_length=4, block_length=16))

Аргументы cycle_length и block_length управляют порядком создания элементов. cycle_length определяет количество входных элементов, обрабатываемых одновременно. Если задать cycle_length равным 1, это преобразование будет обрабатывать по одному входному элементу за раз и выдаст результаты, идентичные результатам tf.data.Dataset.flat_map. В общем случае это преобразование применит map_func к cycle_length входным элементам, откроет итераторы для возвращённых объектов Dataset и будет циклически перебирать их, создавая block_length последовательных элементов из каждого итератора и потребляя следующий входной элемент каждый раз, когда достигается конец итератора.

Например:

a = Dataset.range(1, 6)  # ==> [ 1, 2, 3, 4, 5 ]

# NOTE: New lines indicate "block" boundaries.
a.interleave(lambda x: Dataset.from_tensors(x).repeat(6),
            cycle_length=2, block_length=4)  # ==> [1, 1, 1, 1,
                                             #      2, 2, 2, 2,
                                             #      1, 1,
                                             #      2, 2,
                                             #      3, 3, 3, 3,
                                             #      4, 4, 4, 4,
                                             #      3, 3,
                                             #      4, 4,
                                             #      5, 5, 5, 5,
                                             #      5, 5]

Примечание: Порядок элементов, возвращаемых этим преобразованием, детерминирован, если map_func является чистой функцией. Если map_func содержит операции с состоянием, порядок доступа к этому состоянию не определён.

list_files

Просмотреть исходный код

@staticmethod
list_files(
    file_pattern, shuffle=None, seed=None
)

Набор данных со всеми файлами, соответствующими одному или нескольким шаблонам поиска.

Примечание: По умолчанию этот метод возвращает имена файлов в недетерминированном, случайно перемешанном порядке. Передайте seed или shuffle=False, чтобы получить результаты в детерминированном порядке.

Пример:

Предположим, в нашей файловой системе есть следующие файлы:

• /path/to/dir/a.txt
• /path/to/dir/b.py
• /path/to/dir/c.py Если передать "/path/to/dir/*.py" в качестве каталога, набор данных вернёт:
• /path/to/dir/b.py
• /path/to/dir/c.py

make_initializable_iterator

Просмотреть исходный код

make_initializable_iterator(
    shared_name=None
)

Создаёт итератор для перебора элементов этого набора данных. (устарело)

Примечание: Возвращаемый итератор будет неинициализирован; перед использованием необходимо выполнить операцию iterator.initializer:

dataset = ...
iterator = dataset.make_initializable_iterator()
# ...
sess.run(iterator.initializer)

make_one_shot_iterator

Просмотреть исходный код

make_one_shot_iterator()

Создаёт итератор для перебора элементов этого набора данных. (устарело)

Примечание: Возвращаемый итератор будет инициализирован автоматически. Итератор «one-shot» в настоящее время не поддерживает повторную инициализацию.

map

Просмотреть исходный код

map(
    map_func, num_parallel_calls=None
)

Применяет функцию `map` к элементам этого набора данных.

Это преобразование применяет функцию `map` к каждому элементу этого набора данных и возвращает новый набор данных, содержащий преобразованные элементы в том же порядке, что и в исходном.

Например:

a = Dataset.range(1, 6)  # ==> [ 1, 2, 3, 4, 5 ]

a.map(lambda x: x + 1)  # ==> [ 2, 3, 4, 5, 6 ]

Сигнатура входных данных функции `map` определяется структурой каждого элемента этого набора данных. Например:

# NOTE: The following examples use `{ ... }` to represent the
# contents of a dataset.
# Each element is a `tf.Tensor` object.
a = { 1, 2, 3, 4, 5 }
# `map_func` takes a single argument of type `tf.Tensor` with the same
# shape and dtype.
result = a.map(lambda x: ...)

# Each element is a tuple containing two `tf.Tensor` objects.
b = { (1, "foo"), (2, "bar"), (3, "baz") }
# `map_func` takes two arguments of type `tf.Tensor`.
result = b.map(lambda x_int, y_str: ...)

# Each element is a dictionary mapping strings to `tf.Tensor` objects.
c = { {"a": 1, "b": "foo"}, {"a": 2, "b": "bar"}, {"a": 3, "b": "baz"} }
# `map_func` takes a single argument of type `dict` with the same keys as
# the elements.
result = c.map(lambda d: ...)

Значение или значения, возвращаемые функцией `map`, определяют структуру каждого элемента в возвращаемом наборе данных.

# `map_func` returns a scalar `tf.Tensor` of type `tf.float32`.
def f(...):
  return tf.constant(37.0)
result = dataset.map(f)
result.output_classes == tf.Tensor
result.output_types == tf.float32
result.output_shapes == []  # scalar

# `map_func` returns two `tf.Tensor` objects.
def g(...):
  return tf.constant(37.0), tf.constant(["Foo", "Bar", "Baz"])
result = dataset.map(g)
result.output_classes == (tf.Tensor, tf.Tensor)
result.output_types == (tf.float32, tf.string)
result.output_shapes == ([], [3])

# Python primitives, lists, and NumPy arrays are implicitly converted to
# `tf.Tensor`.
def h(...):
  return 37.0, ["Foo", "Bar", "Baz"], np.array([1.0, 2.0] dtype=np.float64)
result = dataset.map(h)
result.output_classes == (tf.Tensor, tf.Tensor, tf.Tensor)
result.output_types == (tf.float32, tf.string, tf.float64)
result.output_shapes == ([], [3], [2])

# `map_func` can return nested structures.
def i(...):
  return {"a": 37.0, "b": [42, 16]}, "foo"
result.output_classes == ({"a": tf.Tensor, "b": tf.Tensor}, tf.Tensor)
result.output_types == ({"a": tf.float32, "b": tf.int32}, tf.string)
result.output_shapes == ({"a": [], "b": [2]}, [])

Функция `map` может принимать в качестве аргументов и возвращать элементы набора данных любого типа.

Обратите внимание, что независимо от контекста, в котором определена функция `map` (eager или graph), tf.data отслеживает функцию и выполняет её как граф. Для использования кода Python внутри функции доступны два варианта:

1) Использовать AutoGraph для преобразования кода Python в эквивалентные вычисления графа. Недостаток этого подхода заключается в том, что AutoGraph может преобразовать некоторые, но не все фрагменты кода Python.

2) Использовать tf.py_function, который позволяет писать произвольный код Python, но обычно обеспечивает худшую производительность, чем вариант 1). Например:

d = tf.data.Dataset.from_tensor_slices(['hello', 'world'])

# transform a string tensor to upper case string using a Python function
def upper_case_fn(t: tf.Tensor) -> str:
    return t.numpy().decode('utf-8').upper()

d.map(lambda x: tf.py_function(func=upper_case_fn,
      inp=[x], Tout=tf.string))  # ==> [ "HELLO", "WORLD" ]

map_with_legacy_function

Просмотреть исходный код

map_with_legacy_function(
    map_func, num_parallel_calls=None
)

Применяет функцию `map` к элементам этого набора данных. (устарело)

Примечание: Это утилита для существующего использования функций `map`, которые не работают с V2 функциями. Новые использования настоятельно не рекомендуется, и существующие должны мигрировать на map, так как этот метод будет удален в V2.

options

Просмотреть исходный код

options()

Возвращает параметры этого набора данных и его входных данных.

padded_batch

Просмотреть исходный код

padded_batch(
    batch_size, padded_shapes, padding_values=None, drop_remainder=False
)

Объединяет последовательные элементы этого набора данных в заполненные пакеты.

Это преобразование объединяет несколько последовательных элементов входного набора данных в один элемент.

Как и tf.data.Dataset.batch, компоненты результирующего элемента будут иметь дополнительное внешнее измерение, которое будет batch_size (или N % batch_size для последнего элемента, если batch_size не делит количество входных элементов N равномерно и drop_remainder является False). Если ваша программа зависит от того, что пакеты имеют одинаковое внешнее измерение, вы должны установить аргумент drop_remainder в True для предотвращения создания более маленьких пакетов.

В отличие от tf.data.Dataset.batch, входные элементы для пакетирования могут иметь разные формы, и это преобразование заполнит каждый компонент до соответствующей формы в padding_shapes. Аргумент padding_shapes определяет результирующую форму для каждого измерения каждого компонента в элементе вывода:

• Если измерение является постоянным (например, tf.compat.v1.Dimension(37)), компонент будет заполнен до этого размера в этом измерении.
• Если измерение неизвестно (например, tf.compat.v1.Dimension(None)), компонент будет заполнен до максимальной длины всех элементов в этом измерении.

См. также tf.data.experimental.dense_to_sparse_batch, который объединяет элементы с различными формами в tf.SparseTensor.

prefetch

Просмотреть исходный код

prefetch(
    buffer_size
)

Создаёт набор данных, который предварительно загружает элементы из этого набора данных.

Примечание: Как и другие методы Dataset, prefetch работает с элементами входного набора данных. Он не различает примеры и пакеты. examples.prefetch(2) будет предварительно загружать два элемента (2 примера), тогда как examples.batch(20).prefetch(2) будет предварительно загружать 2 элемента (2 пакета по 20 примеров в каждом).

range

Просмотреть исходный код

@staticmethod
range(
    *args
)

Создаёт набор данных из последовательности значений с заданным шагом.

Например:

Dataset.range(5) == [0, 1, 2, 3, 4]
Dataset.range(2, 5) == [2, 3, 4]
Dataset.range(1, 5, 2) == [1, 3]
Dataset.range(1, 5, -2) == []
Dataset.range(5, 1) == []
Dataset.range(5, 1, -2) == [5, 3]

reduce

Просмотреть исходный код

reduce(
    initial_state, reduce_func
)

Сводит входной набор данных к одному элементу.

Преобразование последовательно вызывает reduce_func для каждого элемента входного набора данных, пока набор данных не будет исчерпан, накапливая информацию во внутреннем состоянии. Аргумент initial_state используется как начальное состояние, а конечное состояние возвращается в качестве результата.

Например:

• tf.data.Dataset.range(5).reduce(np.int64(0), lambda x, _: x + 1) даёт 5
• tf.data.Dataset.range(5).reduce(np.int64(0), lambda x, y: x + y) даёт 10

repeat

Просмотреть исходный код

repeat(
    count=None
)

Повторяет этот набор данных count раз.

Примечание: Если этот набор данных зависит от глобального состояния (например, генератора случайных чисел), разные повторения могут давать разные элементы.

shard

Просмотреть исходный код

shard(
    num_shards, index
)

Создаёт набор данных, содержащий только 1/num_shards этого набора данных.

Этот оператор набора данных очень полезен при распределённом обучении, поскольку он позволяет каждому рабочему узлу считывать уникальное подмножество данных.

При чтении из одного входного файла можно пропускать элементы следующим образом:

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)

Важные замечания:

• Убедитесь, что вы разделили набор данных на части до применения любого оператора случайной выборки (например, shuffle).
• В целом лучше использовать оператор разбиения на части на раннем этапе конвейера набора данных. Например, при чтении из набора файлов 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)

shuffle

Просмотреть исходный код

shuffle(
    buffer_size, seed=None, reshuffle_each_iteration=None
)

Случайным образом перемешивает элементы этого набора данных.

Этот набор данных заполняет буфер элементами buffer_size, затем случайным образом выбирает элементы из этого буфера, заменяя выбранные элементы новыми. Для идеального перемешивания размер буфера должен быть равен размеру набора данных или превышать его.

Например, если ваш набор данных содержит 10 000 элементов, но buffer_size задан как 1000, то shuffle изначально будет выбирать случайный элемент только из первых 1000 элементов в буфере. После выбора элемента его место в буфере занимает следующий элемент (то есть элемент 1001), благодаря чему в буфере сохраняется 1000 элементов.

skip

Просмотреть исходный код

skip(
    count
)

Создаёт набор данных, пропускающий count элементов из этого набора данных.

take

Просмотреть исходный код

take(
    count
)

Создаёт набор данных, содержащий не более count элементов из этого набора данных.

unbatch

Просмотреть исходный код

unbatch()

Разделяет элементы набора данных на несколько элементов.

Например, если элементы набора данных имеют форму [B, a0, a1, ...], где B может различаться для каждого входного элемента, то для каждого элемента набора данных результатом преобразования unbatch будет B последовательных элементов формы [a0, a1, ...].

# NOTE: The following example uses `{ ... }` to represent the contents
# of a dataset.
ds = { ['a', 'b', 'c'], ['a', 'b'], ['a', 'b', 'c', 'd'] }

ds.unbatch() == {'a', 'b', 'c', 'a', 'b', 'a', 'b', 'c', 'd'}

window

Просмотреть исходный код

window(
    size, shift=None, stride=1, drop_remainder=False
)

Объединяет входные элементы (или вложенные элементы) в набор данных из окон.

«Окно» — это конечный набор данных из плоских элементов размером size (или, возможно, меньшего размера, если входных элементов недостаточно для заполнения окна и drop_remainder имеет значение false).

Аргумент stride определяет шаг входных элементов, а аргумент shift определяет сдвиг окна.

Например, используя {...} для представления набора данных:

• tf.data.Dataset.range(7).window(2) даёт { {0, 1}, {2, 3}, {4, 5}, {6} }
• tf.data.Dataset.range(7).window(3, 2, 1, True) даёт { {0, 1, 2}, {2, 3, 4}, {4, 5, 6} }
• tf.data.Dataset.range(7).window(3, 1, 2, True) даёт { {0, 2, 4}, {1, 3, 5}, {2, 4, 6} }

Обратите внимание, что при применении преобразования window к набору данных из вложенных элементов создаётся набор данных из вложенных окон.

Например:

• tf.data.Dataset.from_tensor_slices((range(4), range(4))).window(2) даёт {({0, 1}, {0, 1}), ({2, 3}, {2, 3})}
• tf.data.Dataset.from_tensor_slices({"a": range(4)}).window(2) даёт { {"a": {0, 1} }, {"a": {2, 3} } }

with_options

Просмотреть исходный код

with_options(
    options
)

Возвращает новый tf.data.Dataset с заданными параметрами.

Параметры являются «глобальными» в том смысле, что применяются ко всему набору данных. Если параметры заданы несколько раз, они объединяются, если для одного и того же параметра не заданы разные значения, отличные от значений по умолчанию.

zip

Просмотреть исходный код

@staticmethod
zip(
    datasets
)

Создаёт набор данных путём объединения указанных наборов данных.

Этот метод имеет семантику, похожую на встроенную функцию Python zip(), за исключением того, что аргумент datasets может быть произвольной вложенной структурой объектов Dataset. Например:

a = Dataset.range(1, 4)  # ==> [ 1, 2, 3 ]
b = Dataset.range(4, 7)  # ==> [ 4, 5, 6 ]
c = Dataset.range(7, 13).batch(2)  # ==> [ [7, 8], [9, 10], [11, 12] ]
d = Dataset.range(13, 15)  # ==> [ 13, 14 ]

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

# The `datasets` argument may contain an arbitrary number of
# datasets.
Dataset.zip((a, b, c))  # ==> [ (1, 4, [7, 8]),
                        #       (2, 5, [9, 10]),
                        #       (3, 6, [11, 12]) ]

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

__iter__

Просмотреть исходный код

__iter__()

Создаёт итератор для перебора элементов этого набора данных.

Возвращаемый итератор реализует протокол итератора Python и поэтому может использоваться только в eager-режиме.