Filtragem de bot no Query Service com aprendizado de máquina

A atividade de bot pode afetar as métricas de análise e prejudicar a integridade dos dados. O Adobe Experience Platform Query Service pode ser usado para manter a qualidade dos dados por meio do processo de filtragem de bot.

A filtragem de bot permite que você mantenha a qualidade dos seus dados, removendo amplamente a contaminação de dados resultante de interações não humanas com o seu site. Esse processo é obtido por meio da combinação de queries SQL e aprendizado de máquina.

A atividade de bot pode ser identificada de várias maneiras. A abordagem adotada neste documento se concentra em picos de atividade, neste caso, o número de ações executadas por um usuário em um determinado período de tempo. Inicialmente, uma consulta SQL define arbitrariamente um limite para o número de ações tomadas durante um período para se qualificar como atividade de bot. Esse limite é então refinado dinamicamente usando um modelo de aprendizado de máquina para melhorar a precisão dessas taxas.

Este documento fornece uma visão geral e exemplos detalhados das consultas de filtragem de bot SQL e dos modelos de aprendizado de máquina necessários para você configurar o processo no seu ambiente.

Introdução

Como parte desse processo requer que você treine um modelo de aprendizado de máquina, este documento presume um conhecimento prático de um ou mais ambientes de aprendizado de máquina.

Este exemplo usa Jupyter Notebook como um ambiente de desenvolvimento. Embora existam muitas opções disponíveis, Jupyter Notebook é recomendado porque é um aplicativo web de código aberto que tem poucos requisitos computacionais. Ele pode ser baixado do site oficial.

Usar Query Service para definir um limite para a atividade de bot

Os dois atributos usados para extrair dados para detecção de bot são:

A instrução SQL a seguir fornece um exemplo inicial para identificar a atividade de bot. A instrução pressupõe que, se um visitante realizar 50 cliques em um minuto, o usuário será um bot.

SELECT *
FROM   <YOUR_TABLE_NAME>
WHERE  enduserids._experience.mcid NOT IN (SELECT enduserids._experience.mcid
                                           FROM   <YOUR_TABLE_NAME>
                                           GROUP  BY Unix_timestamp(timestamp) /
                                                     60,
                                                     enduserids._experience.mcid
                                           HAVING Count(*) > 50);

A expressão filtra os ECIDs (mcid) de todos os visitantes que atingem o limite, mas não aborda picos no tráfego de outros intervalos.

Melhore a detecção de bot com o aprendizado de máquina

A instrução SQL inicial pode ser refinada para se tornar uma consulta de extração de recursos para aprendizado de máquina. O query aprimorado deve produzir mais recursos para uma variedade de intervalos para treinar modelos de aprendizado de máquina com alta precisão.

A instrução de exemplo é expandida de um minuto com até 60 cliques para incluir períodos de cinco minutos e 30 minutos com contagens de cliques de 300 e 1800, respectivamente.

A instrução de exemplo coleta o número máximo de cliques para cada ECID (mcid) nas várias durações. A instrução inicial foi expandida para incluir períodos de um minuto (60 segundos), 5 minutos (300 segundos) e uma hora (ou seja, 1800 segundos).

SELECT table_count_1_min.mcid AS id,
       count_1_min,
       count_5_mins,
       count_30_mins
