টেনসরফ্লো :: অপস:: টেনসরম্যাপ থেকে অনেক স্পারস নিন

#include <sparse_ops.h>

একটি স্পার্স উপস্থাপনাকে ঘন টেনসরে রূপান্তরিত করে।

সারাংশ

আকার output_shape সহ একটি অ্যারে dense তৈরি করে যেটি

যদি sparse_indexs স্কেলার হয়

ঘন [i] = (i == sparse_indexes ? sparse_values ​​: default_value)

যদি sparse_indices একটি ভেক্টর হয়, তাহলে প্রতিটি i এর জন্য

ঘনত্ব

যদি sparse_indices একটি n দ্বারা d ম্যাট্রিক্স হয়, তাহলে [0, n) প্রতিটি i-এর জন্য

ঘন[স্পার্স_সূচক[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.
    Arguments:
    * 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:
 index = [ 0] [10] [20] values = [1, 2, 3] shape = [50] 

  

    
    and
 index = [ 2] [10] values = [4, 5] shape = [30] 

  

    
    then the final `SparseTensor` will be:
 index = [0 0] [0 10] [0 20] [1 2] [1 10] values = [1, 2, 3, 4, 5] shape = [2 50] ```

  
Arguments:
    
      
  • scope: A Scope object
    • 
      
  • sparse_handles: 1-D, The N serialized SparseTensor objects. Shape: [N].
    • 
      
  • dtype: The dtype of the SparseTensor objects stored in the SparseTensorsMap.
    • 
    

  
Optional attributes (see Attrs):
    
      
  • container: The container name for the SparseTensorsMap read by this op.
    • 
      
  • shared_name: The shared name for the SparseTensorsMap read by this op. It should not be blank; rather the shared_name or unique Operation name of the Op that created the original SparseTensorsMap should be used.
    • 
    

  
Returns:
    
      
  • Output sparse_indices: 2-D. The indices of the minibatch SparseTensor.
    • 
      
  • Output sparse_values: 1-D. The values of the minibatch SparseTensor.
    • 
      
  • Output sparse_shape: 1-D. The shape of the minibatch SparseTensor. 
    • 
    

                                              




        
Constructors and Destructors

      		





        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)
        

      		




                                                                                                  




        
Public attributes

      		





        operation
      

        
      





        sparse_indices
      

        
      





        sparse_shape
      

        
      





        sparse_values
      

        
      




                                                          




        
Public static functions

      		





        Container(StringPiece x)
      

        
      





        SharedName(StringPiece x)
      

        
      




                                      




        
Structs

      		





        tensorflow::ops::TakeManySparseFromTensorsMap::Attrs
      

        
Optional attribute setters for TakeManySparseFromTensorsMap. 

      		




  
Public attributes

  

    
operation

    
Operation operation
 sparse_index 
::tensorflow::Output sparse_indices
 sparse_shape 
::tensorflow::Output sparse_shape
 sparse_values 
::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
)