[luci] Introduce Compress weights pass

This commit introduces CopressWeightsPass for Conv2D

ONE-DCO-1.0-Signed-off-by: Vyacheslav Bazhenov <[email protected]>

compiler/circle2circle/src/Circle2Circle.cpp

@@ -184,6 +184,8 @@ int entry(int argc, char **argv)
              "This will convert single input Transpose to Reshape");
   add_switch(arser, "--expand_broadcast_const", "This will expand broadcastable constant inputs");
   add_switch(arser, "--unroll_unidirseqlstm", "Unroll UnidirectionalSequenceLSTM operator.");
+  add_switch(arser, "--compress_weights_huffman",
+             "Loseless weights compression with Huffman encoding.");
   add_switch(arser, "--convert_nchw_to_nhwc",
              "Experimental: This will convert NCHW operators to NHWC under the assumption that "
              "input model is NCHW.");
@@ -405,6 +407,8 @@ int entry(int argc, char **argv)
     options->enable(Algorithms::ExpandBroadcastConst);
   if (arser.get<bool>("--unroll_unidirseqlstm"))
     options->enable(Algorithms::UnrollUnidirSeqLSTM);
+  if (arser.get<bool>("--compress_weights_huffman"))
+    options->enable(Algorithms::CompressWeightsHuffman);
 
   // NOTE Experimental options; these will be removed someday
   //      Add experimental options here

compiler/luci/export/src/CircleBuiltinTypesExtractor.h

@@ -108,10 +108,10 @@ class BuiltinOptionsExtractor final
   // flatbuffers::Offset<void> visit(luci::CircleConst *)
   flatbuffers::Offset<void> visit(luci::CircleConv2D *node)
   {
-    return circle::CreateConv2DOptions(_builder, getOpPadding(node->padding()), node->stride()->w(),
-                                       node->stride()->h(),
-                                       to_circle_actfunc(node->fusedActivationFunction()),
-                                       node->dilation()->w(), node->dilation()->h())
+    return circle::CreateConv2DOptions(
+             _builder, getOpPadding(node->padding()), node->stride()->w(), node->stride()->h(),
+             to_circle_actfunc(node->fusedActivationFunction()), node->dilation()->w(),
+             node->dilation()->h(), to_circle_weightcompressiontype(node->weightCompression()))
       .Union();
   }
   flatbuffers::Offset<void> visit(luci::CircleCos *)

compiler/luci/export/src/CircleExporterUtils.cpp

