Como prever o tráfego de pesquisa com Python e GA4

Publicados: 2021-04-26

Em qualquer estratégia focada em otimização de mecanismos de busca (SEO), a análise de dados é essencial. São cada vez mais os especialistas nesta área que optam por desenvolver as suas carreiras na análise do tráfego de busca orgânica, que por si só tem um comportamento e particularidades bastante diferentes das restantes: busca paga, email, social orgânico, direto, etc. nesse sentido e graças a uma ampla gama de ferramentas disponíveis hoje, esse tipo de estudo conseguiu evoluir a um grau impensável em comparação com apenas alguns anos atrás.

Este grande avanço deve-se principalmente ao aparecimento de novas metodologias e desenvolvimentos que nos permitiram gerar modelos analíticos sem depender de operações matemáticas complicadas. Temos a sorte de ter à nossa disposição as técnicas e algoritmos já testados e prontos para começar a trabalhar com eles.

No artigo abaixo, vamos nos concentrar na criação de um modelo preditivo para um conjunto de dados de uma série temporal onde a tendência calculada é ajustada à sazonalidade e periodicidade anterior. Mais especificamente, estaremos prevendo o tráfego de pesquisa orgânica de nossa propriedade a partir do Google Analytics 4 (doravante GA4). Existem muitas opções para fazer isso, porém para este caso em particular eu decidi executar o desenvolvimento inteiramente em Python.
O roteiro no qual este artigo se baseia consiste em três partes claramente diferenciadas:

  • Extração de dados . Como usar a nova API GA4 passo a passo para coletar tráfego de pesquisa orgânica.
  • Modelagem de dados . Uso do Prophet, a biblioteca de código aberto do Facebook para fazer previsões de séries temporais.
  • Visualização de dados . Mostrar mudanças de tendência e previsão modelada.

Extração de dados do GA4 por meio de sua API usando Python

A primeira coisa que precisamos saber quando estamos lidando com a API de dados do Google Analytics (GA4) é que GA4 é seu status de desenvolvimento. Conforme detalhado pelo Google em sua página, está atualmente em uma versão inicial. Especificamente, na data em que este artigo foi escrito, ainda está na fase Beta.

Deve-se notar que o GA4 foi publicado em 14 de outubro de 2020. Apenas alguns meses se passaram. Na verdade, quem já tinha uma propriedade do Universal Analytics e cria uma nova do GA4 poderá continuar usando as duas versões lado a lado, sem restrições. Não se sabe ao certo quando as propriedades do Universal Analytics deixarão de funcionar. De qualquer forma, minha recomendação seria criar uma nova propriedade do tipo GA4 o mais rápido possível. Dessa forma, você terá um histórico de dados mais amplo. Também deve ser considerado que cada dia que passa do GA4 integra novas funcionalidades ou melhora as já existentes. No momento está em constante evolução.

Por causa disso, é claro que pode haver pequenas alterações no código descrito abaixo. Embora com certeza, eles serão mínimos. Como exemplo, já encontrei pequenas ninharias, como renomear o campo “entidade” (fase Alfa) como “propriedade” (fase Beta) dentro da classe RunReportRequest() .
Antes de mais nada, antes de criar a solicitação da API, é necessário entender quais elementos estão disponíveis. Basicamente, trata-se de seguir a estrutura abaixo:

Tipos para RunReportRequest da API GA4 Data v1 Beta

À primeira vista é bastante intuitivo, embora a realidade seja bem diferente. Para fazer uma solicitação, é necessário ter sempre em mãos pelo menos a seguinte documentação:

  • Desenvolvedor de APIs do Google
  • Relatórios da API de dados do Google Analytics (GA4).

Isso ocorre simplesmente porque os nomes dos campos variam um pouco da documentação oficial, que representa os campos no formato JSON. Um exemplo é o campo fieldname da classe Filter. Em Python devemos descrevê-lo como field_name. Uma boa regra geral será sempre ir de um campo do tipo camel case (como “fieldName”) para um snake case (como “field_name”).

