neulab/docprompting-conala huggingface dataset:
tf.raw_ops.ParallelConcat Concatenates a list of N tensors along the first dimension.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.ParallelConcat  
tf.raw_ops.ParallelConcat(
    values, shape, name=None
)
 The input tensors are all required to have size 1 in the first dimension. For example: # 'x' is [[1, 4]]
# 'y' is [[2, 5]]
# 'z' is [[3, 6]]
parallel_concat([x, y, z]) => [[1, 4], [2, 5], [3, 6]]  # Pack along first dim.
 The difference between concat and parallel_concat is that concat requires all of the inputs be computed before the operation will begin but doesn't require that the input shapes be known during graph construction. Parallel concat will copy pieces of the input into the output as they become available, in some situations this can provide a performance benefit.
 


 Args
  values   A list of at least 1 Tensor objects with the same type. Tensors to be concatenated. All must have size 1 in the first dimension and same shape.  
  shape   A tf.TensorShape or list of ints. the final shape of the result; should be equal to the shapes of any input but with the number of input values in the first dimension.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor. Has the same type as values.
tf.raw_ops.ParallelDynamicStitch Interleave the values from the data tensors into a single tensor.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.ParallelDynamicStitch  
tf.raw_ops.ParallelDynamicStitch(
    indices, data, name=None
)
 Builds a merged tensor such that merged[indices[m][i, ..., j], ...] = data[m][i, ..., j, ...]
 For example, if each indices[m] is scalar or vector, we have # Scalar indices:
merged[indices[m], ...] = data[m][...]

# Vector indices:
merged[indices[m][i], ...] = data[m][i, ...]
 Each data[i].shape must start with the corresponding indices[i].shape, and the rest of data[i].shape must be constant w.r.t. i. That is, we must have data[i].shape = indices[i].shape + constant. In terms of this constant, the output shape is merged.shape = [max(indices)] + constant
 Values may be merged in parallel, so if an index appears in both indices[m][i] and indices[n][j], the result may be invalid. This differs from the normal DynamicStitch operator that defines the behavior in that case. For example: indices[0] = 6
indices[1] = [4, 1]
indices[2] = [[5, 2], [0, 3]]
data[0] = [61, 62]
data[1] = [[41, 42], [11, 12]]
data[2] = [[[51, 52], [21, 22]], [[1, 2], [31, 32]]]
merged = [[1, 2], [11, 12], [21, 22], [31, 32], [41, 42],
          [51, 52], [61, 62]]
 This method can be used to merge partitions created by dynamic_partition as illustrated on the following example: # Apply function (increments x_i) on elements for which a certain condition
# apply (x_i != -1 in this example).
x=tf.constant([0.1, -1., 5.2, 4.3, -1., 7.4])
condition_mask=tf.not_equal(x,tf.constant(-1.))
partitioned_data = tf.dynamic_partition(
    x, tf.cast(condition_mask, tf.int32) , 2)
partitioned_data[1] = partitioned_data[1] + 1.0
condition_indices = tf.dynamic_partition(
    tf.range(tf.shape(x)[0]), tf.cast(condition_mask, tf.int32) , 2)
x = tf.dynamic_stitch(condition_indices, partitioned_data)
# Here x=[1.1, -1., 6.2, 5.3, -1, 8.4], the -1. values remain
# unchanged.
   
 


 Args
  indices   A list of at least 1 Tensor objects with type int32.  
  data   A list with the same length as indices of Tensor objects with the same type.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor. Has the same type as data.
tf.raw_ops.ParallelInterleaveDataset Creates a dataset that applies f to the outputs of input_dataset.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.ParallelInterleaveDataset  
tf.raw_ops.ParallelInterleaveDataset(
    input_dataset, other_arguments, cycle_length, block_length, sloppy,
    buffer_output_elements, prefetch_input_elements, f, output_types, output_shapes,
    name=None
)
 The resulting dataset is similar to the InterleaveDataset, with the exception that if retrieving the next value from a dataset would cause the requester to block, it will skip that input dataset. This dataset is especially useful when loading data from a variable-latency datastores (e.g. HDFS, GCS), as it allows the training step to proceed so long as some data is available. !! WARNING !! If the sloppy parameter is set to True, the operation of this dataset will not be deterministic! This dataset has been superseded by ParallelInterleaveDatasetV2. New code should use ParallelInterleaveDatasetV2. The Python API tf.data.experimental.parallel_interleave creates instances of this op. tf.data.experimental.parallel_interleave is a deprecated API.
 


 Args
  input_dataset   A Tensor of type variant. Dataset that produces a stream of arguments for the function f.  
  other_arguments   A list of Tensor objects. Additional arguments to pass to f beyond those produced by input_dataset. Evaluated once when the dataset is instantiated.  
  cycle_length   A Tensor of type int64. Number of datasets (each created by applying f to the elements of input_dataset) among which the ParallelInterleaveDataset will cycle in a round-robin fashion.  
  block_length   A Tensor of type int64. Number of elements at a time to produce from each interleaved invocation of a dataset returned by f.  
  sloppy   A Tensor of type bool. If True, return elements as they become available, even if that means returning these elements in a non-deterministic order. Sloppy operation may result in better performance in the presence of stragglers, but the dataset will still block if all of its open streams are blocked. If False, always return elements in a deterministic order.  
  buffer_output_elements   A Tensor of type int64. The number of elements each iterator being interleaved should buffer (similar to the .prefetch() transformation for each interleaved iterator).  
  prefetch_input_elements   A Tensor of type int64. Determines the number of iterators to prefetch, allowing buffers to warm up and data to be pre-fetched without blocking the main thread.  
  f   A function decorated with @Defun. A function mapping elements of input_dataset, concatenated with other_arguments, to a Dataset variant that contains elements matching output_types and output_shapes.  
  output_types   A list of tf.DTypes that has length >= 1.  
  output_shapes   A list of shapes (each a tf.TensorShape or list of ints) that has length >= 1.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor of type variant.
