:Configurar filtros

O mecanismo PAI-Rec oferece diversos modelos de filtro integrados, incluindo User2ItemExposureFilter, ItemStateFilter e AdjustCountFilter.

Configurações de filtro

Configure os filtros definindo o parâmetro FilterConfs conforme o código de exemplo a seguir. FilterConfs é um array de objetos que permite definir várias políticas de filtragem.

Visão geral das configurações comuns de filtro

Esta seção descreve as configurações comuns referenciadas por diferentes filtros. Essas definições não se repetem nas descrições detalhadas de cada filtro neste tópico.

Configuração de exemplo:

{
    "FilterConfs": [
        {
            "Name": "",
            "FilterType": "",
            "Dimension": "",
            "DaoConf": {},
            "AdjustCountConfs": [],
            "ItemStateDaoConf": {},
            "FilterParams": [],
            "DiversityDaoConf": {},
            "FilterVal": {}
        }
    ]
}

User2ItemExposureFilter

Em muitos cenários de negócios, a filtragem de exposição evita recomendações repetidas. Geralmente, combina-se pseudoexposição e exposição real.

Pseudoexposição: A latência dos logs em tempo real impede a identificação imediata dos itens expostos. Por isso, a lista de itens retornada pelo mecanismo de recomendação funciona como lista de pseudoexposição.

Um mecanismo de computação em tempo real, como o Flink, grava logs em um banco de dados para consumo posterior pelo mecanismo PAI-Rec.

Os parâmetros comuns a seguir aplicam-se à filtragem de exposição para várias fontes de dados.

{
    "FilterConfs": [
        {
            "Name": "holo_exposure_filter",
            "FilterType": "User2ItemExposureFilter",
            "MaxItems": 100,
            "TimeInterval": 172800,
            "WriteLog": true,
            "DaoConf": {
                "AdapterType": "hologres",
                "HologresName": "holo_info",
                "HologresTableName": "exposure_history"
            }
        }
    ]
}

BEGIN;
CREATE TABLE "exposure_history" (
 "uid" text NOT NULL,
 "item" text NOT NULL,
 "create_time" int4 NOT NULL
);
CALL SET_TABLE_PROPERTY('"exposure_history"', 'orientation', 'column');
CALL set_table_property('"exposure_history"', 'distribution_key', 'uid');
CALL SET_TABLE_PROPERTY('"exposure_history"', 'clustering_key', '"uid","create_time"');
CALL SET_TABLE_PROPERTY('"exposure_history"', 'segment_key', '"create_time"');
CALL SET_TABLE_PROPERTY('"exposure_history"', 'bitmap_columns', '"uid","item"');
CALL SET_TABLE_PROPERTY('"exposure_history"', 'dictionary_encoding_columns', '"uid","item"');
CALL SET_TABLE_PROPERTY('"exposure_history"', 'time_to_live_in_seconds', '172800');
comment on table "exposure_history" is 'Exposure history table';
COMMIT;

{
    "FilterConfs": [
        {
            "Name": "fs_exposure_filter",
            "FilterType": "User2ItemExposureFilter",
            "TimeInterval": 300,
            "WriteLog": true,
            "DaoConf": {
                "AdapterType": "featurestore",
                "FeatureStoreName": "fs_pairec",
                "FeatureStoreViewName": "user_expose"
            }
        }
    ]
}

"FilterConfs": [
        {
            "Name": "fs_exposure_filter2",
            "FilterType": "User2ItemExposureFilter",
            "WriteLog": false,
            "DaoConf": {
                "AdapterType": "featurestore",
                "FeatureStoreName": "fs_pairec",
                "FeatureStoreViewName": "user_expose"
            }
        }
    ]

{
    "FilterConfs": [
        {
            "Name": "redis_exposure_filter",
            "FilterType": "User2ItemExposureFilter",
            "MaxItems": 100,
            "TimeInterval": 172800,
            "WriteLog": true,
            "DaoConf": {
                "AdapterType": "redis",
                "RedisName": "redis_info",
                "RedisPrefix": "exposure_"
            }
        }
    ]
}

{
    "FilterConfs": [
        {
            "Name": "ots_exposure_filter",
            "FilterType": "User2ItemExposureFilter",
            "MaxItems": 100,
            "TimeInterval": 172800,
            "WriteLog": true,
            "DaoConf": {
                "AdapterType": "tablestore",
                "TableStoreName": "tablestore_info",
                "TableStoreTableName": "exposure_history"
            }
        }
    ]
}

Rebaixamento por impressão