Antes de continuar, vamos fazer uma pausa por um momento para inicializar nosso projeto. Como na grande maioria dos casos ao desenvolver scripts em Python, temos que gastar algum tempo importando as bibliotecas necessárias e preparando o ambiente de execução.

  • Crie um novo projeto em Python. Nesse caso, o software PyCharm foi usado.
  • Ative a API de dados do Google Analytics no Google Cloud Platform e faça o download do arquivo de conta de serviço criado (tipo JSON) e salve-o na pasta onde o projeto Python foi criado. Ao abrir este arquivo, o valor do campo client_email deve ser copiado, que será algo como [email protected].
  • Adicione este valor client_email à propriedade GA4 da qual os dados serão extraídos. Você precisará fazer isso na seção de gerenciamento de usuários. No mínimo, será necessário conceder-lhe o nível de permissão 'Ler e Análise'.
  • Através do terminal do cliente (PyCharm) instale a biblioteca de dados do Google Analytics no diretório do projeto com o qual serão feitas as solicitações da API:
    pip install google-analytics-data

A partir daqui, tudo o que você precisa fazer é criar a solicitação, que, como você pode ver abaixo, consiste basicamente em três partes (cliente, solicitação e resposta), e visualizar ou salvar os dados coletados.

Código para fazer uma solicitação simples ao GA4

Qualquer dimensão, métrica, filtro, ordem de dados, intervalo de datas etc. adicionado à variável de solicitação deve ser adicionado como uma classe (consulte a imagem anterior “Tipos para RunReportRequest”) vinculada a uma variável ( métrica = [Métrica (..)] ). Isso torna muito mais fácil entender a estrutura dos dados a serem coletados. Nesse sentido, para cada classe de nível mais alto deve ser realizada uma importação específica. Ou seja, se você quiser adicionar uma dimensão e uma métrica para um intervalo de tempo específico, pelo menos os seguintes objetos serão necessários…

 de google.analytics.data_v1beta importar BetaAnalyticsDataClient
de google.analytics.data_v1beta.types import RunReportRequest
de google.analytics.data_v1beta.types import DateRange
da dimensão de importação de google.analytics.data_v1beta.types
da métrica de importação de google.analytics.data_v1beta.types

Claro, também é possível adicionar valores específicos a determinadas variáveis ​​( name = 'eventCount' ). Por esse motivo, é essencial entender e mergulhar na documentação descrita anteriormente.

Além disso, atenção especial deve ser dada à variável os.environ [“GOOGLE_APPLICATION_CREDENTIALS”] , que conterá o caminho para o arquivo baixado anteriormente no passo 2. Esta linha de código evitará alguns problemas ao gerenciar as permissões para o API do Google.

Se o código foi executado corretamente, você verá um resultado semelhante a este: {Date, Events}, {20210418, 934}, {…}, ….

Dados de rastreamento³

Expanda sua análise com conexões perfeitas para conjuntos de dados adicionais. Analise sua estratégia de SEO com base em dados de backlinks, tráfego de SEO, classificações e conjuntos de dados personalizados de seu CRM, solução de monitoramento ou qualquer outra fonte.
Saber mais

Previsão de dados através do Facebook Prophet

Hoje em dia existem muitas opções gratuitas e existentes para realizar qualquer tipo de previsão com base no histórico de dados. Neste caso específico, escolhi a biblioteca do Profeta, mas o que é realmente?

É uma biblioteca de código aberto (disponível para R e Python) criada pela equipe de Data Science do Facebook para estimar o comportamento de um conjunto de dados de séries temporais com base em um modelo aditivo onde as tendências não lineares são ajustadas a uma sazonalidade diária, semanal e anual. em conta os efeitos dos dias de férias.
Voltando à implementação proposta (previsão de tráfego de busca orgânica), a primeira coisa a fazer é instalar as seguintes bibliotecas:

  • Pandas ( pip instala pandas ). Gerenciar e analisar estruturas de dados.
  • Plotly ( pip install plotly ). Criação de gráficos de todos os tipos.
  • Profeta ( conda install -c conda-forge fbprophet -y ).

Então, como sempre, você deve realizar as importações associadas a essas bibliotecas. Depois disso, a única coisa que resta a você fazer é realizar a modelagem da previsão e sua visualização correspondente. Para fazer isso, no caso do Profeta, você só deve seguir este processo:

  • Inicialize um novo objeto Profeta com os atributos desejados para gerar a previsão.
  • Solicite o método fit, passando os dados extraídos do GA4 como um dataframe. Essa solicitação pode levar vários segundos em alguns casos. O dataframe com os dados coletados deve ser composto apenas por duas colunas cujos nomes são sempre os mesmos: ds (campo tipo data) e y (métrica a estudar).
  • Crie um novo dataframe futuro definindo o número de períodos até os quais a previsão deve atingir a partir do intervalo de datas selecionado e a frequência com que os dados serão agregados (semanal, mensal etc.)
  • Solicite o método de previsão, que atribuirá a cada linha do novo dataframe futuro um valor previsto (yhat).
  • Solicite o método de plotagem para poder visualizar as previsões geradas.
  • Solicite o método plot_components que ajuda a entender visualmente a tendência e a sazonalidade dos dados.
 m = Profeta()
m.fit(df)
futuro = m.make_future_dataframe(períodos=365)
previsão = m.predict(futuro)
m.plot(previsão)
m.plot_components(previsão)
plt.show()

Embora a previsão desejada tenha sido gerada em apenas seis etapas e pareça relativamente simples, vários elementos devem ser considerados que serão fundamentais para gerar a previsão. Todos eles afetam a pertinência da previsão de uma forma ou de outra. No final, trata-se de gerar uma previsão que esteja de acordo com a lógica, no caso deste artigo, do nosso tráfego de busca orgânica. Para isso, é necessário entender algumas configurações mais avançadas do Profeta.

  • Dias e feriados especiais. Existe a possibilidade de adicionar dias especiais.
  • Atípicos. Eles devem ser eliminados se afetarem a estimativa.
  • Pontos de mudança. Detecção de mudanças de tendência ao longo do tempo analisado.
  • Diagnóstico. Validação baseada na medição do erro de previsão de acordo com o estudo histórico dos dados.
  • Aumentar. Seleção entre linear ou logística.
  • Sazonalidade. Escolha entre aditivo ou multiplicativo.

Tudo isso e muitas outras opções estão perfeitamente detalhadas nesta documentação da biblioteca do Profeta.

Criando o script completo para poder visualizar a previsão de tráfego

Tudo o que resta agora é juntar todas as peças do quebra-cabeça em um único roteiro. A maneira usual de resolver este tipo de quebra-cabeça é criar uma função para cada um dos processos detalhados anteriormente, de forma que possam ser executados de forma ordenada e limpa:

 def ga4(id_propriedade, data_inicial, data_final):
[…]

def forecasting(dim, met, per, freq):
[…]

if __name__ == "__main__":
dimensão, métrica = ga4(PROPERTY_ID, START_DATE, END_DATE)
previsão (dimensão, métrica, PERÍODOS, FREQ)

Antes de visualizar o resultado final da previsão, é uma boa ideia observar o tráfego de busca orgânica analisado.

À primeira vista, você pode ver como as diferentes estratégias e ações tomadas tiveram efeito ao longo do tempo. Ao contrário de outros canais (por exemplo, campanhas de Busca Paga), o tráfego gerado pela Busca Orgânica costuma ter poucas oscilações apreciáveis ​​(vales ou picos). Ele tende a crescer ou diminuir gradualmente ao longo do tempo e às vezes é influenciado por eventos sazonais. Normalmente, flutuações perceptíveis estão associadas a atualizações no algoritmo do mecanismo de pesquisa (Google, Bing, etc.).

