/*
|
* Copyright (C) 2018 The Android Open Source Project
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* 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.
|
*/
|
|
#include "actions/actions-suggestions.h"
|
|
#include <fstream>
|
#include <iterator>
|
#include <memory>
|
|
#include "actions/actions_model_generated.h"
|
#include "actions/test_utils.h"
|
#include "actions/zlib-utils.h"
|
#include "annotator/collections.h"
|
#include "annotator/types.h"
|
#include "utils/flatbuffers.h"
|
#include "utils/flatbuffers_generated.h"
|
#include "utils/hash/farmhash.h"
|
#include "gmock/gmock.h"
|
#include "gtest/gtest.h"
|
#include "flatbuffers/flatbuffers.h"
|
#include "flatbuffers/reflection.h"
|
|
namespace libtextclassifier3 {
|
namespace {
|
using testing::_;
|
|
constexpr char kModelFileName[] = "actions_suggestions_test.model";
|
constexpr char kHashGramModelFileName[] =
|
"actions_suggestions_test.hashgram.model";
|
|
std::string ReadFile(const std::string& file_name) {
|
std::ifstream file_stream(file_name);
|
return std::string(std::istreambuf_iterator<char>(file_stream), {});
|
}
|
|
std::string GetModelPath() {
|
return "";
|
}
|
|
class ActionsSuggestionsTest : public testing::Test {
|
protected:
|
ActionsSuggestionsTest() : INIT_UNILIB_FOR_TESTING(unilib_) {}
|
std::unique_ptr<ActionsSuggestions> LoadTestModel() {
|
return ActionsSuggestions::FromPath(GetModelPath() + kModelFileName,
|
&unilib_);
|
}
|
std::unique_ptr<ActionsSuggestions> LoadHashGramTestModel() {
|
return ActionsSuggestions::FromPath(GetModelPath() + kHashGramModelFileName,
|
&unilib_);
|
}
|
UniLib unilib_;
|
};
|
|
TEST_F(ActionsSuggestionsTest, InstantiateActionSuggestions) {
|
EXPECT_THAT(LoadTestModel(), testing::NotNull());
|
}
|
|
TEST_F(ActionsSuggestionsTest, SuggestActions) {
|
std::unique_ptr<ActionsSuggestions> actions_suggestions = LoadTestModel();
|
const ActionsSuggestionsResponse& response =
|
actions_suggestions->SuggestActions(
|
{{{/*user_id=*/1, "Where are you?", /*reference_time_ms_utc=*/0,
|
/*reference_timezone=*/"Europe/Zurich",
|
/*annotations=*/{}, /*locales=*/"en"}}});
|
EXPECT_EQ(response.actions.size(), 3 /* share_location + 2 smart replies*/);
|
}
|
|
TEST_F(ActionsSuggestionsTest, SuggestNoActionsForUnknownLocale) {
|
std::unique_ptr<ActionsSuggestions> actions_suggestions = LoadTestModel();
|
const ActionsSuggestionsResponse& response =
|
actions_suggestions->SuggestActions(
|
{{{/*user_id=*/1, "Where are you?", /*reference_time_ms_utc=*/0,
|
/*reference_timezone=*/"Europe/Zurich",
|
/*annotations=*/{}, /*locales=*/"zz"}}});
|
EXPECT_THAT(response.actions, testing::IsEmpty());
|
}
|
|
TEST_F(ActionsSuggestionsTest, SuggestActionsFromAnnotations) {
|
std::unique_ptr<ActionsSuggestions> actions_suggestions = LoadTestModel();
|
AnnotatedSpan annotation;
|
annotation.span = {11, 15};
|
annotation.classification = {ClassificationResult("address", 1.0)};
|
const ActionsSuggestionsResponse& response =
|
actions_suggestions->SuggestActions(
|
{{{/*user_id=*/1, "are you at home?",
|
/*reference_time_ms_utc=*/0,
|
/*reference_timezone=*/"Europe/Zurich",
|
/*annotations=*/{annotation},
|
/*locales=*/"en"}}});
|
ASSERT_GE(response.actions.size(), 1);
|
EXPECT_EQ(response.actions.front().type, "view_map");
|
EXPECT_EQ(response.actions.front().score, 1.0);
|
}
|
|
TEST_F(ActionsSuggestionsTest, SuggestActionsFromAnnotationsWithEntityData) {
|
const std::string actions_model_string =
|
ReadFile(GetModelPath() + kModelFileName);
|
std::unique_ptr<ActionsModelT> actions_model =
|
UnPackActionsModel(actions_model_string.c_str());
|
SetTestEntityDataSchema(actions_model.get());
|
|
// Set custom actions from annotations config.
|
actions_model->annotation_actions_spec->annotation_mapping.clear();
|
actions_model->annotation_actions_spec->annotation_mapping.emplace_back(
|
new AnnotationActionsSpec_::AnnotationMappingT);
|
AnnotationActionsSpec_::AnnotationMappingT* mapping =
|
actions_model->annotation_actions_spec->annotation_mapping.back().get();
|
mapping->annotation_collection = "address";
|
mapping->action.reset(new ActionSuggestionSpecT);
|
mapping->action->type = "save_location";
|
mapping->action->score = 1.0;
|
mapping->action->priority_score = 2.0;
|
mapping->entity_field.reset(new FlatbufferFieldPathT);
|
mapping->entity_field->field.emplace_back(new FlatbufferFieldT);
|
mapping->entity_field->field.back()->field_name = "location";
|
|
flatbuffers::FlatBufferBuilder builder;
|
FinishActionsModelBuffer(builder,
|
ActionsModel::Pack(builder, actions_model.get()));
|
std::unique_ptr<ActionsSuggestions> actions_suggestions =
|
ActionsSuggestions::FromUnownedBuffer(
|
reinterpret_cast<const uint8_t*>(builder.GetBufferPointer()),
|
builder.GetSize(), &unilib_);
|
|
AnnotatedSpan annotation;
|
annotation.span = {11, 15};
|
annotation.classification = {ClassificationResult("address", 1.0)};
|
const ActionsSuggestionsResponse& response =
|
actions_suggestions->SuggestActions(
|
{{{/*user_id=*/1, "are you at home?",
|
/*reference_time_ms_utc=*/0,
|
/*reference_timezone=*/"Europe/Zurich",
|
/*annotations=*/{annotation},
|
/*locales=*/"en"}}});
|
ASSERT_GE(response.actions.size(), 1);
|
EXPECT_EQ(response.actions.front().type, "save_location");
|
EXPECT_EQ(response.actions.front().score, 1.0);
|
|
// Check that the `location` entity field holds the text from the address
|
// annotation.
|
const flatbuffers::Table* entity =
|
flatbuffers::GetAnyRoot(reinterpret_cast<const unsigned char*>(
|
response.actions.front().serialized_entity_data.data()));
|
EXPECT_EQ(entity->GetPointer<const flatbuffers::String*>(/*field=*/6)->str(),
|
"home");
|
}
|
|
TEST_F(ActionsSuggestionsTest, SuggestActionsFromDuplicatedAnnotations) {
|
std::unique_ptr<ActionsSuggestions> actions_suggestions = LoadTestModel();
|
AnnotatedSpan flight_annotation;
|
flight_annotation.span = {11, 15};
|
flight_annotation.classification = {ClassificationResult("flight", 2.5)};
|
AnnotatedSpan flight_annotation2;
|
flight_annotation2.span = {35, 39};
|
flight_annotation2.classification = {ClassificationResult("flight", 3.0)};
|
AnnotatedSpan email_annotation;
|
email_annotation.span = {55, 68};
|
email_annotation.classification = {ClassificationResult("email", 2.0)};
|
|
const ActionsSuggestionsResponse& response =
|
actions_suggestions->SuggestActions(
|
{{{/*user_id=*/1,
|
"call me at LX38 or send message to LX38 or test@test.com.",
|
/*reference_time_ms_utc=*/0,
|
/*reference_timezone=*/"Europe/Zurich",
|
/*annotations=*/
|
{flight_annotation, flight_annotation2, email_annotation},
|
/*locales=*/"en"}}});
|
|
ASSERT_GE(response.actions.size(), 2);
|
EXPECT_EQ(response.actions[0].type, "track_flight");
|
EXPECT_EQ(response.actions[0].score, 3.0);
|
EXPECT_EQ(response.actions[1].type, "send_email");
|
EXPECT_EQ(response.actions[1].score, 2.0);
|
}
|
|
TEST_F(ActionsSuggestionsTest, SuggestActionsAnnotationsNoDeduplication) {
|
const std::string actions_model_string =
|
ReadFile(GetModelPath() + kModelFileName);
|
std::unique_ptr<ActionsModelT> actions_model =
|
UnPackActionsModel(actions_model_string.c_str());
|
// Disable deduplication.
|
actions_model->annotation_actions_spec->deduplicate_annotations = false;
|
flatbuffers::FlatBufferBuilder builder;
|
FinishActionsModelBuffer(builder,
|
ActionsModel::Pack(builder, actions_model.get()));
|
std::unique_ptr<ActionsSuggestions> actions_suggestions =
|
ActionsSuggestions::FromUnownedBuffer(
|
reinterpret_cast<const uint8_t*>(builder.GetBufferPointer()),
|
builder.GetSize(), &unilib_);
|
AnnotatedSpan flight_annotation;
|
flight_annotation.span = {11, 15};
|
flight_annotation.classification = {ClassificationResult("flight", 2.5)};
|
AnnotatedSpan flight_annotation2;
|
flight_annotation2.span = {35, 39};
|
flight_annotation2.classification = {ClassificationResult("flight", 3.0)};
|
AnnotatedSpan email_annotation;
|
email_annotation.span = {55, 68};
|
email_annotation.classification = {ClassificationResult("email", 2.0)};
|
|
const ActionsSuggestionsResponse& response =
|
actions_suggestions->SuggestActions(
|
{{{/*user_id=*/1,
|
"call me at LX38 or send message to LX38 or test@test.com.",
|
/*reference_time_ms_utc=*/0,
|
/*reference_timezone=*/"Europe/Zurich",
|
/*annotations=*/
|
{flight_annotation, flight_annotation2, email_annotation},
|
/*locales=*/"en"}}});
|
|
ASSERT_GE(response.actions.size(), 3);
|
EXPECT_EQ(response.actions[0].type, "track_flight");
|
EXPECT_EQ(response.actions[0].score, 3.0);
|
EXPECT_EQ(response.actions[1].type, "track_flight");
|
EXPECT_EQ(response.actions[1].score, 2.5);
|
EXPECT_EQ(response.actions[2].type, "send_email");
|
EXPECT_EQ(response.actions[2].score, 2.0);
|
}
|
|
ActionsSuggestionsResponse TestSuggestActionsFromAnnotations(
|
const std::function<void(ActionsModelT*)>& set_config_fn,
|
const UniLib* unilib = nullptr) {
|
const std::string actions_model_string =
|
ReadFile(GetModelPath() + kModelFileName);
|
std::unique_ptr<ActionsModelT> actions_model =
|
UnPackActionsModel(actions_model_string.c_str());
|
|
// Set custom config.
|
set_config_fn(actions_model.get());
|
|
// Disable smart reply for easier testing.
|
actions_model->preconditions->min_smart_reply_triggering_score = 1.0;
|
|
flatbuffers::FlatBufferBuilder builder;
|
FinishActionsModelBuffer(builder,
|
ActionsModel::Pack(builder, actions_model.get()));
|
std::unique_ptr<ActionsSuggestions> actions_suggestions =
|
ActionsSuggestions::FromUnownedBuffer(
|
reinterpret_cast<const uint8_t*>(builder.GetBufferPointer()),
|
builder.GetSize(), unilib);
|
|
AnnotatedSpan flight_annotation;
|
flight_annotation.span = {15, 19};
|
flight_annotation.classification = {ClassificationResult("flight", 2.0)};
|
AnnotatedSpan email_annotation;
|
email_annotation.span = {0, 16};
|
email_annotation.classification = {ClassificationResult("email", 1.0)};
|
|
return actions_suggestions->SuggestActions(
|
{{{/*user_id=*/ActionsSuggestions::kLocalUserId,
|
"hehe@android.com",
|
/*reference_time_ms_utc=*/0,
|
/*reference_timezone=*/"Europe/Zurich",
|
/*annotations=*/
|
{email_annotation},
|
/*locales=*/"en"},
|
{/*user_id=*/2,
|
"yoyo@android.com",
|
/*reference_time_ms_utc=*/0,
|
/*reference_timezone=*/"Europe/Zurich",
|
/*annotations=*/
|
{email_annotation},
|
/*locales=*/"en"},
|
{/*user_id=*/1,
|
"test@android.com",
|
/*reference_time_ms_utc=*/0,
|
/*reference_timezone=*/"Europe/Zurich",
|
/*annotations=*/
|
{email_annotation},
|
/*locales=*/"en"},
|
{/*user_id=*/1,
|
"I am on flight LX38.",
|
/*reference_time_ms_utc=*/0,
|
/*reference_timezone=*/"Europe/Zurich",
|
/*annotations=*/
|
{flight_annotation},
|
/*locales=*/"en"}}});
|
}
|
|
TEST_F(ActionsSuggestionsTest, SuggestActionsWithAnnotationsOnlyLastMessage) {
|
const ActionsSuggestionsResponse response = TestSuggestActionsFromAnnotations(
|
[](ActionsModelT* actions_model) {
|
actions_model->annotation_actions_spec->include_local_user_messages =
|
false;
|
actions_model->annotation_actions_spec->only_until_last_sent = true;
|
actions_model->annotation_actions_spec->max_history_from_any_person = 1;
|
actions_model->annotation_actions_spec->max_history_from_last_person =
|
1;
|
},
|
&unilib_);
|
EXPECT_EQ(response.actions.size(), 1);
|
EXPECT_EQ(response.actions[0].type, "track_flight");
|
}
|
|
TEST_F(ActionsSuggestionsTest, SuggestActionsWithAnnotationsOnlyLastPerson) {
|
const ActionsSuggestionsResponse response = TestSuggestActionsFromAnnotations(
|
[](ActionsModelT* actions_model) {
|
actions_model->annotation_actions_spec->include_local_user_messages =
|
false;
|
actions_model->annotation_actions_spec->only_until_last_sent = true;
|
actions_model->annotation_actions_spec->max_history_from_any_person = 1;
|
actions_model->annotation_actions_spec->max_history_from_last_person =
|
3;
|
},
|
&unilib_);
|
EXPECT_EQ(response.actions.size(), 2);
|
EXPECT_EQ(response.actions[0].type, "track_flight");
|
EXPECT_EQ(response.actions[1].type, "send_email");
|
}
|
|
TEST_F(ActionsSuggestionsTest, SuggestActionsWithAnnotationsFromAny) {
|
const ActionsSuggestionsResponse response = TestSuggestActionsFromAnnotations(
|
[](ActionsModelT* actions_model) {
|
actions_model->annotation_actions_spec->include_local_user_messages =
|
false;
|
actions_model->annotation_actions_spec->only_until_last_sent = true;
|
actions_model->annotation_actions_spec->max_history_from_any_person = 2;
|
actions_model->annotation_actions_spec->max_history_from_last_person =
|
1;
|
},
|
&unilib_);
|
EXPECT_EQ(response.actions.size(), 2);
|
EXPECT_EQ(response.actions[0].type, "track_flight");
|
EXPECT_EQ(response.actions[1].type, "send_email");
|
}
|
|
TEST_F(ActionsSuggestionsTest,
|
SuggestActionsWithAnnotationsFromAnyManyMessages) {
|
const ActionsSuggestionsResponse response = TestSuggestActionsFromAnnotations(
|
[](ActionsModelT* actions_model) {
|
actions_model->annotation_actions_spec->include_local_user_messages =
|
false;
|
actions_model->annotation_actions_spec->only_until_last_sent = true;
|
actions_model->annotation_actions_spec->max_history_from_any_person = 3;
|
actions_model->annotation_actions_spec->max_history_from_last_person =
|
1;
|
},
|
&unilib_);
|
EXPECT_EQ(response.actions.size(), 3);
|
EXPECT_EQ(response.actions[0].type, "track_flight");
|
EXPECT_EQ(response.actions[1].type, "send_email");
|
EXPECT_EQ(response.actions[2].type, "send_email");
|
}
|
|
TEST_F(ActionsSuggestionsTest,
|
SuggestActionsWithAnnotationsFromAnyManyMessagesButNotLocalUser) {
|
const ActionsSuggestionsResponse response = TestSuggestActionsFromAnnotations(
|
[](ActionsModelT* actions_model) {
|
actions_model->annotation_actions_spec->include_local_user_messages =
|
false;
|
actions_model->annotation_actions_spec->only_until_last_sent = true;
|
actions_model->annotation_actions_spec->max_history_from_any_person = 5;
|
actions_model->annotation_actions_spec->max_history_from_last_person =
|
1;
|
},
|
&unilib_);
|
EXPECT_EQ(response.actions.size(), 3);
|
EXPECT_EQ(response.actions[0].type, "track_flight");
|
EXPECT_EQ(response.actions[1].type, "send_email");
|
EXPECT_EQ(response.actions[2].type, "send_email");
|
}
|
|
TEST_F(ActionsSuggestionsTest,
|
SuggestActionsWithAnnotationsFromAnyManyMessagesAlsoFromLocalUser) {
|
const ActionsSuggestionsResponse response = TestSuggestActionsFromAnnotations(
|
[](ActionsModelT* actions_model) {
|
actions_model->annotation_actions_spec->include_local_user_messages =
|
true;
|
actions_model->annotation_actions_spec->only_until_last_sent = false;
|
actions_model->annotation_actions_spec->max_history_from_any_person = 5;
|
actions_model->annotation_actions_spec->max_history_from_last_person =
|
1;
|
},
|
&unilib_);
|
EXPECT_EQ(response.actions.size(), 4);
|
EXPECT_EQ(response.actions[0].type, "track_flight");
|
EXPECT_EQ(response.actions[1].type, "send_email");
|
EXPECT_EQ(response.actions[2].type, "send_email");
|
EXPECT_EQ(response.actions[3].type, "send_email");
|
}
|
|
void TestSuggestActionsWithThreshold(
|
const std::function<void(ActionsModelT*)>& set_value_fn,
|
const UniLib* unilib = nullptr, const int expected_size = 0,
|
const std::string& preconditions_overwrite = "") {
|
const std::string actions_model_string =
|
ReadFile(GetModelPath() + kModelFileName);
|
std::unique_ptr<ActionsModelT> actions_model =
|
UnPackActionsModel(actions_model_string.c_str());
|
set_value_fn(actions_model.get());
|
flatbuffers::FlatBufferBuilder builder;
|
FinishActionsModelBuffer(builder,
|
ActionsModel::Pack(builder, actions_model.get()));
|
std::unique_ptr<ActionsSuggestions> actions_suggestions =
|
ActionsSuggestions::FromUnownedBuffer(
|
reinterpret_cast<const uint8_t*>(builder.GetBufferPointer()),
|
builder.GetSize(), unilib, preconditions_overwrite);
|
ASSERT_TRUE(actions_suggestions);
|
const ActionsSuggestionsResponse& response =
|
actions_suggestions->SuggestActions(
|
{{{/*user_id=*/1, "I have the low-ground. Where are you?",
|
/*reference_time_ms_utc=*/0,
|
/*reference_timezone=*/"Europe/Zurich",
|
/*annotations=*/{}, /*locales=*/"en"}}});
|
EXPECT_LE(response.actions.size(), expected_size);
|
}
|
|
TEST_F(ActionsSuggestionsTest, SuggestActionsWithTriggeringScore) {
|
TestSuggestActionsWithThreshold(
|
[](ActionsModelT* actions_model) {
|
actions_model->preconditions->min_smart_reply_triggering_score = 1.0;
|
},
|
&unilib_,
|
/*expected_size=*/1 /*no smart reply, only actions*/
|
);
|
}
|
|
TEST_F(ActionsSuggestionsTest, SuggestActionsWithMinReplyScore) {
|
TestSuggestActionsWithThreshold(
|
[](ActionsModelT* actions_model) {
|
actions_model->preconditions->min_reply_score_threshold = 1.0;
|
},
|
&unilib_,
|
/*expected_size=*/1 /*no smart reply, only actions*/
|
);
|
}
|
|
TEST_F(ActionsSuggestionsTest, SuggestActionsWithSensitiveTopicScore) {
|
TestSuggestActionsWithThreshold(
|
[](ActionsModelT* actions_model) {
|
actions_model->preconditions->max_sensitive_topic_score = 0.0;
|
},
|
&unilib_,
|
/*expected_size=*/4 /* no sensitive prediction in test model*/);
|
}
|
|
TEST_F(ActionsSuggestionsTest, SuggestActionsWithMaxInputLength) {
|
TestSuggestActionsWithThreshold(
|
[](ActionsModelT* actions_model) {
|
actions_model->preconditions->max_input_length = 0;
|
},
|
&unilib_);
|
}
|
|
TEST_F(ActionsSuggestionsTest, SuggestActionsWithMinInputLength) {
|
TestSuggestActionsWithThreshold(
|
[](ActionsModelT* actions_model) {
|
actions_model->preconditions->min_input_length = 100;
|
},
|
&unilib_);
|
}
|
|
TEST_F(ActionsSuggestionsTest, SuggestActionsWithPreconditionsOverwrite) {
|
TriggeringPreconditionsT preconditions_overwrite;
|
preconditions_overwrite.max_input_length = 0;
|
flatbuffers::FlatBufferBuilder builder;
|
builder.Finish(
|
TriggeringPreconditions::Pack(builder, &preconditions_overwrite));
|
TestSuggestActionsWithThreshold(
|
// Keep model untouched.
|
[](ActionsModelT* actions_model) {}, &unilib_,
|
/*expected_size=*/0,
|
std::string(reinterpret_cast<const char*>(builder.GetBufferPointer()),
|
builder.GetSize()));
|
}
|
|
#ifdef TC3_UNILIB_ICU
|
TEST_F(ActionsSuggestionsTest, SuggestActionsLowConfidence) {
|
TestSuggestActionsWithThreshold(
|
[](ActionsModelT* actions_model) {
|
actions_model->preconditions->suppress_on_low_confidence_input = true;
|
actions_model->low_confidence_rules.reset(new RulesModelT);
|
actions_model->low_confidence_rules->rule.emplace_back(
|
new RulesModel_::RuleT);
|
actions_model->low_confidence_rules->rule.back()->pattern =
|
"low-ground";
|
},
|
&unilib_);
|
}
|
|
TEST_F(ActionsSuggestionsTest, SuggestActionsLowConfidenceInputOutput) {
|
const std::string actions_model_string =
|
ReadFile(GetModelPath() + kModelFileName);
|
std::unique_ptr<ActionsModelT> actions_model =
|
UnPackActionsModel(actions_model_string.c_str());
|
// Add custom triggering rule.
|
actions_model->rules.reset(new RulesModelT());
|
actions_model->rules->rule.emplace_back(new RulesModel_::RuleT);
|
RulesModel_::RuleT* rule = actions_model->rules->rule.back().get();
|
rule->pattern = "^(?i:hello\\s(there))$";
|
{
|
std::unique_ptr<RulesModel_::Rule_::RuleActionSpecT> rule_action(
|
new RulesModel_::Rule_::RuleActionSpecT);
|
rule_action->action.reset(new ActionSuggestionSpecT);
|
rule_action->action->type = "text_reply";
|
rule_action->action->response_text = "General Desaster!";
|
rule_action->action->score = 1.0f;
|
rule_action->action->priority_score = 1.0f;
|
rule->actions.push_back(std::move(rule_action));
|
}
|
{
|
std::unique_ptr<RulesModel_::Rule_::RuleActionSpecT> rule_action(
|
new RulesModel_::Rule_::RuleActionSpecT);
|
rule_action->action.reset(new ActionSuggestionSpecT);
|
rule_action->action->type = "text_reply";
|
rule_action->action->response_text = "General Kenobi!";
|
rule_action->action->score = 1.0f;
|
rule_action->action->priority_score = 1.0f;
|
rule->actions.push_back(std::move(rule_action));
|
}
|
|
// Add input-output low confidence rule.
|
actions_model->preconditions->suppress_on_low_confidence_input = true;
|
actions_model->low_confidence_rules.reset(new RulesModelT);
|
actions_model->low_confidence_rules->rule.emplace_back(
|
new RulesModel_::RuleT);
|
actions_model->low_confidence_rules->rule.back()->pattern = "hello";
|
actions_model->low_confidence_rules->rule.back()->output_pattern =
|
"(?i:desaster)";
|
|
flatbuffers::FlatBufferBuilder builder;
|
FinishActionsModelBuffer(builder,
|
ActionsModel::Pack(builder, actions_model.get()));
|
std::unique_ptr<ActionsSuggestions> actions_suggestions =
|
ActionsSuggestions::FromUnownedBuffer(
|
reinterpret_cast<const uint8_t*>(builder.GetBufferPointer()),
|
builder.GetSize(), &unilib_);
|
ASSERT_TRUE(actions_suggestions);
|
const ActionsSuggestionsResponse& response =
|
actions_suggestions->SuggestActions(
|
{{{/*user_id=*/1, "hello there",
|
/*reference_time_ms_utc=*/0,
|
/*reference_timezone=*/"Europe/Zurich",
|
/*annotations=*/{}, /*locales=*/"en"}}});
|
ASSERT_GE(response.actions.size(), 1);
|
EXPECT_EQ(response.actions[0].response_text, "General Kenobi!");
|
}
|
|
TEST_F(ActionsSuggestionsTest,
|
SuggestActionsLowConfidenceInputOutputOverwrite) {
|
const std::string actions_model_string =
|
ReadFile(GetModelPath() + kModelFileName);
|
std::unique_ptr<ActionsModelT> actions_model =
|
UnPackActionsModel(actions_model_string.c_str());
|
actions_model->low_confidence_rules.reset();
|
|
// Add custom triggering rule.
|
actions_model->rules.reset(new RulesModelT());
|
actions_model->rules->rule.emplace_back(new RulesModel_::RuleT);
|
RulesModel_::RuleT* rule = actions_model->rules->rule.back().get();
|
rule->pattern = "^(?i:hello\\s(there))$";
|
{
|
std::unique_ptr<RulesModel_::Rule_::RuleActionSpecT> rule_action(
|
new RulesModel_::Rule_::RuleActionSpecT);
|
rule_action->action.reset(new ActionSuggestionSpecT);
|
rule_action->action->type = "text_reply";
|
rule_action->action->response_text = "General Desaster!";
|
rule_action->action->score = 1.0f;
|
rule_action->action->priority_score = 1.0f;
|
rule->actions.push_back(std::move(rule_action));
|
}
|
{
|
std::unique_ptr<RulesModel_::Rule_::RuleActionSpecT> rule_action(
|
new RulesModel_::Rule_::RuleActionSpecT);
|
rule_action->action.reset(new ActionSuggestionSpecT);
|
rule_action->action->type = "text_reply";
|
rule_action->action->response_text = "General Kenobi!";
|
rule_action->action->score = 1.0f;
|
rule_action->action->priority_score = 1.0f;
|
rule->actions.push_back(std::move(rule_action));
|
}
|
|
// Add custom triggering rule via overwrite.
|
actions_model->preconditions->low_confidence_rules.reset();
|
TriggeringPreconditionsT preconditions;
|
preconditions.suppress_on_low_confidence_input = true;
|
preconditions.low_confidence_rules.reset(new RulesModelT);
|
preconditions.low_confidence_rules->rule.emplace_back(new RulesModel_::RuleT);
|
preconditions.low_confidence_rules->rule.back()->pattern = "hello";
|
preconditions.low_confidence_rules->rule.back()->output_pattern =
|
"(?i:desaster)";
|
flatbuffers::FlatBufferBuilder preconditions_builder;
|
preconditions_builder.Finish(
|
TriggeringPreconditions::Pack(preconditions_builder, &preconditions));
|
std::string serialize_preconditions = std::string(
|
reinterpret_cast<const char*>(preconditions_builder.GetBufferPointer()),
|
preconditions_builder.GetSize());
|
|
flatbuffers::FlatBufferBuilder builder;
|
FinishActionsModelBuffer(builder,
|
ActionsModel::Pack(builder, actions_model.get()));
|
std::unique_ptr<ActionsSuggestions> actions_suggestions =
|
ActionsSuggestions::FromUnownedBuffer(
|
reinterpret_cast<const uint8_t*>(builder.GetBufferPointer()),
|
builder.GetSize(), &unilib_, serialize_preconditions);
|
|
ASSERT_TRUE(actions_suggestions);
|
const ActionsSuggestionsResponse& response =
|
actions_suggestions->SuggestActions(
|
{{{/*user_id=*/1, "hello there",
|
/*reference_time_ms_utc=*/0,
|
/*reference_timezone=*/"Europe/Zurich",
|
/*annotations=*/{}, /*locales=*/"en"}}});
|
ASSERT_GE(response.actions.size(), 1);
|
EXPECT_EQ(response.actions[0].response_text, "General Kenobi!");
|
}
|
#endif
|
|
TEST_F(ActionsSuggestionsTest, SuppressActionsFromAnnotationsOnSensitiveTopic) {
|
const std::string actions_model_string =
|
ReadFile(GetModelPath() + kModelFileName);
|
std::unique_ptr<ActionsModelT> actions_model =
|
UnPackActionsModel(actions_model_string.c_str());
|
|
// Don't test if no sensitivity score is produced
|
if (actions_model->tflite_model_spec->output_sensitive_topic_score < 0) {
|
return;
|
}
|
|
actions_model->preconditions->max_sensitive_topic_score = 0.0;
|
actions_model->preconditions->suppress_on_sensitive_topic = true;
|
flatbuffers::FlatBufferBuilder builder;
|
FinishActionsModelBuffer(builder,
|
ActionsModel::Pack(builder, actions_model.get()));
|
std::unique_ptr<ActionsSuggestions> actions_suggestions =
|
ActionsSuggestions::FromUnownedBuffer(
|
reinterpret_cast<const uint8_t*>(builder.GetBufferPointer()),
|
builder.GetSize(), &unilib_);
|
AnnotatedSpan annotation;
|
annotation.span = {11, 15};
|
annotation.classification = {
|
ClassificationResult(Collections::Address(), 1.0)};
|
const ActionsSuggestionsResponse& response =
|
actions_suggestions->SuggestActions(
|
{{{/*user_id=*/1, "are you at home?",
|
/*reference_time_ms_utc=*/0,
|
/*reference_timezone=*/"Europe/Zurich",
|
/*annotations=*/{annotation},
|
/*locales=*/"en"}}});
|
EXPECT_THAT(response.actions, testing::IsEmpty());
|
}
|
|
TEST_F(ActionsSuggestionsTest, SuggestActionsWithLongerConversation) {
|
const std::string actions_model_string =
|
ReadFile(GetModelPath() + kModelFileName);
|
std::unique_ptr<ActionsModelT> actions_model =
|
UnPackActionsModel(actions_model_string.c_str());
|
|
// Allow a larger conversation context.
|
actions_model->max_conversation_history_length = 10;
|
|
flatbuffers::FlatBufferBuilder builder;
|
FinishActionsModelBuffer(builder,
|
ActionsModel::Pack(builder, actions_model.get()));
|
std::unique_ptr<ActionsSuggestions> actions_suggestions =
|
ActionsSuggestions::FromUnownedBuffer(
|
reinterpret_cast<const uint8_t*>(builder.GetBufferPointer()),
|
builder.GetSize(), &unilib_);
|
AnnotatedSpan annotation;
|
annotation.span = {11, 15};
|
annotation.classification = {
|
ClassificationResult(Collections::Address(), 1.0)};
|
const ActionsSuggestionsResponse& response =
|
actions_suggestions->SuggestActions(
|
{{{/*user_id=*/ActionsSuggestions::kLocalUserId, "hi, how are you?",
|
/*reference_time_ms_utc=*/10000,
|
/*reference_timezone=*/"Europe/Zurich",
|
/*annotations=*/{}, /*locales=*/"en"},
|
{/*user_id=*/1, "good! are you at home?",
|
/*reference_time_ms_utc=*/15000,
|
/*reference_timezone=*/"Europe/Zurich",
|
/*annotations=*/{annotation},
|
/*locales=*/"en"}}});
|
ASSERT_GE(response.actions.size(), 1);
|
EXPECT_EQ(response.actions[0].type, "view_map");
|
EXPECT_EQ(response.actions[0].score, 1.0);
|
}
|
|
TEST_F(ActionsSuggestionsTest, CreateActionsFromClassificationResult) {
|
std::unique_ptr<ActionsSuggestions> actions_suggestions = LoadTestModel();
|
AnnotatedSpan annotation;
|
annotation.span = {8, 12};
|
annotation.classification = {
|
ClassificationResult(Collections::Flight(), 1.0)};
|
|
const ActionsSuggestionsResponse& response =
|
actions_suggestions->SuggestActions(
|
{{{/*user_id=*/1, "I'm on LX38?",
|
/*reference_time_ms_utc=*/0,
|
/*reference_timezone=*/"Europe/Zurich",
|
/*annotations=*/{annotation},
|
/*locales=*/"en"}}});
|
|
ASSERT_GE(response.actions.size(), 2);
|
EXPECT_EQ(response.actions[0].type, "track_flight");
|
EXPECT_EQ(response.actions[0].score, 1.0);
|
EXPECT_EQ(response.actions[0].annotations.size(), 1);
|
EXPECT_EQ(response.actions[0].annotations[0].span.message_index, 0);
|
EXPECT_EQ(response.actions[0].annotations[0].span.span, annotation.span);
|
}
|
|
#ifdef TC3_UNILIB_ICU
|
TEST_F(ActionsSuggestionsTest, CreateActionsFromRules) {
|
const std::string actions_model_string =
|
ReadFile(GetModelPath() + kModelFileName);
|
std::unique_ptr<ActionsModelT> actions_model =
|
UnPackActionsModel(actions_model_string.c_str());
|
ASSERT_TRUE(DecompressActionsModel(actions_model.get()));
|
|
actions_model->rules.reset(new RulesModelT());
|
actions_model->rules->rule.emplace_back(new RulesModel_::RuleT);
|
RulesModel_::RuleT* rule = actions_model->rules->rule.back().get();
|
rule->pattern = "^(?i:hello\\s(there))$";
|
rule->actions.emplace_back(new RulesModel_::Rule_::RuleActionSpecT);
|
rule->actions.back()->action.reset(new ActionSuggestionSpecT);
|
ActionSuggestionSpecT* action = rule->actions.back()->action.get();
|
action->type = "text_reply";
|
action->response_text = "General Kenobi!";
|
action->score = 1.0f;
|
action->priority_score = 1.0f;
|
|
// Set capturing groups for entity data.
|
rule->actions.back()->capturing_group.emplace_back(
|
new RulesModel_::Rule_::RuleActionSpec_::RuleCapturingGroupT);
|
RulesModel_::Rule_::RuleActionSpec_::RuleCapturingGroupT* greeting_group =
|
rule->actions.back()->capturing_group.back().get();
|
greeting_group->group_id = 0;
|
greeting_group->entity_field.reset(new FlatbufferFieldPathT);
|
greeting_group->entity_field->field.emplace_back(new FlatbufferFieldT);
|
greeting_group->entity_field->field.back()->field_name = "greeting";
|
rule->actions.back()->capturing_group.emplace_back(
|
new RulesModel_::Rule_::RuleActionSpec_::RuleCapturingGroupT);
|
RulesModel_::Rule_::RuleActionSpec_::RuleCapturingGroupT* location_group =
|
rule->actions.back()->capturing_group.back().get();
|
location_group->group_id = 1;
|
location_group->entity_field.reset(new FlatbufferFieldPathT);
|
location_group->entity_field->field.emplace_back(new FlatbufferFieldT);
|
location_group->entity_field->field.back()->field_name = "location";
|
|
// Set test entity data schema.
|
SetTestEntityDataSchema(actions_model.get());
|
|
// Use meta data to generate custom serialized entity data.
|
ReflectiveFlatbufferBuilder entity_data_builder(
|
flatbuffers::GetRoot<reflection::Schema>(
|
actions_model->actions_entity_data_schema.data()));
|
std::unique_ptr<ReflectiveFlatbuffer> entity_data =
|
entity_data_builder.NewRoot();
|
entity_data->Set("person", "Kenobi");
|
action->serialized_entity_data = entity_data->Serialize();
|
|
flatbuffers::FlatBufferBuilder builder;
|
FinishActionsModelBuffer(builder,
|
ActionsModel::Pack(builder, actions_model.get()));
|
std::unique_ptr<ActionsSuggestions> actions_suggestions =
|
ActionsSuggestions::FromUnownedBuffer(
|
reinterpret_cast<const uint8_t*>(builder.GetBufferPointer()),
|
builder.GetSize(), &unilib_);
|
|
const ActionsSuggestionsResponse& response =
|
actions_suggestions->SuggestActions(
|
{{{/*user_id=*/1, "hello there", /*reference_time_ms_utc=*/0,
|
/*reference_timezone=*/"Europe/Zurich",
|
/*annotations=*/{}, /*locales=*/"en"}}});
|
EXPECT_GE(response.actions.size(), 1);
|
EXPECT_EQ(response.actions[0].response_text, "General Kenobi!");
|
|
// Check entity data.
|
const flatbuffers::Table* entity =
|
flatbuffers::GetAnyRoot(reinterpret_cast<const unsigned char*>(
|
response.actions[0].serialized_entity_data.data()));
|
EXPECT_EQ(entity->GetPointer<const flatbuffers::String*>(/*field=*/4)->str(),
|
"hello there");
|
EXPECT_EQ(entity->GetPointer<const flatbuffers::String*>(/*field=*/6)->str(),
|
"there");
|
EXPECT_EQ(entity->GetPointer<const flatbuffers::String*>(/*field=*/8)->str(),
|
"Kenobi");
|
}
|
|
TEST_F(ActionsSuggestionsTest, CreatesTextRepliesFromRules) {
|
const std::string actions_model_string =
|
ReadFile(GetModelPath() + kModelFileName);
|
std::unique_ptr<ActionsModelT> actions_model =
|
UnPackActionsModel(actions_model_string.c_str());
|
ASSERT_TRUE(DecompressActionsModel(actions_model.get()));
|
|
actions_model->rules.reset(new RulesModelT());
|
actions_model->rules->rule.emplace_back(new RulesModel_::RuleT);
|
RulesModel_::RuleT* rule = actions_model->rules->rule.back().get();
|
rule->pattern = "(?i:reply (stop|quit|end) (?:to|for) )";
|
rule->actions.emplace_back(new RulesModel_::Rule_::RuleActionSpecT);
|
|
// Set capturing groups for entity data.
|
rule->actions.back()->capturing_group.emplace_back(
|
new RulesModel_::Rule_::RuleActionSpec_::RuleCapturingGroupT);
|
RulesModel_::Rule_::RuleActionSpec_::RuleCapturingGroupT* code_group =
|
rule->actions.back()->capturing_group.back().get();
|
code_group->group_id = 1;
|
code_group->text_reply.reset(new ActionSuggestionSpecT);
|
code_group->text_reply->score = 1.0f;
|
code_group->text_reply->priority_score = 1.0f;
|
|
flatbuffers::FlatBufferBuilder builder;
|
FinishActionsModelBuffer(builder,
|
ActionsModel::Pack(builder, actions_model.get()));
|
std::unique_ptr<ActionsSuggestions> actions_suggestions =
|
ActionsSuggestions::FromUnownedBuffer(
|
reinterpret_cast<const uint8_t*>(builder.GetBufferPointer()),
|
builder.GetSize(), &unilib_);
|
|
const ActionsSuggestionsResponse& response =
|
actions_suggestions->SuggestActions(
|
{{{/*user_id=*/1,
|
"visit test.com or reply STOP to cancel your subscription",
|
/*reference_time_ms_utc=*/0,
|
/*reference_timezone=*/"Europe/Zurich",
|
/*annotations=*/{}, /*locales=*/"en"}}});
|
EXPECT_GE(response.actions.size(), 1);
|
EXPECT_EQ(response.actions[0].response_text, "STOP");
|
}
|
|
TEST_F(ActionsSuggestionsTest, DeduplicateActions) {
|
std::unique_ptr<ActionsSuggestions> actions_suggestions = LoadTestModel();
|
ActionsSuggestionsResponse response = actions_suggestions->SuggestActions(
|
{{{/*user_id=*/1, "Where are you?", /*reference_time_ms_utc=*/0,
|
/*reference_timezone=*/"Europe/Zurich",
|
/*annotations=*/{}, /*locales=*/"en"}}});
|
|
// Check that the location sharing model triggered.
|
bool has_location_sharing_action = false;
|
for (const ActionSuggestion action : response.actions) {
|
if (action.type == ActionsSuggestions::kShareLocation) {
|
has_location_sharing_action = true;
|
break;
|
}
|
}
|
EXPECT_TRUE(has_location_sharing_action);
|
const int num_actions = response.actions.size();
|
|
// Add custom rule for location sharing.
|
const std::string actions_model_string =
|
ReadFile(GetModelPath() + kModelFileName);
|
std::unique_ptr<ActionsModelT> actions_model =
|
UnPackActionsModel(actions_model_string.c_str());
|
ASSERT_TRUE(DecompressActionsModel(actions_model.get()));
|
|
actions_model->rules.reset(new RulesModelT());
|
actions_model->rules->rule.emplace_back(new RulesModel_::RuleT);
|
actions_model->rules->rule.back()->pattern = "^(?i:where are you[.?]?)$";
|
actions_model->rules->rule.back()->actions.emplace_back(
|
new RulesModel_::Rule_::RuleActionSpecT);
|
actions_model->rules->rule.back()->actions.back()->action.reset(
|
new ActionSuggestionSpecT);
|
ActionSuggestionSpecT* action =
|
actions_model->rules->rule.back()->actions.back()->action.get();
|
action->score = 1.0f;
|
action->type = ActionsSuggestions::kShareLocation;
|
|
flatbuffers::FlatBufferBuilder builder;
|
FinishActionsModelBuffer(builder,
|
ActionsModel::Pack(builder, actions_model.get()));
|
actions_suggestions = ActionsSuggestions::FromUnownedBuffer(
|
reinterpret_cast<const uint8_t*>(builder.GetBufferPointer()),
|
builder.GetSize(), &unilib_);
|
|
response = actions_suggestions->SuggestActions(
|
{{{/*user_id=*/1, "Where are you?", /*reference_time_ms_utc=*/0,
|
/*reference_timezone=*/"Europe/Zurich",
|
/*annotations=*/{}, /*locales=*/"en"}}});
|
EXPECT_EQ(response.actions.size(), num_actions);
|
}
|
|
TEST_F(ActionsSuggestionsTest, DeduplicateConflictingActions) {
|
std::unique_ptr<ActionsSuggestions> actions_suggestions = LoadTestModel();
|
AnnotatedSpan annotation;
|
annotation.span = {7, 11};
|
annotation.classification = {
|
ClassificationResult(Collections::Flight(), 1.0)};
|
ActionsSuggestionsResponse response = actions_suggestions->SuggestActions(
|
{{{/*user_id=*/1, "I'm on LX38",
|
/*reference_time_ms_utc=*/0,
|
/*reference_timezone=*/"Europe/Zurich",
|
/*annotations=*/{annotation},
|
/*locales=*/"en"}}});
|
|
// Check that the phone actions are present.
|
EXPECT_GE(response.actions.size(), 1);
|
EXPECT_EQ(response.actions[0].type, "track_flight");
|
|
// Add custom rule.
|
const std::string actions_model_string =
|
ReadFile(GetModelPath() + kModelFileName);
|
std::unique_ptr<ActionsModelT> actions_model =
|
UnPackActionsModel(actions_model_string.c_str());
|
ASSERT_TRUE(DecompressActionsModel(actions_model.get()));
|
|
actions_model->rules.reset(new RulesModelT());
|
actions_model->rules->rule.emplace_back(new RulesModel_::RuleT);
|
RulesModel_::RuleT* rule = actions_model->rules->rule.back().get();
|
rule->pattern = "^(?i:I'm on ([a-z0-9]+))$";
|
rule->actions.emplace_back(new RulesModel_::Rule_::RuleActionSpecT);
|
rule->actions.back()->action.reset(new ActionSuggestionSpecT);
|
ActionSuggestionSpecT* action = rule->actions.back()->action.get();
|
action->score = 1.0f;
|
action->priority_score = 2.0f;
|
action->type = "test_code";
|
rule->actions.back()->capturing_group.emplace_back(
|
new RulesModel_::Rule_::RuleActionSpec_::RuleCapturingGroupT);
|
RulesModel_::Rule_::RuleActionSpec_::RuleCapturingGroupT* code_group =
|
rule->actions.back()->capturing_group.back().get();
|
code_group->group_id = 1;
|
code_group->annotation_name = "code";
|
code_group->annotation_type = "code";
|
|
flatbuffers::FlatBufferBuilder builder;
|
FinishActionsModelBuffer(builder,
|
ActionsModel::Pack(builder, actions_model.get()));
|
actions_suggestions = ActionsSuggestions::FromUnownedBuffer(
|
reinterpret_cast<const uint8_t*>(builder.GetBufferPointer()),
|
builder.GetSize(), &unilib_);
|
|
response = actions_suggestions->SuggestActions(
|
{{{/*user_id=*/1, "I'm on LX38",
|
/*reference_time_ms_utc=*/0,
|
/*reference_timezone=*/"Europe/Zurich",
|
/*annotations=*/{annotation},
|
/*locales=*/"en"}}});
|
EXPECT_GE(response.actions.size(), 1);
|
EXPECT_EQ(response.actions[0].type, "test_code");
|
}
|
#endif
|
|
TEST_F(ActionsSuggestionsTest, SuggestActionsRanking) {
|
std::unique_ptr<ActionsSuggestions> actions_suggestions = LoadTestModel();
|
std::vector<AnnotatedSpan> annotations(2);
|
annotations[0].span = {11, 15};
|
annotations[0].classification = {ClassificationResult("address", 1.0)};
|
annotations[1].span = {19, 23};
|
annotations[1].classification = {ClassificationResult("address", 2.0)};
|
const ActionsSuggestionsResponse& response =
|
actions_suggestions->SuggestActions(
|
{{{/*user_id=*/1, "are you at home or work?",
|
/*reference_time_ms_utc=*/0,
|
/*reference_timezone=*/"Europe/Zurich",
|
/*annotations=*/annotations,
|
/*locales=*/"en"}}});
|
EXPECT_GE(response.actions.size(), 2);
|
EXPECT_EQ(response.actions[0].type, "view_map");
|
EXPECT_EQ(response.actions[0].score, 2.0);
|
EXPECT_EQ(response.actions[1].type, "view_map");
|
EXPECT_EQ(response.actions[1].score, 1.0);
|
}
|
|
TEST_F(ActionsSuggestionsTest, VisitActionsModel) {
|
EXPECT_TRUE(VisitActionsModel<bool>(GetModelPath() + kModelFileName,
|
[](const ActionsModel* model) {
|
if (model == nullptr) {
|
return false;
|
}
|
return true;
|
}));
|
EXPECT_FALSE(VisitActionsModel<bool>(GetModelPath() + "non_existing_model.fb",
|
[](const ActionsModel* model) {
|
if (model == nullptr) {
|
return false;
|
}
|
return true;
|
}));
|
}
|
|
TEST_F(ActionsSuggestionsTest, SuggestActionsWithHashGramModel) {
|
std::unique_ptr<ActionsSuggestions> actions_suggestions =
|
LoadHashGramTestModel();
|
ASSERT_TRUE(actions_suggestions != nullptr);
|
{
|
const ActionsSuggestionsResponse& response =
|
actions_suggestions->SuggestActions(
|
{{{/*user_id=*/1, "hello",
|
/*reference_time_ms_utc=*/0,
|
/*reference_timezone=*/"Europe/Zurich",
|
/*annotations=*/{},
|
/*locales=*/"en"}}});
|
EXPECT_THAT(response.actions, testing::IsEmpty());
|
}
|
{
|
const ActionsSuggestionsResponse& response =
|
actions_suggestions->SuggestActions(
|
{{{/*user_id=*/1, "where are you",
|
/*reference_time_ms_utc=*/0,
|
/*reference_timezone=*/"Europe/Zurich",
|
/*annotations=*/{},
|
/*locales=*/"en"}}});
|
EXPECT_THAT(
|
response.actions,
|
ElementsAre(testing::Field(&ActionSuggestion::type, "share_location")));
|
}
|
{
|
const ActionsSuggestionsResponse& response =
|
actions_suggestions->SuggestActions(
|
{{{/*user_id=*/1, "do you know johns number",
|
/*reference_time_ms_utc=*/0,
|
/*reference_timezone=*/"Europe/Zurich",
|
/*annotations=*/{},
|
/*locales=*/"en"}}});
|
EXPECT_THAT(
|
response.actions,
|
ElementsAre(testing::Field(&ActionSuggestion::type, "share_contact")));
|
}
|
}
|
|
// Test class to expose token embedding methods for testing.
|
class TestingMessageEmbedder : private ActionsSuggestions {
|
public:
|
explicit TestingMessageEmbedder(const ActionsModel* model);
|
|
using ActionsSuggestions::EmbedAndFlattenTokens;
|
using ActionsSuggestions::EmbedTokensPerMessage;
|
|
protected:
|
// EmbeddingExecutor that always returns features based on
|
// the id of the sparse features.
|
class FakeEmbeddingExecutor : public EmbeddingExecutor {
|
public:
|
bool AddEmbedding(const TensorView<int>& sparse_features, float* dest,
|
const int dest_size) const override {
|
TC3_CHECK_GE(dest_size, 1);
|
EXPECT_EQ(sparse_features.size(), 1);
|
dest[0] = sparse_features.data()[0];
|
return true;
|
}
|
};
|
};
|
|
TestingMessageEmbedder::TestingMessageEmbedder(const ActionsModel* model) {
|
model_ = model;
|
const ActionsTokenFeatureProcessorOptions* options =
|
model->feature_processor_options();
|
feature_processor_.reset(
|
new ActionsFeatureProcessor(options, /*unilib=*/nullptr));
|
embedding_executor_.reset(new FakeEmbeddingExecutor());
|
EXPECT_TRUE(
|
EmbedTokenId(options->padding_token_id(), &embedded_padding_token_));
|
EXPECT_TRUE(EmbedTokenId(options->start_token_id(), &embedded_start_token_));
|
EXPECT_TRUE(EmbedTokenId(options->end_token_id(), &embedded_end_token_));
|
token_embedding_size_ = feature_processor_->GetTokenEmbeddingSize();
|
EXPECT_EQ(token_embedding_size_, 1);
|
}
|
|
class EmbeddingTest : public testing::Test {
|
protected:
|
EmbeddingTest() {
|
model_.feature_processor_options.reset(
|
new ActionsTokenFeatureProcessorOptionsT);
|
options_ = model_.feature_processor_options.get();
|
options_->chargram_orders = {1};
|
options_->num_buckets = 1000;
|
options_->embedding_size = 1;
|
options_->start_token_id = 0;
|
options_->end_token_id = 1;
|
options_->padding_token_id = 2;
|
options_->tokenizer_options.reset(new ActionsTokenizerOptionsT);
|
}
|
|
TestingMessageEmbedder CreateTestingMessageEmbedder() {
|
flatbuffers::FlatBufferBuilder builder;
|
FinishActionsModelBuffer(builder, ActionsModel::Pack(builder, &model_));
|
buffer_ = builder.ReleaseBufferPointer();
|
return TestingMessageEmbedder(
|
flatbuffers::GetRoot<ActionsModel>(buffer_.data()));
|
}
|
|
flatbuffers::DetachedBuffer buffer_;
|
ActionsModelT model_;
|
ActionsTokenFeatureProcessorOptionsT* options_;
|
};
|
|
TEST_F(EmbeddingTest, EmbedsTokensPerMessageWithNoBounds) {
|
const TestingMessageEmbedder embedder = CreateTestingMessageEmbedder();
|
std::vector<std::vector<Token>> tokens = {
|
{Token("a", 0, 1), Token("b", 2, 3), Token("c", 4, 5)}};
|
std::vector<float> embeddings;
|
int max_num_tokens_per_message = 0;
|
|
EXPECT_TRUE(embedder.EmbedTokensPerMessage(tokens, &embeddings,
|
&max_num_tokens_per_message));
|
|
EXPECT_EQ(max_num_tokens_per_message, 3);
|
EXPECT_EQ(embeddings.size(), 3);
|
EXPECT_THAT(embeddings[0],
|
testing::FloatEq(tc3farmhash::Fingerprint64("a", 1) %
|
options_->num_buckets));
|
EXPECT_THAT(embeddings[1],
|
testing::FloatEq(tc3farmhash::Fingerprint64("b", 1) %
|
options_->num_buckets));
|
EXPECT_THAT(embeddings[2],
|
testing::FloatEq(tc3farmhash::Fingerprint64("c", 1) %
|
options_->num_buckets));
|
}
|
|
TEST_F(EmbeddingTest, EmbedsTokensPerMessageWithPadding) {
|
options_->min_num_tokens_per_message = 5;
|
const TestingMessageEmbedder embedder = CreateTestingMessageEmbedder();
|
std::vector<std::vector<Token>> tokens = {
|
{Token("a", 0, 1), Token("b", 2, 3), Token("c", 4, 5)}};
|
std::vector<float> embeddings;
|
int max_num_tokens_per_message = 0;
|
|
EXPECT_TRUE(embedder.EmbedTokensPerMessage(tokens, &embeddings,
|
&max_num_tokens_per_message));
|
|
EXPECT_EQ(max_num_tokens_per_message, 5);
|
EXPECT_EQ(embeddings.size(), 5);
|
EXPECT_THAT(embeddings[0],
|
testing::FloatEq(tc3farmhash::Fingerprint64("a", 1) %
|
options_->num_buckets));
|
EXPECT_THAT(embeddings[1],
|
testing::FloatEq(tc3farmhash::Fingerprint64("b", 1) %
|
options_->num_buckets));
|
EXPECT_THAT(embeddings[2],
|
testing::FloatEq(tc3farmhash::Fingerprint64("c", 1) %
|
options_->num_buckets));
|
EXPECT_THAT(embeddings[3], testing::FloatEq(options_->padding_token_id));
|
EXPECT_THAT(embeddings[4], testing::FloatEq(options_->padding_token_id));
|
}
|
|
TEST_F(EmbeddingTest, EmbedsTokensPerMessageDropsAtBeginning) {
|
options_->max_num_tokens_per_message = 2;
|
const TestingMessageEmbedder embedder = CreateTestingMessageEmbedder();
|
std::vector<std::vector<Token>> tokens = {
|
{Token("a", 0, 1), Token("b", 2, 3), Token("c", 4, 5)}};
|
std::vector<float> embeddings;
|
int max_num_tokens_per_message = 0;
|
|
EXPECT_TRUE(embedder.EmbedTokensPerMessage(tokens, &embeddings,
|
&max_num_tokens_per_message));
|
|
EXPECT_EQ(max_num_tokens_per_message, 2);
|
EXPECT_EQ(embeddings.size(), 2);
|
EXPECT_THAT(embeddings[0],
|
testing::FloatEq(tc3farmhash::Fingerprint64("b", 1) %
|
options_->num_buckets));
|
EXPECT_THAT(embeddings[1],
|
testing::FloatEq(tc3farmhash::Fingerprint64("c", 1) %
|
options_->num_buckets));
|
}
|
|
TEST_F(EmbeddingTest, EmbedsTokensPerMessageWithMultipleMessagesNoBounds) {
|
const TestingMessageEmbedder embedder = CreateTestingMessageEmbedder();
|
std::vector<std::vector<Token>> tokens = {
|
{Token("a", 0, 1), Token("b", 2, 3), Token("c", 4, 5)},
|
{Token("d", 0, 1), Token("e", 2, 3)}};
|
std::vector<float> embeddings;
|
int max_num_tokens_per_message = 0;
|
|
EXPECT_TRUE(embedder.EmbedTokensPerMessage(tokens, &embeddings,
|
&max_num_tokens_per_message));
|
|
EXPECT_EQ(max_num_tokens_per_message, 3);
|
EXPECT_THAT(embeddings[0],
|
testing::FloatEq(tc3farmhash::Fingerprint64("a", 1) %
|
options_->num_buckets));
|
EXPECT_THAT(embeddings[1],
|
testing::FloatEq(tc3farmhash::Fingerprint64("b", 1) %
|
options_->num_buckets));
|
EXPECT_THAT(embeddings[2],
|
testing::FloatEq(tc3farmhash::Fingerprint64("c", 1) %
|
options_->num_buckets));
|
EXPECT_THAT(embeddings[3],
|
testing::FloatEq(tc3farmhash::Fingerprint64("d", 1) %
|
options_->num_buckets));
|
EXPECT_THAT(embeddings[4],
|
testing::FloatEq(tc3farmhash::Fingerprint64("e", 1) %
|
options_->num_buckets));
|
EXPECT_THAT(embeddings[5], testing::FloatEq(options_->padding_token_id));
|
}
|
|
TEST_F(EmbeddingTest, EmbedsFlattenedTokensWithNoBounds) {
|
const TestingMessageEmbedder embedder = CreateTestingMessageEmbedder();
|
std::vector<std::vector<Token>> tokens = {
|
{Token("a", 0, 1), Token("b", 2, 3), Token("c", 4, 5)}};
|
std::vector<float> embeddings;
|
int total_token_count = 0;
|
|
EXPECT_TRUE(
|
embedder.EmbedAndFlattenTokens(tokens, &embeddings, &total_token_count));
|
|
EXPECT_EQ(total_token_count, 5);
|
EXPECT_EQ(embeddings.size(), 5);
|
EXPECT_THAT(embeddings[0], testing::FloatEq(options_->start_token_id));
|
EXPECT_THAT(embeddings[1],
|
testing::FloatEq(tc3farmhash::Fingerprint64("a", 1) %
|
options_->num_buckets));
|
EXPECT_THAT(embeddings[2],
|
testing::FloatEq(tc3farmhash::Fingerprint64("b", 1) %
|
options_->num_buckets));
|
EXPECT_THAT(embeddings[3],
|
testing::FloatEq(tc3farmhash::Fingerprint64("c", 1) %
|
options_->num_buckets));
|
EXPECT_THAT(embeddings[4], testing::FloatEq(options_->end_token_id));
|
}
|
|
TEST_F(EmbeddingTest, EmbedsFlattenedTokensWithPadding) {
|
options_->min_num_total_tokens = 7;
|
const TestingMessageEmbedder embedder = CreateTestingMessageEmbedder();
|
std::vector<std::vector<Token>> tokens = {
|
{Token("a", 0, 1), Token("b", 2, 3), Token("c", 4, 5)}};
|
std::vector<float> embeddings;
|
int total_token_count = 0;
|
|
EXPECT_TRUE(
|
embedder.EmbedAndFlattenTokens(tokens, &embeddings, &total_token_count));
|
|
EXPECT_EQ(total_token_count, 7);
|
EXPECT_EQ(embeddings.size(), 7);
|
EXPECT_THAT(embeddings[0], testing::FloatEq(options_->start_token_id));
|
EXPECT_THAT(embeddings[1],
|
testing::FloatEq(tc3farmhash::Fingerprint64("a", 1) %
|
options_->num_buckets));
|
EXPECT_THAT(embeddings[2],
|
testing::FloatEq(tc3farmhash::Fingerprint64("b", 1) %
|
options_->num_buckets));
|
EXPECT_THAT(embeddings[3],
|
testing::FloatEq(tc3farmhash::Fingerprint64("c", 1) %
|
options_->num_buckets));
|
EXPECT_THAT(embeddings[4], testing::FloatEq(options_->end_token_id));
|
EXPECT_THAT(embeddings[5], testing::FloatEq(options_->padding_token_id));
|
EXPECT_THAT(embeddings[6], testing::FloatEq(options_->padding_token_id));
|
}
|
|
TEST_F(EmbeddingTest, EmbedsFlattenedTokensDropsAtBeginning) {
|
options_->max_num_total_tokens = 3;
|
const TestingMessageEmbedder embedder = CreateTestingMessageEmbedder();
|
std::vector<std::vector<Token>> tokens = {
|
{Token("a", 0, 1), Token("b", 2, 3), Token("c", 4, 5)}};
|
std::vector<float> embeddings;
|
int total_token_count = 0;
|
|
EXPECT_TRUE(
|
embedder.EmbedAndFlattenTokens(tokens, &embeddings, &total_token_count));
|
|
EXPECT_EQ(total_token_count, 3);
|
EXPECT_EQ(embeddings.size(), 3);
|
EXPECT_THAT(embeddings[0],
|
testing::FloatEq(tc3farmhash::Fingerprint64("b", 1) %
|
options_->num_buckets));
|
EXPECT_THAT(embeddings[1],
|
testing::FloatEq(tc3farmhash::Fingerprint64("c", 1) %
|
options_->num_buckets));
|
EXPECT_THAT(embeddings[2], testing::FloatEq(options_->end_token_id));
|
}
|
|
TEST_F(EmbeddingTest, EmbedsFlattenedTokensWithMultipleMessagesNoBounds) {
|
const TestingMessageEmbedder embedder = CreateTestingMessageEmbedder();
|
std::vector<std::vector<Token>> tokens = {
|
{Token("a", 0, 1), Token("b", 2, 3), Token("c", 4, 5)},
|
{Token("d", 0, 1), Token("e", 2, 3)}};
|
std::vector<float> embeddings;
|
int total_token_count = 0;
|
|
EXPECT_TRUE(
|
embedder.EmbedAndFlattenTokens(tokens, &embeddings, &total_token_count));
|
|
EXPECT_EQ(total_token_count, 9);
|
EXPECT_EQ(embeddings.size(), 9);
|
EXPECT_THAT(embeddings[0], testing::FloatEq(options_->start_token_id));
|
EXPECT_THAT(embeddings[1],
|
testing::FloatEq(tc3farmhash::Fingerprint64("a", 1) %
|
options_->num_buckets));
|
EXPECT_THAT(embeddings[2],
|
testing::FloatEq(tc3farmhash::Fingerprint64("b", 1) %
|
options_->num_buckets));
|
EXPECT_THAT(embeddings[3],
|
testing::FloatEq(tc3farmhash::Fingerprint64("c", 1) %
|
options_->num_buckets));
|
EXPECT_THAT(embeddings[4], testing::FloatEq(options_->end_token_id));
|
EXPECT_THAT(embeddings[5], testing::FloatEq(options_->start_token_id));
|
EXPECT_THAT(embeddings[6],
|
testing::FloatEq(tc3farmhash::Fingerprint64("d", 1) %
|
options_->num_buckets));
|
EXPECT_THAT(embeddings[7],
|
testing::FloatEq(tc3farmhash::Fingerprint64("e", 1) %
|
options_->num_buckets));
|
EXPECT_THAT(embeddings[8], testing::FloatEq(options_->end_token_id));
|
}
|
|
TEST_F(EmbeddingTest,
|
EmbedsFlattenedTokensWithMultipleMessagesDropsAtBeginning) {
|
options_->max_num_total_tokens = 7;
|
const TestingMessageEmbedder embedder = CreateTestingMessageEmbedder();
|
std::vector<std::vector<Token>> tokens = {
|
{Token("a", 0, 1), Token("b", 2, 3), Token("c", 4, 5)},
|
{Token("d", 0, 1), Token("e", 2, 3), Token("f", 4, 5)}};
|
std::vector<float> embeddings;
|
int total_token_count = 0;
|
|
EXPECT_TRUE(
|
embedder.EmbedAndFlattenTokens(tokens, &embeddings, &total_token_count));
|
|
EXPECT_EQ(total_token_count, 7);
|
EXPECT_EQ(embeddings.size(), 7);
|
EXPECT_THAT(embeddings[0],
|
testing::FloatEq(tc3farmhash::Fingerprint64("c", 1) %
|
options_->num_buckets));
|
EXPECT_THAT(embeddings[1], testing::FloatEq(options_->end_token_id));
|
EXPECT_THAT(embeddings[2], testing::FloatEq(options_->start_token_id));
|
EXPECT_THAT(embeddings[3],
|
testing::FloatEq(tc3farmhash::Fingerprint64("d", 1) %
|
options_->num_buckets));
|
EXPECT_THAT(embeddings[4],
|
testing::FloatEq(tc3farmhash::Fingerprint64("e", 1) %
|
options_->num_buckets));
|
EXPECT_THAT(embeddings[5],
|
testing::FloatEq(tc3farmhash::Fingerprint64("f", 1) %
|
options_->num_buckets));
|
EXPECT_THAT(embeddings[6], testing::FloatEq(options_->end_token_id));
|
}
|
|
} // namespace
|
} // namespace libtextclassifier3
|