Quando o pool de recall de um usuário é pequeno, a filtragem de impressão pode eliminar todos os itens disponíveis. Para evitar isso, marque os itens já visualizados em vez de filtrá-los completamente. Durante a reclassificação, aplique boosting e rebaixamento para mover esses itens marcados para o final da lista. O exemplo a seguir demonstra essa configuração para uma fonte de dados Hologres. O processo é semelhante para outras fontes de dados.

{
    "FilterConfs": [
        {
            "Name": "holo_exposure_filter",
            "FilterType": "User2ItemExposureFilter",
            "MaxItems": 20,
            "TimeInterval": 172800,
            "WriteLog": true,
            "OnlyLogUserExposeFlag": true,
            "DaoConf": {
                "AdapterType": "hologres",
                "HologresName": "holo_info",
                "HologresTableName": "exposure_history"
            }
        }
    ],
    "SortConfs": [
        {
            "Name": "boost_score_sort",
            "SortType": "BoostScoreSort",
            "BoostScoreConditions": [
                {
                    "Conditions": [
                        {
                            "Name": "_is_exposure_",
                            "Domain": "item",
                            "Type": "int",
                            "Value": 1,
                            "Operator": "equal"
                        }
                    ],
                    "Expression": "score / 10"
                }
            ]
        }
    ]
}
This JSON example defines filter and sort configurations. The FilterConfs section uses the holo_exposure_filter to filter out items a user has already been exposed to, based on data from the exposure_history table in Hologres. The SortConfs section uses boost_score_sort for score boosting: if an item has been exposed (_is_exposure_ is 1), its score is divided by 10, reducing its ranking.

User2ItemCustomFilter

{
    "FilterConfs": [
        {
            "Name": "u2i_custom_filter",
            "FilterType": "User2ItemCustomFilter",
            "DaoConf": {
                "AdapterType": "hologres",
                "HologresName": "holo_info",
                "HologresTableName": "u2i_custom_filter"
            },
            "ItemStateCacheSize": 10000,
            "ItemStateCacheTime": 3600
        }
    ]
}

{
    "FilterConfs": [
        {
            "Name": "u2i_custom_filter",
            "FilterType": "User2ItemCustomFilter",
            "DaoConf": {
                "AdapterType": "tablestore",
                "TableStoreName": "tablestore_info",
                "TableStoreTableName": "u2i_table"
            }
        }
    ]
}

  {
    "FilterConfs": [
        {
            "Name": "u2i_custom_filter",
            "FilterType": "User2ItemCustomFilter",
            "DaoConf": {
                "AdapterType": "featurestore",
                "FeatureStoreName": "fs_pairec",
                "FeatureStoreViewName": "u2icustom_filter"
            }
        }
    ]
}

AdjustCountFilter

O AdjustCountFilter embaralha aleatoriamente os itens retornados pelos links de recall e retém um número especificado de itens.

Configuração de exemplo:

{
    "FilterConfs": [
        {
            "Name": "adjust_count_filter",
            "FilterType": "AdjustCountFilter",
            "ShuffleItem": true,
            "RetainNum": 500
        }
    ]
}

PriorityAdjustCountFilter

O PriorityAdjustCountFilter controla o número de itens selecionados dos resultados retornados pelos links de recall com base nas pontuações. Cada link de recall classifica os itens recomendados de acordo com suas pontuações.

Configuração de exemplo:

{
    "FilterConfs": [
        {
            "Name": "priority_adjust_count_filter",
            "FilterType": "PriorityAdjustCountFilter",
            "AdjustCountConfs": [
                {
                    "RecallName": "recall_1",
                    "Count": 125,
                    "Type": "accumulator"
                },
                {
                    "RecallName": "recall_2",
                    "Count": 250,
                    "Type": "accumulator"
                },
                {
                    "RecallName": "recall_3",
                    "Count": 400,
                    "Type": "accumulator"
                }
            ]
        }
    ]
}

ItemStateFilter

Filtrar itens recuperados por estado exige buscar seus estados em tempo real, pois eles podem mudar a qualquer momento. Esses estados geralmente residem em uma tabela dedicada.

{
    "FilterConfs": [
        {
            "Name": "ItemStateFilter",
            "FilterType": "ItemStateFilter",
            "ItemStateDaoConf": {
                "AdapterType": "hologres",
                "HologresName": "",
                "HologresTableName": "",
                "ItemFieldName": "",
                "WhereClause": "",
                "SelectFields": ""
            },
            "ItemStateCacheSize": 50000,
            "ItemStateCacheTime": 3600,
            "FilterParams": [

            ]
        }
    ]
}

