tf.compat.v2.data.TextLineDataset

A Dataset содержащий строки из одного или нескольких текстовых файлов.

tf.compat.v2.data.TextLineDataset(
    filenames, compression_type=None, buffer_size=None, num_parallel_reads=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]

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_tensor_slices

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

@staticmethod
from_tensor_slices(
    tensors
)

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

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

from_tensors

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

@staticmethod
from_tensors(
    tensors
)

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

Обратите внимание, что если tensors содержит массив NumPy, а жадное выполнение не включено, значения будут встроены в граф как одна или несколько операций 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

map

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

map(
    map_func, num_parallel_calls=None
)

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

Эта трансформация применяет 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" ]

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, 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
)

Создаёт 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
)

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

take

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

take(
    count
)

Создаёт Dataset с не более чем 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
)

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

Этот метод имеет семантику, аналогичную встроенной функции 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__()

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

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