Draft: Add QAT

Implement QAT in Aidge. This MR aims to reach iso-functionalities with N2D2. Beyond simple iso-functionalities, this MR includes many code cleaning, factorization and optimization vs N2D2, and also makes extensive use of graph matching. The eventual goal is to make QAT developement in Aidge simpler and more powerful than ever... and most importantly, provide direct bit-accurate true quantization with optimized scaling strategies for hardware designers

• Enable CUDA build;
• Implement QAT operators.
  • Base LSQ operators;
  • Base SAT operators;
  • LSQ CPU implementations;
  • SAT CPU implementations (for half, float and double precision);
  • LSQ CUDA implementations;
  • SAT CUDA implementations (for half, float and double precision).
• Implement LSQ graph transformation recipes for QAT;
• Implement SAT graph transformation recipes for QAT;
• Implement LSQ QAT training recipe examples Requires working CUDA training first;
• Implement SAT QAT training recipe examples Requires working CUDA training first;
• Implement LSQ graph transformations recipes for export Did not exist in N2D2;
• Implement SAT graph transformations recipes for export WIP.
  • Scaling Operator adaptation;
  • Clipping Operator.

Tests and validation:

• Pre-req: CUDA MNIST training on LeNet
• Validation on LeNet
• Pre-req: CUDA ImageNet training on MobileNetv1
• Validation on MobileNetv1
• Pre-req: CUDA ImageNet training on MobileNetv2
• Validation on MobileNetv2
• Pre-req: CUDA ImageNet training on ResNet18
• Validation on ResNet18

include/aidge/backend/cpu/operator/CG-PACTImpl.hpp

+/********************************************************************************
+ * Copyright (c) 2023 CEA-List
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ ********************************************************************************/
+
+#ifndef AIDGE_CPU_OPERATOR_CGPACTIMPL_H_
+#define AIDGE_CPU_OPERATOR_CGPACTIMPL_H_
+
+#include <cstddef>  // std::size_t
+#include <memory>
+#include <tuple>    // std::tuple
+#include <vector>
+
+#include "aidge/backend/OperatorImpl.hpp"
+#include "aidge/operator/CG-PACT.hpp"
+#include "aidge/utils/Registrar.hpp"
+#include "aidge/utils/Types.h"
+
+namespace Aidge {
+// compute kernel registry for forward and backward
+class CGPACTImplForward_cpu
+    : public Registrable<CGPACTImplForward_cpu, std::tuple<DataType, DataType>, void(const std::size_t, size_t, const void*, const void*, void*)> {
+};
+class CGPACTImplBackward_cpu
+    : public Registrable<CGPACTImplBackward_cpu, std::tuple<DataType, DataType, DataType>, void(const std::size_t, size_t, const void*, const void*, const void*, void*, void*)> {
+};
+
+class CGPACTImpl_cpu : public OperatorImpl {
+public:
+    CGPACTImpl_cpu(const CGPACT_Op& op) : OperatorImpl(op, "cpu") {}
+
+    static std::unique_ptr<CGPACTImpl_cpu> create(const CGPACT_Op& op) {
+        return std::make_unique<CGPACTImpl_cpu>(op);
+    }
+
+    void forward() override final;
+
+    void backward() override final;
+};
+
+namespace {
+static Registrar<CGPACT_Op> registrarCGPACTImpl_cpu("cpu", Aidge::CGPACTImpl_cpu::create);
+}
+}  // namespace Aidge
+
+#endif /* AIDGE_CPU_OPERATOR_CGPACTIMPL_H_ */