tensorflow::ops::TakeManySparseFromTensorsMap

#include <sparse_ops.h>

Преобразует разреженное представление в плотный тензор.

Summary

Строит массив dense с формой output_shape таким образом, что

Если sparse_indices является скаляром

dense[i] = (i == sparse_indices ? sparse_values : default_value)

Если sparse_indices является вектором, то для каждого i

dense[sparse_indices[i]] = sparse_values[i]

Если sparse_indices является n×d матрицей, то для каждого i в [0, n)

dense[sparse_indices[i][0], ..., sparse_indices[i][d-1]] = sparse_values[i]

All other values in `dense` are set to `default_value`.  If `sparse_values` is a
    scalar, all sparse indices are set to this single value.

Indices should be sorted in lexicographic order, and indices must not
contain any repeats. If `validate_indices` is true, these properties
are checked during execution.

Args:
* scope: A Scope object
* sparse_indices: 0-D, 1-D, or 2-D.  `sparse_indices[i]` contains the complete
index where `sparse_values[i]` will be placed.
* output_shape: 1-D.  Shape of the dense output tensor.
* sparse_values: 1-D.  Values corresponding to each row of `sparse_indices`,
or a scalar value to be used for all sparse indices.
* default_value: Scalar value to set for indices not specified in
`sparse_indices`.

Optional attributes (see `Attrs`):
* validate_indices: If true, indices are checked to make sure they are sorted in
lexicographic order and that there are no repeats.

    Returns:
    * `Output`: Dense output tensor of shape `output_shape`. */
class SparseToDense {
 public:
  /// Optional attribute setters for SparseToDense
  struct Attrs {
    /** If true, indices are checked to make sure they are sorted in
        lexicographic order and that there are no repeats.

    Defaults to true */
TF_MUST_USE_RESULT Attrs ValidateIndices(bool x) {
  Attrs ret = *this;
  ret.validate_indices_ = x;
  return ret;
}

  bool validate_indices_ = true;
};
SparseToDense(const tensorflow::Scope& scope, tensorflow::Input
            sparse_indices, tensorflow::Input output_shape,
            tensorflow::Input sparse_values, tensorflow::Input
            default_value);
SparseToDense(const tensorflow::Scope& scope, tensorflow::Input
            sparse_indices, tensorflow::Input output_shape,
            tensorflow::Input sparse_values, tensorflow::Input
            default_value, const SparseToDense::Attrs& attrs);
operator ::tensorflow::Output() const { return dense; }
operator ::tensorflow::Input() const { return dense; }
::tensorflow::Node* node() const { return dense.node(); }

static Attrs ValidateIndices(bool x) {
  return Attrs().ValidateIndices(x);
}

Operation operation;
  tensorflow::Output dense;
};

/** Read `SparseTensors` from a `SparseTensorsMap` and concatenate them.

The input `sparse_handles` must be an `int64` matrix of shape `[N, 1]` where
`N` is the minibatch size and the rows correspond to the output handles of
`AddSparseToTensorsMap` or `AddManySparseToTensorsMap`.  The ranks of the
original `SparseTensor` objects that went into the given input ops must all
match.  When the final `SparseTensor` is created, it has rank one
higher than the ranks of the incoming `SparseTensor` objects
(they have been concatenated along a new row dimension on the left).

The output `SparseTensor` object's shape values for all dimensions but the
first are the max across the input `SparseTensor` objects' shape values
for the corresponding dimensions.  Its first shape value is `N`, the minibatch
size.

The input `SparseTensor` objects' indices are assumed ordered in
standard lexicographic order.  If this is not the case, after this
step run `SparseReorder` to restore index ordering.

For example, if the handles represent an input, which is a `[2, 3]` matrix
representing two original `SparseTensor` objects:

and

then the final `SparseTensor` will be:

Аргументы:

• scope: Объект Scope
• sparse_handles: 1-мерный массив. Последовательности N сериализованных объектов SparseTensor. Форма: [N].
• dtype: Тип dtype объектов SparseTensor, хранящихся в SparseTensorsMap.

Необязательные атрибуты (см. Attrs):

• container: Имя контейнера для SparseTensorsMap чтения этой операцией.
• shared_name: Общее имя для SparseTensorsMap чтения этой операцией. Оно не должно быть пустым; вместо этого следует использовать имя shared_name или уникальное имя операции, создавшей исходный SparseTensorsMap.

Возвращаемое значение:

• Output sparse_indices: 2-мерный массив. indices мини-пакета SparseTensor.
• Output sparse_values: 1-мерный массив. values мини-пакета SparseTensor.
• Output sparse_shape: 1-мерный массив. shape мини-пакета SparseTensor.

Публичные атрибуты

Operation operation

::tensorflow::Output sparse_indices

::tensorflow::Output sparse_shape

::tensorflow::Output sparse_values

Публичные функции

 TakeManySparseFromTensorsMap(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input sparse_handles,
  DataType dtype
)

 TakeManySparseFromTensorsMap(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input sparse_handles,
  DataType dtype,
  const TakeManySparseFromTensorsMap::Attrs & attrs
)

Публичные статические функции

Attrs Container(
  StringPiece x
)

Attrs SharedName(
  StringPiece x
)