Prévision du trafic SEO avec Prophet et Python

Publié: 2021-03-16

Fixer des objectifs et évaluer les réalisations dans le temps est un exercice très intéressant pour comprendre ce que nous sommes capables de réaliser et si la stratégie que nous utilisons est efficace ou non. Cependant, il n'est généralement pas si facile de fixer ces objectifs car nous devrons d'abord établir une prévision.

Créer une prévision n'est pas une chose facile, mais grâce à certaines procédures de prévision disponibles, à notre processeur et à certaines compétences en programmation, nous pouvons réduire considérablement sa complexité. Dans cet article, je vais vous montrer comment nous pouvons faire des prédictions précises et comment vous pouvez appliquer cela au SEO en utilisant Python et la bibliothèque Prophet et sans avoir à avoir des superpouvoirs de diseuse de bonne aventure.

Si vous n'avez jamais entendu parler du Prophète, vous vous demandez peut-être ce que c'est. En bref, Prophet est une procédure de prévision qui a été publiée par l'équipe Core Data Science de Facebook qui est disponible en Python et R et qui traite très bien les valeurs aberrantes et les effets saisonniers pour
fournir des prévisions précises et rapides.

Lorsque nous parlons de prévision, nous devons prendre en considération deux choses :

  1. Plus nous aurons de données historiques, plus notre modèle et donc nos prédictions seront précis.
  2. Le modèle prédictif ne sera valide que si les facteurs internes restent les mêmes et qu'aucun facteur externe ne l'affecte. Cela signifie que si, par exemple, nous avons publié un article par semaine et que nous commençons à publier deux articles par semaine, ce modèle pourrait ne pas être valide pour prédire quel sera le résultat de ce changement de stratégie. D'un autre côté, s'il y a une mise à jour de l'algorithme, le modèle peut ne pas être valide non plus. Gardez à l'esprit que le modèle est construit sur la base de données historiques.

Pour appliquer cela au référencement, nous allons prédire les sessions de référencement pour le mois à venir en suivant les étapes suivantes :

  1. Obtenir des données de Google Analytics sur les sessions organiques pour une période de temps spécifique.
  2. Formation de notre modèle.
  3. Prévision du trafic SEO pour le mois à venir.
  4. Évaluer la qualité de notre modèle avec l'erreur absolue moyenne.

Vous souhaitez en savoir plus sur le fonctionnement de cette procédure de prévision ? Commençons alors !

Obtenir les données de Google Analytics

On peut aborder l'extraction des données de Google Analytics de deux manières : en exportant un fichier Excel depuis l'interface normale ou en utilisant l'API pour récupérer ces données.

Importation des données depuis un fichier Excel

Le moyen le plus simple d'obtenir ces données de Google Analytics est d'aller dans la section Canaux de la barre latérale, de cliquer sur Organique et d'exporter les données avec le bouton qui se trouve en haut de la page. Assurez-vous de sélectionner dans le menu déroulant en haut du graphique la variable que vous souhaitez analyser, dans ce cas Sessions.

Après avoir exporté les données sous forme de fichier Excel, nous pouvons les importer dans notre cahier avec Pandas. Notez que le fichier Excel avec ces données contiendra différents onglets, donc l'onglet avec le trafic mensuel doit être spécifié comme argument dans le morceau de code ci-dessous. Nous effaçons également la dernière ligne car elle contient le nombre total de sessions, ce qui fausserait notre modèle.

 importer des pandas en tant que pd

df = pd.read_excel ('.xlsx', nom_feuille = "")
df = df.drop(len(df) - 1)

Nous pouvons dessiner avec Matplotlib à quoi ressemblent les données :

de matplotlib importer pyplot

df["Sessions"].plot(title = "Sessions")
pyplot.show()

Utilisation de l'API Google Analytics

Tout d'abord, pour utiliser l'API Google Analytics, nous devons créer un projet sur la console développeur de Google, activer le service de rapport Google Analytics et obtenir les informations d'identification. Jean-Christophe Chouinard explique très bien dans cet article comment mettre cela en place.

Une fois les informations d'identification obtenues, nous devons nous authentifier avant de faire notre demande. L'authentification doit être effectuée avec le fichier d'informations d'identification obtenu initialement à partir de la console de développement de Google. Nous devrons également noter dans notre code l'ID de vue GA de la propriété que nous souhaitons utiliser.

 à partir de la construction d'importation apiclient.discovery
depuis oauth2client.service_account importer ServiceAccountCredentials

CHAMPS D'APPLICATION = ['https://www.googleapis.com/auth/analytics.readonly']
KEY_FILE_LOCATION = ''
VOIR_

informations d'identification = ServiceAccountCredentials.from_json_keyfile_name(KEY_FILE_LOCATION, SCOPES)
analytics = build('analyticsreporting', 'v4', identifiants=identifiants)

Après authentification, il suffit de faire la demande. Celui que nous devons utiliser pour obtenir les données sur les sessions organiques pour chaque jour est :

 réponse = analytics.reports().batchGet(body={
  'reportRequests' : [{
  'ID de vue' : VIEW_ID,
  'dateRanges' : [{'startDate' : '2020-09-01', 'endDate' : '2021-01-31'}],
  'métrique' : [
    {"expression": "ga:sessions"}
  ], "cotes": [
    {"name": "ga:date"}
  ],
"filtersExpression":"ga:channelGrouping=~Organic",
"includeEmptyRows": "vrai"
}]}).exécuter()

Notez que nous sélectionnons la plage de temps dans dateRanges. Dans mon cas, je vais récupérer les données du 1er septembre au 31 janvier : [{'startDate' : '2020-09-01', 'endDate' : '2021-01-31'}]

