Add some inference API comments for AnalysisPredictor (#23242)

* add inference api doc. test=develop

paddle/fluid/inference/api/paddle_mkldnn_quantizer_config.h

@@ -11,6 +11,17 @@
 // 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.
+
+///
+/// \file paddle_mkldnn_quantizer_config.h
+///
+/// \brief Mkldnn quantizer config.
+///
+/// \author paddle-infer@baidu.com
+/// \date 2020-01-01
+/// \since 1.7.0
+///
+
 #pragma once
 
 #include <cassert>
@@ -24,75 +35,155 @@
 
 namespace paddle {
 
-// Algorithms for finding scale of quantized Tensors.
+///
+/// \brief Algorithms for finding scale of quantized Tensors.
+///
 enum class ScaleAlgo {
-  NONE,      // Do not compute scale
-  MAX,       // Find scale based on the max absolute value
-  MAX_CH,    // Find scale based on the max absolute value per output channel
-  MAX_CH_T,  // Find scale based on the max absolute value per output channel
-             // of a transposed tensor
-  KL,        // Find scale based on KL Divergence
+  NONE,      ///< Do not compute scale
+  MAX,       ///< Find scale based on the max absolute value
+  MAX_CH,    ///< Find scale based on the max absolute value per output channel
+  MAX_CH_T,  ///< Find scale based on the max absolute value per output channel
+             ///< of a transposed tensor
+  KL,        ///< Find scale based on KL Divergence
 };
 
+///
+/// \class MkldnnQuantizerConfig
+///
+/// \brief Config for mkldnn quantize.
+///
+/// The MkldnnQuantizerConfig is used to configure Mkldnn's quantization
+/// parameters, including scale algorithm, warmup data, warmup batch size,
+/// quantized op list, etc.
+///
+/// It is not recommended to use this config directly, please refer to
+/// AnalysisConfig::mkldnn_quantizer_config()
+///
 struct MkldnnQuantizerConfig {
+  ///
+  /// \brief Construct a new Mkldnn Quantizer Config object
+  ///
   MkldnnQuantizerConfig();
 
-  /** Specify a quantization algorithm for a connection (input/output) of the
-   * operator type.
-   * @param op_type_name the operator's name.
-   * @param conn_name name of the connection (input/output) of the operator.
-   * @param algo the algorithm for computing scale.
-   */
+  ///
+  /// \brief Set the scale algo
+  ///
+  /// Specify a quantization algorithm for a connection (input/output) of the
+  /// operator type.
+  /// \param[in] op_type_name the operator's name.
+  /// \param[in] conn_name name of the connection (input/output) of the
+  /// operator.
+  /// \param[in] algo the algorithm for computing scale.
+  ///
   void SetScaleAlgo(std::string op_type_name, std::string conn_name,
                     ScaleAlgo algo) {
     rules_[op_type_name][conn_name] = algo;
   }
 
-  /** Get the quantization algorithm for a connection (input/output) of the
-   * operator type.
-   * @param op_type_name the operator's name.
-   * @param conn_name name of the connection (input/output) of the operator.
-   * @return the algorithm for computing scale.
-   */
+  ///
+  /// \brief Get the scale algo
+  ///
+  /// Get the quantization algorithm for a connection (input/output) of the
+  /// operator type.
+  ///
+  /// \param[in] op_type_name the operator's name.
+  /// \param[in] conn_name name of the connection (input/output) of the
+  /// operator.
+  /// \return the scale algo.
+  ///
   ScaleAlgo scale_algo(const std::string& op_type_name,
                        const std::string& conn_name) const;
 
-  /** Set the batch of data to be used for warm-up iteration.
-   * @param data batch of data.
-   */
+  ///
+  /// \brief Set the warmup data
+  ///
+  /// Set the batch of data to be used for warm-up iteration.
+  ///
+  /// \param[in] data batch of data.
+  ///
   void SetWarmupData(std::shared_ptr<std::vector<PaddleTensor>> data) {
     warmup_data_ = data;
   }
 
-  /** Get the batch of data used for warm-up iteration.
-   * @return batch of data.
-   */
+  ///
+  /// \brief Get the warmup data
+  ///
+  /// Get the batch of data used for warm-up iteration.
+  ///
+  /// \return the warm up data
+  ///
   std::shared_ptr<std::vector<PaddleTensor>> warmup_data() const {
     return warmup_data_;
   }
 
+  ///
+  /// \brief Set the warmup batch size
+  ///
+  /// Set the batch size for warm-up iteration.
+  ///
+  /// \param[in] batch_size warm-up batch size
+  ///
   void SetWarmupBatchSize(int batch_size) { warmup_bs_ = batch_size; }
 
+  ///
+  /// \brief Get the warmup batch size
+  ///
+  /// Get the batch size for warm-up iteration.
+  ///
+  /// \return the warm up batch size
   int warmup_batch_size() const { return warmup_bs_; }
 
+  ///
+  /// \brief Set quantized op list
+  ///
+  /// In the quantization process, set the op list that supports quantization
+  ///
+  /// \param[in] op_list List of quantized ops
+  ///
   void SetEnabledOpTypes(std::unordered_set<std::string> op_list) {
     enabled_op_types_ = op_list;
   }
 
+  ///
+  /// \brief Get quantized op list
+  ///
+  /// \return list of quantized ops
+  ///
   const std::unordered_set<std::string>& enabled_op_types() const {
     return enabled_op_types_;
   }
 
+  ///
+  /// \brief Set the excluded op ids
+  ///
+  /// \param[in] op_ids_list excluded op ids
+  ///
   void SetExcludedOpIds(std::unordered_set<int> op_ids_list) {
     excluded_op_ids_ = op_ids_list;
   }
 
+  ///
+  /// \brief Get the excluded op ids
+  ///
+  /// \return exclude op ids
+  ///
   const std::unordered_set<int>& excluded_op_ids() const {
     return excluded_op_ids_;
   }
 
+  ///
+  /// \brief Set default scale algorithm
+  ///
+  /// \param[in] algo Method for calculating scale in quantization process
+  ///
   void SetDefaultScaleAlgo(ScaleAlgo algo) { default_scale_algo_ = algo; }
 
+  ///
+  /// \brief Get default scale algorithm
+  ///
+  /// \return Method for calculating scale in quantization
+  /// process
+  ///
   ScaleAlgo default_scale_algo() const { return default_scale_algo_; }
 
  protected: