chromium/components/segmentation_platform/internal/metadata/metadata_writer.cc

// Copyright 2022 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/40285824): Remove this and convert code to safer constructs.
#pragma allow_unsafe_buffers
#endif

#include "components/segmentation_platform/internal/metadata/metadata_writer.h"

#include <cstddef>
#include <optional>
#include <vector>

#include "base/check.h"
#include "base/metrics/metrics_hashes.h"
#include "base/strings/strcat.h"
#include "components/segmentation_platform/public/constants.h"
#include "components/segmentation_platform/public/proto/model_metadata.pb.h"

namespace segmentation_platform {

namespace {

void FillCustomInput(const MetadataWriter::CustomInput feature,
                     proto::CustomInput& input) { … }

template <typename StringVector>
void PopulateMultiClassClassifier(
    proto::Predictor::MultiClassClassifier* multi_class_classifier,
    const StringVector& class_labels,
    int top_k_outputs) { … }

}  // namespace

MetadataWriter::MetadataWriter(proto::SegmentationModelMetadata* metadata)
    : … { … }
MetadataWriter::~MetadataWriter() = default;

void MetadataWriter::AddUmaFeatures(const UMAFeature features[],
                                    size_t features_size,
                                    bool is_output) { … }

proto::SqlFeature* MetadataWriter::AddSqlFeature(const SqlFeature& feature) { … }

proto::SqlFeature* MetadataWriter::AddSqlFeature(
    const SqlFeature& feature,
    const BindValues& bind_values) { … }

proto::CustomInput* MetadataWriter::AddCustomInput(const CustomInput& feature) { … }

void MetadataWriter::AddDiscreteMappingEntries(
    const std::string& key,
    const std::pair<float, int>* mappings,
    size_t mappings_size) { … }

void MetadataWriter::AddBooleanSegmentDiscreteMapping(const std::string& key) { … }

void MetadataWriter::AddBooleanSegmentDiscreteMappingWithSubsegments(
    const std::string& key,
    float threshold,
    int max_value) { … }

void MetadataWriter::SetSegmentationMetadataConfig(
    proto::TimeUnit time_unit,
    uint64_t bucket_duration,
    int64_t signal_storage_length,
    int64_t min_signal_collection_length,
    int64_t result_time_to_live) { … }

void MetadataWriter::SetDefaultSegmentationMetadataConfig(
    int min_signal_collection_length_days,
    int signal_storage_length_days) { … }

void MetadataWriter::AddOutputConfigForBinaryClassifier(
    float threshold,
    const std::string& positive_label,
    const std::string& negative_label) { … }

void MetadataWriter::SetIgnorePreviousModelTTLInOutputConfig() { … }

void MetadataWriter::AddOutputConfigForMultiClassClassifier(
    base::span<const char* const> class_labels,
    int top_k_outputs,
    std::optional<float> threshold) { … }

void MetadataWriter::AddOutputConfigForMultiClassClassifier(
    const std::vector<std::string>& class_labels,
    int top_k_outputs,
    std::optional<float> threshold) { … }

void MetadataWriter::AddOutputConfigForMultiClassClassifier(
    base::span<const char* const> class_labels,
    int top_k_outputs,
    const base::span<float> per_class_thresholds) { … }

void MetadataWriter::AddOutputConfigForBinnedClassifier(
    const std::vector<std::pair<float, std::string>>& bins,
    std::string underflow_label) { … }

void MetadataWriter::AddOutputConfigForGenericPredictor(
    const std::vector<std::string>& labels) { … }

void MetadataWriter::AddPredictedResultTTLInOutputConfig(
    std::vector<std::pair<std::string, std::int64_t>> top_label_to_ttl_list,
    int64_t default_ttl,
    proto::TimeUnit time_unit) { … }

void MetadataWriter::AddDelayTrigger(uint64_t delay_sec) { … }

void MetadataWriter::AddFromInputContext(const char* custom_input_name,
                                         const char* additional_args_name) { … }

}  // namespace segmentation_platform