@@ -24,6 +24,19 @@
 
 namespace luci
 {
+circle::WeightCompressionType to_circle_weightcompressiontype(luci::WeightCompression type)
+{
+  switch (type)
+  {
+    case luci::WeightCompression::NONE:
+      return circle::WeightCompressionType_NONE;
+    case luci::WeightCompression::HUFFMAN:
+      return circle::WeightCompressionType_Huffman;
+    default:
+      INTERNAL_EXN_V("trying to convert unsupported luci::WeightCompression",
+                     oops::to_uint32(type));
+  }
+}
 
 circle::ActivationFunctionType to_circle_actfunc(luci::FusedActFunc func)
 {

compiler/luci/export/src/CircleExporterUtils.h

@@ -29,6 +29,7 @@
 namespace luci
 {
 
+circle::WeightCompressionType to_circle_weightcompressiontype(luci::WeightCompression type);
 circle::ActivationFunctionType to_circle_actfunc(luci::FusedActFunc func);
 circle::TensorType to_circle_tensortype(loco::DataType type);
 circle::MirrorPadMode to_circle_mirrorpadmode(luci::MirrorPadMode mode);

compiler/luci/export/src/CircleTensorExporter.cpp

@@ -559,6 +559,8 @@ bool has_same_values(luci::CircleConst *lhs, luci::CircleConst *rhs)
       return has_same_elements<loco::DataType::S4>(lhs, rhs);
 
     case loco::DataType::S8:
+      if (lhs->size<loco::DataType::S8>() != rhs->size<loco::DataType::S8>())
+        return false;
       return has_same_elements<loco::DataType::S8>(lhs, rhs);
 
     case loco::DataType::S16:
@@ -574,6 +576,8 @@ bool has_same_values(luci::CircleConst *lhs, luci::CircleConst *rhs)
       return has_same_elements<loco::DataType::U4>(lhs, rhs);
 
     case loco::DataType::U8:
+      if (lhs->size<loco::DataType::U8>() != rhs->size<loco::DataType::U8>())
+        return false;
       return has_same_elements<loco::DataType::U8>(lhs, rhs);
 
     case loco::DataType::BOOL:

compiler/luci/import/include/luci/Import/CircleImporterUtils.h

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2024 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __CIRCLE_IMPORTER_UTILS_H__
+#define __CIRCLE_IMPORTER_UTILS_H__
+
+#include <luci/IR/CircleNodes.h>
+
+#include <loco.h>
+
+#include <mio/circle/schema_generated.h>
+
+namespace luci
+{
+luci::WeightCompression from_circle_weightcompressiontype(circle::WeightCompressionType type);
+
+} // namespace luci
+
+#endif // __CIRCLE_IMPORTER_UTILS_H__

compiler/luci/import/src/CircleImporterUtils.cpp

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "luci/Import/CircleImporterUtils.h"
+
+#include <oops/InternalExn.h>
+
+namespace luci
+{
+luci::WeightCompression from_circle_weightcompressiontype(circle::WeightCompressionType type)
+{
+  switch (type)
+  {
+    case circle::WeightCompressionType_NONE:
+      return luci::WeightCompression::NONE;
+    case circle::WeightCompressionType_Huffman:
+      return luci::WeightCompression::HUFFMAN;
+    default:
+      INTERNAL_EXN_V("trying to convert unsupported luci::WeightCompression",
+                     oops::to_uint32(type));
+  }
+}
+} // namespace luci

compiler/luci/import/src/Nodes/CircleConv2D.cpp

@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
+#include "luci/Import/CircleImporterUtils.h"
 #include "luci/Import/Nodes/CircleConv2D.h"
 
 #include <luci/IR/Nodes/CircleConv2D.h>
-
 #include <loco.h>
 
 #include <cassert>
@@ -49,6 +49,7 @@ CircleNode *CircleConv2DGraphBuilder::build_node(const circle::OperatorT &op,
   node->fusedActivationFunction(luci_actfunc(options->fused_activation_function));
   node->dilation()->w(options->dilation_w_factor);
   node->dilation()->h(options->dilation_h_factor);
+  node->weightCompression(from_circle_weightcompressiontype(options->weight_compression_type));
 
   return node;
 }

compiler/luci/lang/include/luci/IR/AttrWeightCompression.h

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2024 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __LUCI_IR_ATTRWEIGHTCOMPRESSION_H__
+#define __LUCI_IR_ATTRWEIGHTCOMPRESSION_H__
+
+namespace luci
+{
+
+enum class WeightCompression
+{
+  UNDEFINED, // This is not defined by TFLite or Circle. This was added to
+             // prevent programming error.
+  NONE,
+  HUFFMAN
+};
+
+} // namespace luci
+
+#endif // __LUCI_IR_ATTRWEIGHTCOMPRESSION_H__

compiler/luci/lang/include/luci/IR/CircleNodeMixins.h

@@ -18,6 +18,7 @@
 #define __LUCI_IR_CIRCLE_NODE_MIXINS_H__
 
 #include "luci/IR/AttrFusedActFunc.h"
+#include "luci/IR/AttrWeightCompression.h"
 
 #include <loco/IR/Node.h>
 #include <loco/IR/NodeMixins.h>
@@ -31,11 +32,28 @@ namespace luci
 enum class CircleNodeTrait
 {
   FusedActFunc,
-  Bias
+  Bias,
+  WeightCompression
 };
 
 template <CircleNodeTrait T> class CircleNodeMixin;
 
+template <> class CircleNodeMixin<CircleNodeTrait::WeightCompression>
+{
+public:
+  CircleNodeMixin() = default;
+
+public:
+  WeightCompression weightCompression() const { return _weight_compression; }
+  void weightCompression(WeightCompression weight_compression)
+  {
+    _weight_compression = weight_compression;
+  }
+
+private:
+  WeightCompression _weight_compression = WeightCompression::UNDEFINED;
+};
+
 template <> class CircleNodeMixin<CircleNodeTrait::FusedActFunc>
 {
 public:

compiler/luci/lang/include/luci/IR/Nodes/CircleConst.h

@@ -17,6 +17,7 @@
 #ifndef __LUCI_IR_CIRCLECONST_H__
 #define __LUCI_IR_CIRCLECONST_H__
 
+#include "luci/IR/AttrWeightCompression.h"
 #include "luci/IR/CircleNodeDecl.h"
 #include "luci/IR/CircleOpcode.h"
 
@@ -34,6 +35,9 @@ namespace luci
 class CircleConst final : public FixedArityNode<0, CircleNodeImpl<CircleOpcode::CIRCLECONST>>
 {
 public:
+  template <loco::DataType DT> WeightCompression compression(void) const;
+  template <loco::DataType DT> void compression(WeightCompression c);
+
   template <loco::DataType DT> uint32_t size(void) const;
   template <loco::DataType DT> void size(uint32_t size);
   template <loco::DataType DT> const typename loco::DataTypeImpl<DT>::Type &at(uint32_t n) const;
@@ -46,6 +50,7 @@ class CircleConst final : public FixedArityNode<0, CircleNodeImpl<CircleOpcode::
   std::vector<uint8_t> _data;
   // TODO use _data for STRING and remove _strings
   std::vector<std::string> _strings; // for STRING type
+  WeightCompression _compression{WeightCompression::NONE};
 };
 
 } // namespace luci

compiler/luci/lang/include/luci/IR/Nodes/CircleConv2D.h

@@ -34,7 +34,8 @@ namespace luci
  */
 class CircleConv2D final : public FixedArityNode<3, CircleNodeImpl<CircleOpcode::CONV_2D>>,
                            public CircleNodeMixin<CircleNodeTrait::FusedActFunc>,
-                           public CircleNodeMixin<CircleNodeTrait::Bias>
+                           public CircleNodeMixin<CircleNodeTrait::Bias>,
+                           public CircleNodeMixin<CircleNodeTrait::WeightCompression>
 {
 public:
   loco::Node *input(void) const { return at(0)->node(); }

compiler/luci/lang/src/Nodes/CircleConst.cpp

@@ -20,6 +20,17 @@
 
 namespace luci
 {
+template <loco::DataType DT> WeightCompression CircleConst::compression(void) const
+{
+  assert(dtype() == DT);
+  return _compression;
+}
+
+template <loco::DataType DT> void CircleConst::compression(luci::WeightCompression c)
+{
+  assert(dtype() == DT);
+  _compression = c;
+}
 
 template <loco::DataType DT> uint32_t CircleConst::size(void) const
 {
@@ -63,6 +74,8 @@ template <loco::DataType DT> typename loco::DataTypeImpl<DT>::Type &CircleConst:
 }
 
 #define INSTANTIATE(DT)                                                                      \
+  template WeightCompression CircleConst::compression<DT>(void) const;                       \
+  template void CircleConst::compression<DT>(WeightCompression);                             \
   template uint32_t CircleConst::size<DT>(void) const;                                       \
   template void CircleConst::size<DT>(uint32_t);                                             \
   template const typename loco::DataTypeImpl<DT>::Type &CircleConst::at<DT>(uint32_t) const; \

compiler/luci/pass/include/luci/CircleOptimizer.h

@@ -109,6 +109,7 @@ class CircleOptimizer final
       UnrollUnidirSeqLSTM,
       XpSepActFromTransposeConv,
       RemoveGatherGuard,
+      CompressWeightsHuffman
     };
 
     enum AlgorithmParameters

compiler/luci/pass/include/luci/Pass/CompressWeightsPass.h

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2024 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __LUCI_COMPRESS_WEIGHTS_PASS_H__
+#define __LUCI_COMPRESS_WEIGHTS_PASS_H__
+
+#include <logo/Pass.h>
+
+namespace luci
+{
+
+/**
+ * @brief  Class to generate FC/CONV with compressed weights
+ *
+ * To see the target Op pattern, please visit implementation.
+ */
+struct CompressWeightsPass final : public logo::Pass
+{
+  const char *name(void) const final { return "luci::CompressWeightsPass"; }
+
+  bool run(loco::Graph *g) final;
+};
+
+} // namespace luci
+
+#endif // __LUCI_COMPRESS_WEIGHTS_PASS_H__

compiler/luci/pass/src/CircleOptimizer.cpp

@@ -92,6 +92,7 @@
 #include "luci/Pass/DecomposeSoftmaxPass.h"
 #include "luci/Pass/UnrollUnidirectionalSequenceLSTMPass.h"
 #include "luci/Pass/XpSepActFromTransposeConvPass.h"
+#include "luci/Pass/CompressWeightsPass.h"
 // TODO add more passes
 
 #include "luci/Pass/CircleShapeInferencePass.h"
@@ -534,7 +535,10 @@ void CircleOptimizer::optimize(loco::Graph *g) const
   {
     phase.emplace_back(std::make_unique<luci::UnrollUnidirectionalSequenceLSTMPass>());
   }
-
+  if (_options->query(Options::Algorithm::CompressWeightsHuffman))
+  {
+    phase.emplace_back(std::make_unique<luci::CompressWeightsPass>());
+  }
   // NOTE Experimental options; these will be removed someday
   //      Add experimental options here
   if (_options->query(Options::Algorithm::XpSepActFromTransposeConv))