tf.raw_ops.ParallelInterleaveDatasetV2 Creates a dataset that applies f to the outputs of input_dataset.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.ParallelInterleaveDatasetV2  
tf.raw_ops.ParallelInterleaveDatasetV2(
    input_dataset, other_arguments, cycle_length, block_length, num_parallel_calls,
    f, output_types, output_shapes, sloppy=False, name=None
)
 The resulting dataset is similar to the InterleaveDataset, except that the dataset will fetch records from the interleaved datasets in parallel. The tf.data Python API creates instances of this op from Dataset.interleave() when the num_parallel_calls parameter of that method is set to any value other than None. By default, the output of this dataset will be deterministic, which may result in the dataset blocking if the next data item to be returned isn't available. In order to avoid head-of-line blocking, one can set the experimental_deterministic parameter of tf.data.Options to False, which can improve performance at the expense of non-determinism.
 


 Args
  input_dataset   A Tensor of type variant. Dataset that produces a stream of arguments for the function f.  
  other_arguments   A list of Tensor objects. Additional arguments to pass to f beyond those produced by input_dataset. Evaluated once when the dataset is instantiated.  
  cycle_length   A Tensor of type int64. Number of datasets (each created by applying f to the elements of input_dataset) among which the ParallelInterleaveDatasetV2 will cycle in a round-robin fashion.  
  block_length   A Tensor of type int64. Number of elements at a time to produce from each interleaved invocation of a dataset returned by f.  
  num_parallel_calls   A Tensor of type int64. Determines the number of threads that should be used for fetching data from input datasets in parallel. The Python API tf.data.experimental.AUTOTUNE constant can be used to indicate that the level of parallelism should be autotuned.  
  f   A function decorated with @Defun. A function mapping elements of input_dataset, concatenated with other_arguments, to a Dataset variant that contains elements matching output_types and output_shapes.  
  output_types   A list of tf.DTypes that has length >= 1.  
  output_shapes   A list of shapes (each a tf.TensorShape or list of ints) that has length >= 1.  
  sloppy   An optional bool. Defaults to False.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor of type variant.
tf.raw_ops.ParallelInterleaveDatasetV3 Creates a dataset that applies f to the outputs of input_dataset.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.ParallelInterleaveDatasetV3  
tf.raw_ops.ParallelInterleaveDatasetV3(
    input_dataset, other_arguments, cycle_length, block_length, num_parallel_calls,
    f, output_types, output_shapes, deterministic='default', name=None
)
 The resulting dataset is similar to the InterleaveDataset, except that the dataset will fetch records from the interleaved datasets in parallel. The tf.data Python API creates instances of this op from Dataset.interleave() when the num_parallel_calls parameter of that method is set to any value other than None. By default, the output of this dataset will be deterministic, which may result in the dataset blocking if the next data item to be returned isn't available. In order to avoid head-of-line blocking, one can either set the deterministic attribute to "false", or leave it as "default" and set the experimental_deterministic parameter of tf.data.Options to False. This can improve performance at the expense of non-determinism.
 


 Args
  input_dataset   A Tensor of type variant. Dataset that produces a stream of arguments for the function f.  
  other_arguments   A list of Tensor objects. Additional arguments to pass to f beyond those produced by input_dataset. Evaluated once when the dataset is instantiated.  
  cycle_length   A Tensor of type int64. Number of datasets (each created by applying f to the elements of input_dataset) among which the ParallelInterleaveDatasetV2 will cycle in a round-robin fashion.  
  block_length   A Tensor of type int64. Number of elements at a time to produce from each interleaved invocation of a dataset returned by f.  
  num_parallel_calls   A Tensor of type int64. Determines the number of threads that should be used for fetching data from input datasets in parallel. The Python API tf.data.experimental.AUTOTUNE constant can be used to indicate that the level of parallelism should be autotuned.  
  f   A function decorated with @Defun. A function mapping elements of input_dataset, concatenated with other_arguments, to a Dataset variant that contains elements matching output_types and output_shapes.  
  output_types   A list of tf.DTypes that has length >= 1.  
  output_shapes   A list of shapes (each a tf.TensorShape or list of ints) that has length >= 1.  
  deterministic   An optional string. Defaults to "default". A string indicating the op-level determinism to use. Deterministic controls whether the interleave is allowed to return elements out of order if the next element to be returned isn't available, but a later element is. Options are "true", "false", and "default". "default" indicates that determinism should be decided by the experimental_deterministic parameter of tf.data.Options.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor of type variant.
