Real quantization cast for PTQ

Related to Issue:#59 (closed)

This MR aims to bring real quantization and Graph Integer Execution in AIDGE quantization module (Solving this issue [aidge_backend_cpu#35]):

Changes for now:

• PTQ.cpp: Creation of a CastNetwork Routine that directly cast the network into the target type. The routine differentiates between normal mode and single-shift mode, inserting either BitShift or IntQuantizer accordingly. IntQuantizer is a modified version of the quantizer operator that allows execution within a fully integer network, as this new meta-operator enables casting the input to Float and the output to Int.

Also, I added the foldGraph flag in the quantizeNetwork() function. When this flag is set to true, the pipeline will now apply the constant folding recipe to the graph, making it much simpler and more readable by 'removing' all the intermediate PTQ nodes inserted, from the user's perspective.

• PTQMetaOps.(h/c)pp Adding the new metaoperator IntQuantizer and BitShiftQuantizer

Results: We obtain exactly the same results for MiniResNet as when using the fake quantization pipeline (with and without SingleShift). For ResNet18, we observe a slight drop in accuracy from 68.7% to 67.6% in Int32 with SingleShift, due to the approximation of the Global Average Pooling operator in integer arithmetic.

Also there is now a functional testsuite to prevent regression in the PTQ pipeline (aidge_quantization/aidge_quantization/unit_tests/test_ptq.py) [#64 (closed)\]

Quick fix to solve this issue: #19 (comment 3112773)

What remains to be done:

• Add support for Int8

src/PTQ/PTQ.cpp

@@ -81,13 +81,15 @@ bool isNotQuantized(std::shared_ptr<Node> node)
 {
     return (notQuantizedNodeTypes.find(node->type()) != notQuantizedNodeTypes.end());
 }
-void clearGraphViewInputNodes(std::shared_ptr<GraphView> graphView)
+void clearGraphViewInputNodes(std::shared_ptr<GraphView> graphView,DataType targetType)
 {
     for (std::shared_ptr<Aidge::Node> input_node: graphView->inputNodes())
     {
         for (Aidge::IOIndex_t index = input_node->getFirstFreeDataInput();index < input_node->getNbFreeDataInputs(); index++)
         {
-            std::static_pointer_cast<OperatorTensor>(input_node->getOperator())->resetInput(index);
+            if(input_node->type() != "IntQuantizer" && input_node->type() != "BitShiftQuantizer") {
+            std::static_pointer_cast<OperatorTensor>(input_node->getOperator())->getInput(index)->setDataType(targetType);
+            }
         }
     }
 }
@@ -436,10 +438,6 @@ std::vector<std::shared_ptr<Node>> retrieveNodeVector(std::shared_ptr<GraphView>
     return nodeVector;    
 }
 
-static std::shared_ptr<Node> getFirstNode(std::shared_ptr<GraphView> graphView)
-{
-    return retrieveNodeVector(graphView)[0];
-}
 
 // TODO : enhance this by modifying OperatorImpl in "core" ...
 static DataType getDataType(std::shared_ptr<Node> node)
@@ -619,7 +617,7 @@ void normalizeParameters(std::shared_ptr<GraphView> graphView)
 
     // ITERATE OVER THE GRAPH /////////////////////////////////////////////////
 
-    std::shared_ptr<Node> firstNode = getFirstNode(graphView);
+    std::shared_ptr<Node> firstNode = graphView->getOrderedInputs()[0].first;
 
     for (std::shared_ptr<Node> node : nodeVector)
     {
@@ -764,8 +762,6 @@ std::unordered_map<std::shared_ptr<Node>, double> computeRanges(std::shared_ptr<
     std::unordered_map<std::shared_ptr<Node>, double> valueRanges;
     std::set<std::shared_ptr<Node>> nodeSet = graphView->getNodes();
     
-    // std::shared_ptr<Node> inputNode = getFirstNode(graphView);
-
     for (std::shared_ptr<Node> node : nodeSet)
         if ((scalingNodesOnly && hasAttr(node, "isScaling")) || (!scalingNodesOnly && (node->type() != "Producer")))
             valueRanges.insert(std::make_pair(node, 0));
@@ -833,7 +829,7 @@ std::unordered_map<std::shared_ptr<Node>, double> computeRanges(std::shared_ptr<
 
 void normalizeActivations(std::shared_ptr<GraphView> graphView, std::unordered_map<std::shared_ptr<Node>, double> valueRanges)
 {
-    std::shared_ptr<Node> firstNode = getFirstNode(graphView);
+    std::shared_ptr<Node> firstNode =  graphView->getOrderedInputs()[0].first;
 
     // CREATE THE ACCUMULATED RATIO MAP ///////////////////////////////////////
 
@@ -936,7 +932,7 @@ void normalizeActivations(std::shared_ptr<GraphView> graphView, std::unordered_m
 
 std::unordered_map<std::shared_ptr<Node>, std::pair<bool, bool>> computeSignMap(std::shared_ptr<GraphView> graphView, bool verbose)
 {
-    std::shared_ptr<Node> firstNode = getFirstNode(graphView);
+    std::shared_ptr<Node> firstNode =  graphView->getOrderedInputs()[0].first;
 
     std::unordered_map<std::shared_ptr<Node>, std::pair<bool, bool>> signMap;
 
@@ -1373,6 +1369,8 @@ void quantizeNetwork(std::shared_ptr<GraphView> graphView,
         AIDGE_ASSERT(!noQuant,"Cannot cast operators with the noQuant (Fake Quantization) flag set to true!")
         Log::notice("Starting to cast operators into the desired type ...");
         castQuantizedGraph(graphView,targetType,singleShift,bitshiftRounding);
+        graphView->updateInputsOutputs();
+        clearGraphViewInputNodes(graphView,targetType); //Convert all input tensors of the GV into targetType
     }
     else
     {
@@ -1388,7 +1386,6 @@ void quantizeNetwork(std::shared_ptr<GraphView> graphView,
     
     //Clearing input nodes
     Log::notice("Clearing all input nodes ...");
-    clearGraphViewInputNodes(graphView);
 
     if (verbose)
         printScalingFactors(graphView);