luci::SparsifyTensorPass Struct Reference

Pass to sparsify tensor. More...

#include <SparsifyTensorPass.h>

Collaboration diagram for luci::SparsifyTensorPass:

Public Member Functions
	SparsifyTensorPass (const std::string &tensor_name, const std::vector< int32_t > &traversal_order, const std::vector< DimensionType > &format, const std::vector< int32_t > &block_size, const std::vector< int32_t > &block_map)
const char *	name (void) const final
bool	run (loco::Graph *g) final
	Run the pass.
template<loco::DataType DT>
void	sparsify_tensor (luci::CircleConst *cop)
Public Member Functions inherited from logo::Pass
virtual	~Pass ()=default

Detailed Description

Pass to sparsify tensor.

Definition at line 32 of file SparsifyTensorPass.h.

Constructor & Destructor Documentation

SparsifyTensorPass()

luci::SparsifyTensorPass::SparsifyTensorPass ( const std::string &  tensor_name, const std::vector< int32_t > &  traversal_order, const std::vector< DimensionType > &  format, const std::vector< int32_t > &  block_size, const std::vector< int32_t > &  block_map  )

inline

Definition at line 35 of file SparsifyTensorPass.h.

    : _tensor_name{tensor_name}, _traversal_order{traversal_order}, _format{format},
      _block_size{block_size}, _block_map{block_map}
  {
    // DO NOTHING
  }

Member Function Documentation

name()

const char * luci::SparsifyTensorPass::name ( void  ) const

inlinefinalvirtual

Reimplemented from logo::Pass.

Definition at line 45 of file SparsifyTensorPass.h.

{ return "luci::SparsifyTensorPass"; }

run()

bool luci::SparsifyTensorPass::run ( loco::Graph *  graph )

finalvirtual

Run the pass.

Returns

false if there was nothing changed

Implements logo::Pass.

Definition at line 87 of file SparsifyTensorPass.cpp.

{
  bool changed = false;
  for (auto node : loco::active_nodes(loco::output_nodes(g)))
  {
    auto cop = dynamic_cast<luci::CircleConst *>(node);
    if (not cop)
      continue;
 
    if (cop->name() != _tensor_name)
      continue;
 
    switch (cop->dtype())
    {
      case loco::DataType::S32:
        sparsify_tensor<loco::DataType::S32>(cop);
        break;
      case loco::DataType::S8:
        sparsify_tensor<loco::DataType::S8>(cop);
        break;
      case loco::DataType::FLOAT32:
        sparsify_tensor<loco::DataType::FLOAT32>(cop);
        break;
      default:
        throw std::runtime_error("SparsifyTensorPass: Unsupported dtype.");
    }
    changed = true;
  }
 
  return changed;
}

References loco::active_nodes(), loco::output_nodes(), luci::SparsifyTensorPass::sparsify_tensor< loco::DataType::FLOAT32 >(), luci::SparsifyTensorPass::sparsify_tensor< loco::DataType::S32 >(), and luci::SparsifyTensorPass::sparsify_tensor< loco::DataType::S8 >().

Referenced by package.infer.session::inference(), and luci::CircleOptimizer::sparsify().

sparsify_tensor()

template<loco::DataType DT>

template void luci::SparsifyTensorPass::sparsify_tensor< loco::DataType::FLOAT32 >

(

luci::CircleConst *

cop

)

Definition at line 26 of file SparsifyTensorPass.cpp.

{
  using PRIMITIVE_DTYPE = typename loco::DataTypeImpl<DT>::Type;
 
  std::vector<int32_t> dense_tensor_shape(cop->rank());
  for (uint32_t d = 0; d < cop->rank(); d++)
  {
    dense_tensor_shape.at(d) = cop->dim(d).value();
  }
 
  Sparsifier<PRIMITIVE_DTYPE> sparsifier(dense_tensor_shape, _traversal_order, _format, _block_size,
                                         _block_map);
  // get dense tensor data
  uint32_t dense_tensor_data_size = cop->size<DT>();
  std::vector<PRIMITIVE_DTYPE> dense_tensor_data(dense_tensor_data_size);
  for (uint32_t i = 0; i < dense_tensor_data_size; i++)
  {
    dense_tensor_data.at(i) = cop->at<DT>(i);
  }
  // sparsify
  sparsifier.DenseToSparse(dense_tensor_data.data());
  // get sparse tensor data
  std::vector<PRIMITIVE_DTYPE> sparse_tensor_data = sparsifier.GetData();
  uint32_t sparse_tensor_data_size = sparse_tensor_data.size();
  cop->size<DT>(sparse_tensor_data_size);
  for (uint32_t i = 0; i < sparse_tensor_data_size; i++)
  {
    cop->at<DT>(i) = sparse_tensor_data.at(i);
  }
  // make sparsity parameter
  auto sparsityparam = std::make_unique<SparsityParam>();
  sparsityparam->traversal_order = _traversal_order;
  sparsityparam->block_map = _block_map;
  // get dimension meta data
  const auto dim_metadata = sparsifier.GetDimMetadata();
  for (uint32_t idx = 0; idx < _format.size(); idx++)
  {
    if (_format.at(idx) == DimensionType::DENSE)
    {
      sparsityparam->dim_metadata.emplace_back(DimensionType::DENSE,
                                               dim_metadata.at(idx * 2).at(0));
    }
    // TODO Set SparseIndexVectorType according to its data range
    else if (_format.at(idx) == DimensionType::SPARSE_CSR)
    {
      sparsityparam->dim_metadata.emplace_back(
        DimensionType::SPARSE_CSR, /* dense size */ 0,
        /* array_segments */
        SparseIndexVector{SparseIndexVectorType::U16, dim_metadata.at(idx * 2)},
        /* array_indices */
        SparseIndexVector{SparseIndexVectorType::U16, dim_metadata.at(idx * 2 + 1)});
    }
  }
  for (uint32_t i = 0; i < _block_size.size(); i++)
  {
    assert(_block_size.at(i) == dim_metadata.at((_format.size() + i) * 2).at(0));
    sparsityparam->dim_metadata.emplace_back(DimensionType::DENSE, _block_size.at(i));
  }
  cop->sparsityparam(std::move(sparsityparam));
}

References luci::CircleConst::at(), luci::DENSE, luci::Sparsifier< T >::DenseToSparse(), luci::Sparsifier< T >::GetData(), luci::Sparsifier< T >::GetDimMetadata(), luci::CircleConst::size(), luci::SPARSE_CSR, luci::CircleNode::sparsityparam(), and luci::U16.

---

The documentation for this struct was generated from the following files:

• compiler/luci/pass/include/luci/Pass/SparsifyTensorPass.h
• compiler/luci/pass/src/SparsifyTensorPass.cpp