tf.raw_ops.ParallelMapDataset Creates a dataset that applies f to the outputs of input_dataset.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.ParallelMapDataset  
tf.raw_ops.ParallelMapDataset(
    input_dataset, other_arguments, num_parallel_calls, f, output_types,
    output_shapes, use_inter_op_parallelism=True, sloppy=False,
    preserve_cardinality=False, name=None
)
 Unlike a "MapDataset", which applies f sequentially, this dataset invokes up to num_parallel_calls copies of f in parallel.
 


 Args
  input_dataset   A Tensor of type variant.  
  other_arguments   A list of Tensor objects.  
  num_parallel_calls   A Tensor of type int32. The number of concurrent invocations of f that process elements from input_dataset in parallel.  
  f   A function decorated with @Defun.  
  output_types   A list of tf.DTypes that has length >= 1.  
  output_shapes   A list of shapes (each a tf.TensorShape or list of ints) that has length >= 1.  
  use_inter_op_parallelism   An optional bool. Defaults to True.  
  sloppy   An optional bool. Defaults to False.  
  preserve_cardinality   An optional bool. Defaults to False.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor of type variant.
tf.raw_ops.ParallelMapDatasetV2 Creates a dataset that applies f to the outputs of input_dataset.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.ParallelMapDatasetV2  
tf.raw_ops.ParallelMapDatasetV2(
    input_dataset, other_arguments, num_parallel_calls, f, output_types,
    output_shapes, use_inter_op_parallelism=True, deterministic='default',
    preserve_cardinality=False, name=None
)
 Unlike a "MapDataset", which applies f sequentially, this dataset invokes up to num_parallel_calls copies of f in parallel.
 


 Args
  input_dataset   A Tensor of type variant.  
  other_arguments   A list of Tensor objects.  
  num_parallel_calls   A Tensor of type int64. The number of concurrent invocations of f that process elements from input_dataset in parallel.  
  f   A function decorated with @Defun.  
  output_types   A list of tf.DTypes that has length >= 1.  
  output_shapes   A list of shapes (each a tf.TensorShape or list of ints) that has length >= 1.  
  use_inter_op_parallelism   An optional bool. Defaults to True.  
  deterministic   An optional string. Defaults to "default".  
  preserve_cardinality   An optional bool. Defaults to False.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor of type variant.
tf.raw_ops.ParameterizedTruncatedNormal Outputs random values from a normal distribution. The parameters may each be a  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.ParameterizedTruncatedNormal  
tf.raw_ops.ParameterizedTruncatedNormal(
    shape, means, stdevs, minvals, maxvals, seed=0, seed2=0, name=None
)
 scalar which applies to the entire output, or a vector of length shape[0] which stores the parameters for each batch.
 


 Args
  shape   A Tensor. Must be one of the following types: int32, int64. The shape of the output tensor. Batches are indexed by the 0th dimension.  
  means   A Tensor. Must be one of the following types: half, bfloat16, float32, float64. The mean parameter of each batch.  
  stdevs   A Tensor. Must have the same type as means. The standard deviation parameter of each batch. Must be greater than 0.  
  minvals   A Tensor. Must have the same type as means. The minimum cutoff. May be -infinity.  
  maxvals   A Tensor. Must have the same type as means. The maximum cutoff. May be +infinity, and must be more than the minval for each batch.  
  seed   An optional int. Defaults to 0. If either seed or seed2 are set to be non-zero, the random number generator is seeded by the given seed. Otherwise, it is seeded by a random seed.  
  seed2   An optional int. Defaults to 0. A second seed to avoid seed collision.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor. Has the same type as means.
