const SavedModelBundle& saved_model_bundle) {
  const protobuf::Map<std::string, std::string>& function_aliases =
      saved_model_bundle.meta_graph_def.meta_info_def().function_aliases();
  return absl::flat_hash_map<std::string, std::string>(function_aliases.begin(),
                                                       function_aliases.end());
}

}  // namespace

absl::StatusOr<mlir::ModuleOp> RunQuantization(

      module_op, checkpoint_dir, function_aliases,
      {asset_file_defs.begin(), asset_file_defs.end()});
}

ExportedModel CreateExportedModelFromGraphDef(
    GraphDef&& graph_def, const absl::string_view init_node_name,
    const absl::string_view checkpoint_dir,
    const std::optional<SaverDef> saver_def,
    const absl::flat_hash_map<FunctionName, FunctionAlias>& function_aliases,

    const std::unordered_set<std::string>& tags,
    const ::stablehlo::quantization::QuantizationConfig& quantization_config,
    absl::string_view debug_name_prefix,
    const absl::flat_hash_map<FunctionName, FunctionAlias>& function_aliases,
    MLIRContext& ctx ABSL_ATTRIBUTE_LIFETIME_BOUND, ModuleOp module_op);

// Factory function for `ExportedModel`.
[[nodiscard]] tensorflow::quantization::ExportedModel
CreateExportedModelFromGraphDef(

    std::unordered_set<std::string> tag_set(tag_names.begin(), tag_names.end());
    TF_ASSIGN_OR_RETURN(
        auto function_aliases,
        quant::stablehlo::GetFunctionAliases(input_path, tag_set));
    quant::stablehlo::UpdateFunctionAliases(function_aliases, *module_op);
    absl::c_for_each(function_aliases, [&](const auto& aliases) {
      return aliased_function_names.insert(aliases.first);
    });
  }

          src_saved_model_path,
          dst_saved_model_path,
          quant_opts_serialized,
          signature_keys=signature_def_keys,
          signature_def_map_serialized={},
          function_aliases={},
          py_function_library=py_function_lib.PyFunctionLibrary(),
          representative_dataset_file_map_serialized=None,
      )

  def test_quantize_model_fails_when_invalid_quant_options_type(self):

  // functions to the original functions' aliases. This information will be used
  // to populate `MetaInfoDef`s `function_aliases` when the quantized model is
  // exported to the saved model. This field is usually only populated for the
  // TF2 models.
  map<string, string> function_aliases = 6;

  // Holds information about the asset files used for the model. It essentially

      std::unordered_set<std::string> tags,
      absl::flat_hash_map<std::string, tensorflow::SignatureDef>
          signature_def_map,
      absl::flat_hash_map<FunctionName, FunctionAlias> function_aliases);

  // Runs the static-range post-training quantization (PTQ) on `module_op`.
  absl::StatusOr<ModuleOp> Run(
      ModuleOp module_op,
      const ::stablehlo::quantization::QuantizationConfig& config) override;

    meta_graph_def = output_loader.get_meta_graph_def_from_tags(tags)
    function_aliases = meta_graph_def.meta_info_def.function_aliases
    self.assertNotEmpty(function_aliases)
    self.assertCountEqual(function_aliases.values(), {'conv_func'})

    # Test that the aliased function contains a quantized op.
    for func_name, alias in function_aliases.items():
      if alias == 'conv_func':

    """Gets the function aliases in the output saved model."""
    loader = loader_impl.SavedModelLoader(output_saved_model_path)
    return loader.get_meta_graph_def_from_tags(
        tags
    ).meta_info_def.function_aliases

  def _create_matmul_model(
      self,
      input_shape: Sequence[int],
      weight_shape: Sequence[int],
      saved_model_path: str,
      bias_fn: Optional[ops.Operation] = None,

      signature_def_map,
      tags,
      init_op_name=exported_model.init_node_name,
      saver_def=_get_saver_def_or_none(exported_model),
      checkpoint_dir=exported_model.checkpoint_dir,
      function_aliases=exported_model.function_aliases,
      asset_file_defs=exported_model.asset_file_defs,
  )

  _copy_assets(src_saved_model_path, dst_saved_model_path)