{
    "FilterParams": [
        {
            "Name": "publicStatus",
            "Type": "int",
            "Operator": "equal",
            "Value": 0
        },
        {
            "Name": "state",
            "Type": "int",
            "Operator": "equal",
            "Value": 1
        },
        {
            "Name": "checkStatus",
            "Type": "int",
            "Operator": "not_equal",
            "Value": 2
        },
        {
            "Name": "norec",
            "Type": "int",
            "Operator": "not_equal",
            "Value": 1
        }
    ]
}

{
    "FilterConfs": [
        {
            "Name": "ItemStateFilter",
            "FilterType": "ItemStateFilter",
            "ItemStateDaoConf": {
                "AdapterType": "featurestore",
                "FeatureStoreName": "",
                "FeatureStoreViewName": "",
                "ItemFieldName": "",
                "SelectFields": ""
            },
            "ItemStateCacheSize": 50000,
            "ItemStateCacheTime": 3600,
            "FilterParams": [

            ]
        }
    ]
}

{
    "FilterParams": [
        {
            "Name": "publicStatus",
            "Type": "int",
            "Operator": "equal",
            "Value": 0
        },
        {
            "Name": "state",
            "Type": "int",
            "Operator": "equal",
            "Value": 1
        },
        {
            "Name": "checkStatus",
            "Type": "int",
            "Operator": "not_equal",
            "Value": 2
        },
        {
            "Name": "norec",
            "Type": "int",
            "Operator": "not_equal",
            "Value": 1
        }
    ]
}

SnakeFilter

A etapa de recall recupera um conjunto de candidatos de múltiplos canais. O SnakeFilter combina dados desses canais em ordem round-robin, com base nas proporções de peso especificadas.

Por exemplo, se houver três canais de recall (A, B e C) com pesos 1, 2 e 3, respectivamente, a lógica de combinação funciona assim:

• Selecione um elemento do conjunto candidato A.

• Selecione dois elementos do conjunto candidato B.

• Selecione três elementos do conjunto candidato C.

• Repetir esse processo até obter o número necessário de elementos.

Existem duas políticas para lidar com elementos duplicados:

• REFILL_ON_DUPLICATE: Se um elemento recuperado de um conjunto candidato duplicar outro selecionado anteriormente, o sistema busca no mesmo conjunto um substituto exclusivo. Por exemplo, se os três elementos recuperados do conjunto C duplicarem elementos já selecionados dos conjuntos A e B, o sistema procura substitutos no conjunto C.

• SKIP_ON_DUPLICATE: O sistema ignora elementos duplicados e passa para a próxima iteração. Por exemplo, se os três elementos recuperados do conjunto C duplicarem elementos dos conjuntos A e B, o conjunto C não retorna nenhum elemento nesta rodada. O processo inicia então uma nova iteração, começando pelo conjunto A.

{
    "FilterConfs": [
        {
            "Name": "SnakeFilter",
            "FilterType": "SnakeFilter",
            "RetainNum": 20,
            "SnakeType": "REFILL_ON_DUPLICATE",
            "AdjustCountConfs": [
                 {
                     "RecallName": "GroupHotRecall",
                     "Weight": 1
                 },
                 {
                     "RecallName": "U2IRecall",
                     "Weight": 2
                 },
                 {
                     "RecallName": "GlobalHotRecall",
                     "Weight": 3
                 }
             ]
        }
    ]
}

CompletelyFairFilter

O CompletelyFairFilter classifica os itens retornados pelos links de recall com base em suas pontuações e seleciona itens dos resultados de cada link de maneira equitativa.

{
    "FilterConfs": [
        {
            "Name": "CompletelyFairFilter",
            "FilterType": "CompletelyFairFilter",
            "RetainNum": 500
        }
    ]
}

DimensionFieldUniqueFilter

O DimensionFieldUniqueFilter funciona de maneira diferente do UniqueFilter, pois remove itens com valores de campo duplicados.

{
    "FilterConfs": [
        {
            "Name": "DimensionFieldUniqueFilter",
            "FilterType": "DimensionFieldUniqueFilter",
            "Dimension": ""
        }
    ]
}

ConditionFilter

Este filtro composto executa dinamicamente um filtro específico com base nas condições da solicitação, como recursos do usuário ou aqueles passados no context. Configure uma ou mais combinações, vinculando cada conjunto de condições a um filtro específico definido em FilterConfs.

