tf.data.experimental.SqlDataset

A Dataset состоящий из результатов запроса SQL.

tf.data.experimental.SqlDataset(
    driver_name, data_source_name, query, output_types
)

Методы

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
)

Создаёт набор данных, чьи элементы генерируются функцией 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
)

Создаёт набор данных, чьи элементы являются слайсами заданных тензоров.

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

from_tensors

Просмотр исходного кода

@staticmethod
from_tensors(
    tensors
)

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

Обратите внимание, что если 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
)

Множество всех файлов, соответствующих одному или нескольким шаблонам glob.

Примечание: По умолчанию этот метод возвращает имена файлов в произвольном порядке. Передайте 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()

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

Примечание: Возвращаемый итератор будет инициализирован автоматически. "Одноразовый" итератор в настоящее время не поддерживает повторную инициализацию.

map

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

map(
    map_func, num_parallel_calls=None
)

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

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

Например:

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

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

Подпись ввода map_func определяется структурой каждого элемента в этом наборе данных. Например:

# 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_func, определяют структуру каждого элемента в возвращаемом наборе данных.

# `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_func может принимать в качестве аргументов и возвращать любой тип элемента набора данных.

Обратите внимание, что независимо от контекста, в котором map_func определён (жадная или графическая обработка), 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 , которое не работает с функциями 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 для предварительной выборки элементов из этого набора данных.

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

range

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

@staticmethod
range(
    *args
)

Создает Dataset диапазона значений с заданным шагом.

Например:

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
)

Создаёт Dataset, включающий только 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 может варьироваться для каждого элемента входных данных, то для каждого элемента в наборе данных набор данных без группирования будет содержать 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
)

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

Этот метод имеет сходную семантику со встроенной функцией zip() в Python, с основным отличием, заключающимся в том, что аргумент 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.