A saída do script pode ser vista nas imagens a seguir, onde são detalhados fatores importantes como tendência, sazonalidade, previsão ou frequência de dados.
Se analisarmos a previsão obtida, pode-se concluir de forma genérica que “se continuarmos com a mesma estratégia de SEO implementada até à data, o tráfego dos motores de busca continuará a crescer gradualmente”. Podemos garantir que “os nossos esforços para melhorar o desempenho do site, gerar conteúdo de qualidade, fornecer links relevantes, etc. valeram a pena”.

Visualizando tendência, sazonalidade e previsão, tendência do tráfego de busca orgânica

Para finalizar, estarei compartilhando o código na íntegra para que você só tenha que copiá-lo e executá-lo em seu IDE (Integrated Development Environment) do Python. Escusado será dizer que todas as bibliotecas mencionadas acima devem ter sido instaladas para que isso funcione corretamente.

 importar pandas como pd
importar fbprophet
de fbprophet import Profeta
de fbprophet.plot importar add_changepoints_to_plot
importar matplotlib.pyplot como plt
importar SO

de google.analytics.data_v1beta importar BetaAnalyticsDataClient
de google.analytics.data_v1beta.types import DateRange
da dimensão de importação de google.analytics.data_v1beta.types
da métrica de importação de google.analytics.data_v1beta.types
do filtro de importação google.analytics.data_v1beta.types
de google.analytics.data_v1beta.types import FilterExpression
de google.analytics.data_v1beta.types import FilterExpressionList
de google.analytics.data_v1beta.types import RunReportRequest

PROPRIEDADE_
START_DATE = '2020-01-01'
END_DATE = '2021-03-31'
PERÍODOS = 4
FREQ = 'M'

os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "[Adicione aqui o caminho do arquivo json com as credenciais]"

def ga4(id_propriedade, data_inicial, data_final):
cliente = BetaAnalyticsDataClient()

request = RunReportRequest(property='properties/' + property_id,
dimensões=[Dimensão(nome='data')],
métricas=[Metric(name='eventCount')],
date_ranges=[DateRange(start_date=start_date,
end_date=end_date)],
dimension_filter=FilterExpression(
and_group=FilterExpressionList(expressions=[
FilterExpression(filter=Filter(field_name='sessionDefaultChannelGrouping',
string_filter=Filtro.StringFilter(
value='Pesquisa orgânica',
match_type=Filter.StringFilter.MatchType(
1)))),
FilterExpression(filter=Filter(field_name='eventName',
string_filter=Filtro.StringFilter(
value='session_start',
match_type=Filter.StringFilter.MatchType(
1))))
]))
)

resposta = client.run_report(solicitação)

x, y = ([] para i no intervalo(2))
para linha em response.rows:
x.append(row.dimension_values[0].value)
y.append(row.metric_values[0].value)
print(row.dimension_values[0].value, row.metric_values[0].value)

retorna x, y

def previsão(x, y, p, f):
print('Profeta %s' % fbprophet.__version__)

dados = {'ds': x, 'y': y}
df = pd.DataFrame(dados, colunas=['ds', 'y'])

m = Profeta(crescimento='linear',
changepoint_prior_scale=0,5,
sazonality_mode='aditivo',
daily_seasonality=Falso,
week_seasonality=Verdadeiro,
yearly_seasonality=Verdadeiro,
feriados=Nenhum,
)
m.fit(df)
futuro = m.make_future_dataframe(períodos=p, freq=f)
previsão = m.predict(futuro)

print(forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].head())

fig = m.plot(previsão, xlabel='Data', ylabel='Visitas')
add_changepoints_to_plot(fig.gca(), m, previsão)
m.plot_components(previsão)
plt.show()

if __name__ == "__main__":
channel_group, event_count = ga4(PROPERTY_ID, START_DATE, END_DATE)
previsão(channel_group, event_count, PERIODS, FREQ)

Espero que este artigo tenha servido de inspiração e que seja de grande utilidade para você em seus próximos projetos. Se você quiser continuar aprendendo sobre esse tipo de implementação ou saber mais sobre Marketing Digital mais técnico, entre em contato comigo. Você pode encontrar mais informações no meu perfil de autor abaixo.