O exemplo anterior define dois filtros independentes: adjust_count_filter e CompletelyFairFilter. O ConditionFilter roteia solicitações com base em condições. Quando o atributo de usuário query for igual a "1", ele usa adjust_count_filter. Se nenhuma condição corresponder, ele recorre ao filtro especificado por DefaultFilterName (CompletelyFairFilter).

Parâmetros de configuração:

Configuração de FilterConfs:

Configure FilterParamConfig da seguinte forma:

Para detalhes sobre as configurações de condição, consulte o apêndice.

UniqueFilter

O UniqueFilter garante que cada ID de item seja exclusivo. Se dois links de recall retornarem o mesmo ID de item, o UniqueFilter prioriza o ID retornado primeiro.

Use o UniqueFilter ao configurar o parâmetro FilterNames, sem necessidade de configurar o próprio UniqueFilter.

Uso de filtros

Assim como na configuração de recall, a configuração de filtro usa o parâmetro FilterNames. Este parâmetro é um Map[string]object que mapeia cada cenário a um conjunto de políticas de filtro.

• ${scene_name}: Nome do cenário. Para aplicar a mesma configuração a vários cenários, use default.

• UniqueFilter: Nome personalizado para um filtro definido em FilterConfigs.

Apêndice

Exemplos de operadores

1. equal (igual ao valor especificado)

{
    "Name": "publicStatus",
    "Type": "int",
    "Operator": "equal",
    "Value": 0
}

1. not_equal (diferente do valor especificado)

{
    "name": "checkStatus",
    "type": "int",
    "operator": "not_equal",
    "value": 2
}

1. greater (maior que o valor especificado)

{
    "Name": "checkStatus",
    "Type": "int",
    "Operator": "greater",
    "Value": 2
}

1. greaterThan (maior ou igual ao valor especificado)

{
    "Name": "checkStatus",
    "Type": "int",
    "Operator": "greaterThan",
    "Value": 2
}

1. less (menor que o valor especificado)

{
    "Name": "checkStatus",
    "Type": "int",
    "Operator": "less",
    "Value": 2
}

1. lessThan (menor ou igual ao valor especificado)

{
    "Name": "checkStatus",
    "Type": "int",
    "Operator": "lessThan",
    "Value": 2
}

1. in (corresponde a qualquer valor em um array)

String

{
    "Name": "state",
    "Type": "string",
    "Operator": "in",
    "Value": ["success","ok"]
}

1. not_in (não corresponde a nenhum item no array)

{
    "name": "state",
    "type": "int",
    "operator": "not_in",
    "value": [2,4,6]
}

Também é possível usar o tipo string e configurá-lo com o operador in.

1. contains (corresponde a qualquer item em um array)

{
    "Name": "state",
    "Type": "[]int",
    "Operator": "contains",
    "Value": [2,4,6]
}

tipo string

{
    "Name": "state",
    "Type": "[]string",
    "Operator": "contains",
    "Value": ["success","ok"]
}

1. not_contains (não contém nenhum dos itens especificados)

{
    "Name": "state",
    "Type": "[]int",
    "Operator": "not_contains",
    "Value": [2,4,6]
}
The following code uses the not_contains operator to filter for items where the state field does not contain any value from the array [2, 4, 6]. This filter is useful for excluding specific items from a query result. For example, you could use this filter to retrieve all tasks except those with a status of 'archived' (ID 2), 'on-hold' (ID 4), or 'deprecated' (ID 6).

Você também pode usar um array de strings. Para detalhes de configuração, consulte o operador contains.

1. bool (combina múltiplos operadores de correspondência de condições)

Combine condições com or.

{
    "Operator": "bool",
    "Type": "or",
    "Configs":
    [
        {
            "Name": "publicStatus",
            "Type": "int",
            "Operator": "equal",
            "Value": 0
        },
        {
            "Name": "checkStatus",
            "Type": "int",
            "Operator": "greater",
            "Value": 2
        }
    ]
}

Usar and é semelhante: defina Type como and.

1. expression (corresponde quando a expressão é avaliada como verdadeira)

{
    "Operator": "expression",
    "Value": "item.size == 43"
}

item.size é um atributo de item; para acessar um atributo de user, use user.xxx.

As expressões suportam operadores aritméticos, de comparação, lógicos e ternários. Exemplo mais complexo:

{
    "Operator": "expression",
    "Value": "!item.sold_out and user.list != nil ? item.size in user.list : true"
}

Para a definição completa da sintaxe de expressão, consulte https://expr-lang.org/docs/language-definition.