FROM   ( ( (SELECT mcid,
                 Max(count_1_min) AS count_1_min
          FROM   (SELECT enduserids._experience.mcid.id AS mcid,
                         Count(*)                       AS count_1_min
                  FROM
       <YOUR_TABLE_NAME>
                  GROUP  BY Unix_timestamp(timestamp) / 60,
                            enduserids._experience.mcid.id)
          GROUP BY mcid) AS table_count_1_min
           LEFT JOIN (SELECT mcid,
                             Max(count_5_mins) AS count_5_mins
                      FROM   (SELECT enduserids._experience.mcid.id AS mcid,
                                     Count(*)                       AS
                                     count_5_mins
                              FROM
           <YOUR_TABLE_NAME>
                              GROUP  BY Unix_timestamp(timestamp) / 300,
                                        enduserids._experience.mcid.id)
                      GROUP  BY mcid) AS table_count_5_mins
                  ON table_count_1_min.mcid = table_count_5_mins.mcid )
         LEFT JOIN (SELECT mcid,
                           Max(count_30_mins) AS count_30_mins
                    FROM   (SELECT enduserids._experience.mcid.id AS mcid,
                                   Count(*)                       AS
                                   count_30_mins
                            FROM
         <YOUR_TABLE_NAME>
                            GROUP  BY Unix_timestamp(timestamp) / 1800,
                                      enduserids._experience.mcid.id)
                    GROUP  BY mcid) AS table_count_30_mins
                ON table_count_1_min.mcid = table_count_30_mins.mcid )

O resultado dessa expressão pode ser semelhante à tabela fornecida abaixo.

Identificar novos limites de pico usando aprendizado de máquina

Em seguida, exporte o conjunto de dados da consulta resultante para o formato CSV e, em seguida, importe-o para Jupyter Notebook. A partir desse ambiente, você pode treinar um modelo de aprendizado de máquina usando as bibliotecas de aprendizado de máquina atuais. Consulte o guia de solução de problemas para obter mais detalhes sobre como exportar dados de Query Service em formato CSV

Os limites de pico ad hoc inicialmente estabelecidos não são orientados por dados e, portanto, carecem de precisão. Os modelos de aprendizado de máquina podem ser usados para treinar parâmetros como limites. Como resultado, você pode aumentar a eficiência da consulta reduzindo o número de GROUP BY palavras-chave, removendo recursos desnecessários.

Este exemplo usa a biblioteca de aprendizado de máquina Scikit-Learn, que é instalada por padrão com o Jupyter Notebook. A biblioteca "pandas" Python também é importada para uso aqui. Os seguintes comandos estão sendo inseridos em Jupyter Notebook.

import pandas as ps

df = pd_read.csv('data/bot.csv')
df = df[df['count_1-min'] > 1]
df['is_bot'] = 0
df.loc[df['count_1_min'] > 50,'is_bot'] = 1
df

Em seguida, você deve treinar um classificador de árvore de decisão no conjunto de dados e observar a lógica resultante do modelo.

A biblioteca "Matplotlib" é usada para visualizar o classificador de árvore decisória no exemplo abaixo.

from sklearn.tree import DecisionTreeClassifier
from sklearn import tree
from matplotlib import pyplot as plt

X = df.iloc[:,:[1,3]]
y = df.iloc[:,-1]

clf = DecisionTreeClassifier(max_leaf_nodes=2, random_state=0)
clf.fit(X,y)

print("Model Accuracy: {:.5f}".format(clf.scre(X,y)))

tree.plot_tree(clf,feature_names=X.columns)
plt.show()

Os valores retornados de Jupyter Notebook para este exemplo são os seguintes.

Model Accuracy: 0.99935

Os resultados do modelo mostrado no exemplo acima têm mais de 99% de precisão.

Como o classificador da árvore de decisão pode ser treinado usando dados de Query Service regularmente com consultas agendadas, você pode garantir a integridade dos dados filtrando a atividade do bot com um alto grau de precisão. Usando os parâmetros derivados do modelo de aprendizado de máquina, as consultas originais podem ser atualizadas com os parâmetros altamente precisos criados pelo modelo.

O modelo de exemplo determinou com alto grau de precisão que todos os visitantes com mais de 130 interações em cinco minutos são bots. Essas informações agora podem ser usadas para refinar suas consultas SQL de filtragem de bot.

Próximas etapas

Ao ler este documento, você terá uma melhor compreensão de como usar o Query Service e o aprendizado de máquina para determinar e filtrar a atividade de bot.

Outros documentos que demonstram os benefícios do Query Service para os insights estratégicos de negócios da sua organização são o exemplo de uso de navegação abandonada.