tf.raw_ops.ParseExampleDataset Transforms input_dataset containing Example protos as vectors of DT_STRING into a dataset of Tensor or SparseTensor objects representing the parsed features.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.ParseExampleDataset  
tf.raw_ops.ParseExampleDataset(
    input_dataset, num_parallel_calls, dense_defaults, sparse_keys, dense_keys,
    sparse_types, dense_shapes, output_types, output_shapes, sloppy=False,
    ragged_keys=[], ragged_value_types=[], ragged_split_types=[], name=None
)

 


 Args
  input_dataset   A Tensor of type variant.  
  num_parallel_calls   A Tensor of type int64.  
  dense_defaults   A list of Tensor objects with types from: float32, int64, string. A dict mapping string keys to Tensors. The keys of the dict must match the dense_keys of the feature.  
  sparse_keys   A list of strings. A list of string keys in the examples features. The results for these keys will be returned as SparseTensor objects.  
  dense_keys   A list of strings. A list of Ndense string Tensors (scalars). The keys expected in the Examples features associated with dense values.  
  sparse_types   A list of tf.DTypes from: tf.float32, tf.int64, tf.string. A list of DTypes of the same length as sparse_keys. Only tf.float32 (FloatList), tf.int64 (Int64List), and tf.string (BytesList) are supported.  
  dense_shapes   A list of shapes (each a tf.TensorShape or list of ints). List of tuples with the same length as dense_keys. The shape of the data for each dense feature referenced by dense_keys. Required for any input tensors identified by dense_keys. Must be either fully defined, or may contain an unknown first dimension. An unknown first dimension means the feature is treated as having a variable number of blocks, and the output shape along this dimension is considered unknown at graph build time. Padding is applied for minibatch elements smaller than the maximum number of blocks for the given feature along this dimension.  
  output_types   A list of tf.DTypes that has length >= 1. The type list for the return values.  
  output_shapes   A list of shapes (each a tf.TensorShape or list of ints) that has length >= 1. The list of shapes being produced.  
  sloppy   An optional bool. Defaults to False.  
  ragged_keys   An optional list of strings. Defaults to [].  
  ragged_value_types   An optional list of tf.DTypes from: tf.float32, tf.int64, tf.string. Defaults to [].  
  ragged_split_types   An optional list of tf.DTypes from: tf.int32, tf.int64. Defaults to [].  
  name   A name for the operation (optional).   
 


 Returns   A Tensor of type variant.
tf.raw_ops.ParseExampleDatasetV2 Transforms input_dataset containing Example protos as vectors of DT_STRING into a dataset of Tensor or SparseTensor objects representing the parsed features.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.ParseExampleDatasetV2  
tf.raw_ops.ParseExampleDatasetV2(
    input_dataset, num_parallel_calls, dense_defaults, sparse_keys, dense_keys,
    sparse_types, dense_shapes, output_types, output_shapes,
    deterministic='default', ragged_keys=[], ragged_value_types=[],
    ragged_split_types=[], name=None
)

 


 Args
  input_dataset   A Tensor of type variant.  
  num_parallel_calls   A Tensor of type int64.  
  dense_defaults   A list of Tensor objects with types from: float32, int64, string. A dict mapping string keys to Tensors. The keys of the dict must match the dense_keys of the feature.  
  sparse_keys   A list of strings. A list of string keys in the examples features. The results for these keys will be returned as SparseTensor objects.  
  dense_keys   A list of strings. A list of Ndense string Tensors (scalars). The keys expected in the Examples features associated with dense values.  
  sparse_types   A list of tf.DTypes from: tf.float32, tf.int64, tf.string. A list of DTypes of the same length as sparse_keys. Only tf.float32 (FloatList), tf.int64 (Int64List), and tf.string (BytesList) are supported.  
  dense_shapes   A list of shapes (each a tf.TensorShape or list of ints). List of tuples with the same length as dense_keys. The shape of the data for each dense feature referenced by dense_keys. Required for any input tensors identified by dense_keys. Must be either fully defined, or may contain an unknown first dimension. An unknown first dimension means the feature is treated as having a variable number of blocks, and the output shape along this dimension is considered unknown at graph build time. Padding is applied for minibatch elements smaller than the maximum number of blocks for the given feature along this dimension.  
  output_types   A list of tf.DTypes that has length >= 1. The type list for the return values.  
  output_shapes   A list of shapes (each a tf.TensorShape or list of ints) that has length >= 1. The list of shapes being produced.  
  deterministic   An optional string. Defaults to "default". A string indicating the op-level determinism to use. Deterministic controls whether the dataset is allowed to return elements out of order if the next element to be returned isn't available, but a later element is. Options are "true", "false", and "default". "default" indicates that determinism should be decided by the experimental_deterministic parameter of tf.data.Options.  
  ragged_keys   An optional list of strings. Defaults to [].  
  ragged_value_types   An optional list of tf.DTypes from: tf.float32, tf.int64, tf.string. Defaults to [].  
  ragged_split_types   An optional list of tf.DTypes from: tf.int32, tf.int64. Defaults to [].  
  name   A name for the operation (optional).   
 


 Returns   A Tensor of type variant.