Après cela, nous n'avons qu'à récupérer le fichier de réponse pour ajouter à une liste les jours avec leurs sessions organiques :

 list_values ​​= []
pour x en réponse["rapports"][0]["données"]["lignes"] :
list_values.append([x["dimensions"][0],x["métriques"][0]["valeurs"][0]])

Comme vous pouvez le constater, l'utilisation de l'API Google Analytics est assez simple et peut être utilisée pour de nombreux objectifs. Dans cet article, j'ai expliqué comment vous pouvez utiliser l'API Google Analytics pour créer des alertes afin de détecter les pages sous-performantes.

Adaptation des listes aux Dataframes

Pour utiliser Prophet, nous devons entrer un Dataframe avec deux colonnes qui doivent être nommées : "ds" et "y". Si vous avez importé les données d'un fichier Excel, nous les avons déjà sous forme de Dataframe, vous n'aurez donc qu'à nommer les colonnes "ds" et "y":

 df.columns = ['ds', 'y']

Si vous avez utilisé l'API pour récupérer les données, nous devons transformer la liste en dataframe et nommer les colonnes comme requis :

 de pandas importer DataFrame
df_sessions = DataFrame(list_values,columns=['ds','y'])

Former le modèle

Une fois que nous avons la Dataframe au format requis, nous pouvons déterminer et former notre modèle très facilement avec :

 importer fbprophète
depuis fbprophet import Prophet

modèle = Prophète()
model.fit(df_sessions)

Faire nos pronostics

Enfin, après avoir formé notre modèle, nous pouvons commencer à prévoir ! Afin de procéder aux prédictions, nous devrons d'abord créer une liste avec la plage de temps que nous aimerions prédire et ajuster le format datetime :

 de l'importation de pandas à_datetime

prévisions_jours = []
pour x dans la plage (1, 28):
date = "2021-02-" + str(x)
prévisions_jours.append([date])
Forecast_days = DataFrame (forecast_days)
Forecast_days.columns = ['ds']
forecast_days['ds']= to_datetime(forecast_days['ds'])

Dans cet exemple, j'utilise une boucle qui créera une trame de données qui contiendra tous les jours de février. Et maintenant, il suffit d'utiliser le modèle qui a été formé précédemment :

 prévision = model.predict(forecast_days)

Nous pouvons dessiner un graphique mettant en évidence la période de temps prévue :

 de matplotlib importer pyplot
model.plot (prévision)
pyplot.show()

Évaluation du modèle

Enfin, nous pouvons évaluer la précision de notre modèle en éliminant certains jours des données utilisées pour former le modèle, en prévoyant les sessions pour ces jours et en calculant l'erreur absolue moyenne.

À titre d'exemple, ce que je vais faire est d'éliminer de la base de données d'origine les 12 derniers jours à partir de janvier, en prévoyant les sessions pour chaque jour et en comparant le trafic réel avec celui prévu.

Tout d'abord, nous éliminons du dataframe d'origine les 12 derniers jours avec pop et nous créons un nouveau dataframe qui n'inclura que les 12 jours qui seront utilisés pour la prévision :

 train = df_sessions.drop(df_sessions.index[-12:])
futur = df_sessions.loc[df_sessions["ds"]> train.iloc[len(train)-1]["ds"]]["ds"]

Maintenant, nous formons le modèle, faisons la prévision et nous calculons l'erreur absolue moyenne. À la fin, nous pouvons dessiner un graphique qui montrera la différence entre les valeurs réelles prévues et les valeurs réelles. C'est quelque chose que j'ai appris de cet article écrit par Jason Brownlee.

 à partir de sklearn.metrics importer mean_absolute_error
importer numpy en tant que np
à partir du tableau d'importation numpy

#Nous formons le modèle
modèle = Prophète()
model.fit(train)

#Adaptez la trame de données utilisée pour les jours de prévision au format requis par Prophet.
futur = liste (futur)
futur = DataFrame (futur)
future = future.rename(columns={0: 'ds'})

# Nous faisons la prévision
prévision = model.predict(futur)

# Nous calculons le MAE entre les valeurs réelles et les valeurs prédites
y_true = df_sessions['y'][-12 :].values
y_pred = prévision['yhat'].values
mae = moyenne_absolute_error(y_true, y_pred)

# Nous traçons la sortie finale pour une compréhension visuelle
y_true = np.stack(y_true).astype(float)
pyplot.plot(y_true, label='Actual')
pyplot.plot(y_pred, label='Prédit')
pyplot.legend()
pyplot.show()
imprimer (mae)

Mon erreur absolue moyenne est de 13, ce qui signifie que mon modèle de prévision attribue à chaque jour 13 sessions de plus que les vraies, ce qui semble être une erreur acceptable.

C'est tout ! J'espère que vous avez trouvé cet article intéressant et que vous pourrez commencer à faire vos prédictions SEO afin de vous fixer des objectifs.

Pour aller plus loin : OnCrawl Labs

Si vous avez aimé prévoir votre trafic avec cette méthode, vous serez également intéressé par OnCrawl Labs, le laboratoire de science des données et de machine learning d'OnCrawl qui propose des projets pré-codés pour vos workflows SEO.

En prévision SEO, OnCrawl Labs vous aide à affiner vos projections SEO :

  • Mieux comprendre les théories et le processus derrière l'algorithme Facebook Prophet
  • Analysez un segment de trafic, comme le trafic sur les mots-clés de longue traîne uniquement, ou les mots-clés de marque uniquement…
  • Suivez un processus étape par étape pour mettre en place des événements historiques, en ajustant leur influence et leur probabilité de se reproduire.
Découvrez les laboratoires OnCrawl