Comment prédire le succès du contenu avec Python

Google nous dit depuis des années que 15% des recherches qu’ils voient chaque jour, ils ne les ont jamais vues auparavant.

S’il y a une chose que j’ai apprise au cours des 15 années de travail sur la recherche Google, c’est que la curiosité des gens est sans fin. Nous voyons des milliards de recherches chaque jour, et 15% de ces requêtes sont celles que nous n’avons jamais vues auparavant – nous avons donc créé des moyens de renvoyer des résultats pour les requêtes que nous ne pouvons pas anticiper.

Ils ont appris à renvoyer des résultats même lorsqu’ils ne peuvent pas prévoir ce que les gens rechercheraient.

Maintenant, imaginez la signification de cette opportunité.

Si personne ne sait ce que sont ces requêtes, elles ne sont probablement pas signalées dans les outils de recherche de mots-clés et ont probablement peu de contenu à affronter.

Pourrions-nous identifier de telles requêtes et rédiger du contenu pour les plus prometteuses?

Découvrons-le!

Voici notre plan technique. Nous allons:

• Récupérez un an de données de requête de recherche à partir de Google Search Console.
• Isolez les requêtes du dernier jour de données et filtrez celles précédemment inconnues.
• Essayez de faire correspondre sémantiquement nos requêtes inconnues avec les précédentes. Cela nous aidera à estimer leur potentiel de production de contenu à fort trafic.
• Effectuer des prévisions de trafic pour prioriser les idées les plus prometteuses.

Récupérer automatiquement les données de la console de recherche Google

Nous devons effectuer une configuration préliminaire pour accéder à Google Search Console à partir de Python.

Tout d’abord, nous devons télécharger un fichier client_id.json pour le référencer à partir de notre code Python:

1. Activer l’API Search Console dans Compute Engine

   https://console.cloud.google.com/apis/api/webmasters.googleapis.com/overview?project=&folder=&organizationId=

2. Créer de nouvelles informations d’identification / Aidez-moi à choisir (API de la Search Console, autre interface utilisateur, données utilisateur)

   https://console.cloud.google.com/apis/credentials/wizard?api=iamcredentials.googleapis.com&project=

3. Télécharger client_id.json

Installons cette bibliothèque qui simplifie considérablement l’accès à Google Search Console,

!pip install git+https://github.com/joshcarty/google-searchconsole

Si vous utilisez Google Colab, importez le fichier client_id.json.

#upload client_id.json

from google.colab import files

names = files.upload()

Vous pouvez obtenir le nom du fichier téléchargé avec cette ligne.

filename=list(names.keys())[0]

Maintenant, nous sommes prêts à nous authentifier avec la Search Console

import searchconsole

account = searchconsole.authenticate(client_config=filename, serialize="credentials.json", flow="console")

Vous devez cliquer sur le lien fourni, terminer les étapes d’authentification et recopier le code fourni.

Vous pouvez imprimer la liste des sites disponibles avec cela.

print(account.webproperties)

Sélectionnez l’une des propriétés du site Web en utilisant:

domain_name = "https://www.sitename.com/"

#Insert your domain name below.
webproperty = account[domain_name]

Cette fonction simple peut prendre une propriété Web et renvoyer une trame de données pandas avec une année complète de données de requête.

Vous pouvez modifier le nombre de jours à récupérer.

Voici le code pour récupérer les données et un exemple de la sortie.

df = get_search_console_data (propriété Web)

df.head ()

Isoler les requêtes inconnues à 15%

Lorsque nous avons récupéré notre ensemble de données de requête de la Search Console, nous nous sommes assurés d’extraire les dates, ce qui nous permettra d’effectuer facilement des analyses puissantes.

Mais d’abord, nous devons changer le type de données de la colonne de date.

Comme vous pouvez le voir ci-dessus, il n’a pas été automatiquement détecté en tant qu’objet datetime.

Le code suivant utilise la fonction pandas to_datetime pour résoudre ce problème.

df["date"] = pd.to_datetime(df.date)

Maintenant, nous pouvons affiner notre ensemble de données pour trouver que 15% des requêtes inconnues apparaissent chaque jour.

Google compare probablement les requêtes quotidiennes avec toutes les requêtes précédemment connues.

Compte tenu de notre ensemble de données limité, nous ne comparerons qu’avec les requêtes vues l’année dernière.

Voici notre processus pour le faire:

• Créer un bloc de données filtré avec juste le dernier jour de données collectées. La mise à jour de la Search Console prend quelques jours.
• Créez deux ensembles de requêtes uniques: un avec les requêtes du dernier jour et un autre avec les requêtes restantes de l’année dernière.
• Créer un nouvel ensemble de requêtes inconnues en calculant la différence entre les jeux de données précédents.

Le dernier jour de données de mon ensemble de données est le 7 novembre.

Je peux filtrer la trame de données en recherchant des dates supérieures au 6 novembre.

Super simple!

df[df["date"] > "2020-11-6"]

Cela renvoie 5 000 lignes de données de requête.

Je peux utiliser la même approche pour obtenir un autre ensemble de données avec le reste des requêtes.

rest_of_queries = df[df["date"] < "2020-11-6"]["query"]

Je reçois 180 000 requêtes dans mon ensemble de données.

Le calcul des requêtes inconnues est très simple à l'aide des ensembles Python.

fiften_percent = set(last_day_queries) - set(rest_of_queries)

Lorsque j'ai compté les mots clés, je n'ai trouvé que 212, ce qui représente moins de 4% des requêtes de la journée.

Ce n'était pas 15%, mais le nombre de requêtes est suffisant pour trouver de nouvelles idées de contenu.

Le site sur lequel j'ai effectué cette analyse est une grande organisation à but non lucratif, et il était intéressant d'examiner manuellement les requêtes inconnues.

Voici quelques-uns des modèles de requête que j'ai découverts.

• Requêtes liées à des noms commerciaux qui semblent avoir été récemment ouverts ou qui ont récemment retenu l'attention.
• Certains semblent être axés sur l'actualité.
• Nouvelles situations dans le monde.

Passons en revue trois exemples de requêtes.

Nouvelle situation dans le monde

Nouvelle entreprise?

Google n'a pas trouvé cette entreprise dans ma recherche, mais regardez comment Google a déterminé qu'il s'agissait d'une recherche locale.

Peut-être que l'entreprise se trouve dans une autre zone géographique.

Axé sur l'actualité

J'ai trouvé celui-ci particulièrement intéressant.

Vous pouvez voir dans les SERPs un reportage du 3 novembre mentionnant une baisse des dons en Colombie-Britannique.

Il est logique que les recherches augmentent pour en savoir plus.

Voyez-vous comment cette technique pourrait aider à découvrir de nouvelles opportunités de contenu?

Des trucs vraiment puissants!

Requêtes de correspondance sémantique

Nous avons donc un certain nombre de nouvelles requêtes et d'idées de contenu correspondantes.

Mais nous n'avons pas de performances historiques pour évaluer chaque opportunité.

Étant donné que ces requêtes ne sont potentiellement jamais vues auparavant, il est peu probable qu'elles apparaissent dans les outils de mots clés.

Comment savoir lesquels prioriser?

Voici une technique intelligente que nous pouvons essayer.

Nous allons emprunter une idée de ce post d'analyse de brevet de sensei Bill Slawski.

Les brevets dont il parle parlent requêtes canoniques.

Les requêtes canoniques impliquent qu'il existe des manières dupliquées d'écrire la même recherche.

Alors que les brevets se concentrent sur la duplication syntaxique, nous pouvons élargir le concept et envisager également la duplication sémantique.

Requêtes qui ont la même signification, mais qui sont exprimées en utilisant des mots différents.

Bill a couvert un autre brevet qui adopte cette approche.

Mais, comment pourrions-nous vérifier cela?

En utilisant l'apprentissage automatique, bien sûr!

La similitude textuelle sémantique est un concept avancé, mais j'aime la simple visualisation et l'explication de cet article.

Il montre qu'une approche pour trouver des requêtes / questions similaires consiste à les faire correspondre par leurs réponses.

Si la réponse est toujours la même, il est probable que nous posions des questions équivalentes!

Maintenant, traduisons cette idée en code Python.

Tout d'abord, installons cette bibliothèque pratique.

!pip install sentence-transformers

Nous pouvons créer un modèle avec quelques lignes de code.

from sentence_transformers import SentenceTransformer, util

model = SentenceTransformer('distilbert-base-nli-stsb-mean-tokens')

Une fois que nous avons un modèle, nous trouverons des requêtes sémantiquement similaires en suivant le processus suivant:

• Transformez les requêtes / phrases en incorporations (nombres qui simplifient les calculs de proximité)
• Calculez les scores de proximité entre les paires de requêtes.
• Filtrez les correspondances les plus proches en fonction d'un seuil de coupure que nous pouvons déterminer empiriquement.

Dans la capture d'écran ci-dessus, vous pouvez voir à quel point cette technique de correspondance est puissante.

«Le nouveau film est génial» et «le nouveau film est tellement génial» sont des correspondances parfaites à 0,98.

Le score le plus élevé est de 1.

Voici le code pour faire cela avec nos requêtes.

Tout d'abord, nous créons les plongements.

fifteen_percent_list = list(fifteen_percent)

#Compute embedding for both lists

embeddings1 = model.encode(fifteen_percent_list, convert_to_tensor=True)

# try on a smaller set of 10k, as it takes too long to run on full set of queries

rest_of_queries_list = list(set(rest_of_queries))[:10000]
embeddings2 = model.encode( rest_of_queries_list, convert_to_tensor=True)
Ensuite, nous voulons trouver des requêtes sémantiquement similaires dans la liste historique qui correspondent étroitement aux nouvelles requêtes inconnues.
#Compute cosine similarities

cosine_scores = util.pytorch_cos_sim(embeddings1, embeddings2)
Enfin, voici le code pour filtrer les requêtes similaires.
#Output the pairs with their score

for i in range(len(fifteen_percent_list)):

  score = cosine_scores[i][i]

  if score > 0.7:

    print(f"{i}. {fifteen_percent_list[i]} <> {rest_of_queries_list[i]} nScore: {score:.4f}")
Je n'ai pu vérifier que 10 000 requêtes et il n'y avait aucune correspondance au-dessus de 0,5.
J'essaierai plus tard avec l'ensemble de données complet et rapporterai le résultat sur Twitter.
N'hésitez pas à signaler ce que vous obtenez dans vos expériences.
Prioriser les idées les plus prometteuses
Lorsque j'ai inspecté visuellement les requêtes inconnues, j'ai trouvé quelques modèles intéressants qui méritent d'être approfondis.
L'un des environ idées de collecte de fonds et un autre sur [no-profit]  proche de moi.
Utilisons une approche basée sur les données pour évaluer l'impact potentiel de chacun avec visualisation et prévision.
Tout d'abord, je vais créer deux cadres de données filtrés où la requête contient le mot-clé pattern.
ideas_df = df[df['query'].str.contains("idea")]
near_me_df = df[df['query'].str.contains("near me")]
Nous allons définir la colonne de date comme index de la trame de données.

Publicité
Continuer la lecture ci-dessous

Cela nous permettra d'effectuer des regroupements avancés par jours ou par mois.
ideas_df = ideas_df.set_index("date")
near_me_df = near_me_df.set_index("date")


Vous pouvez voir que la date n'est plus incluse dans la liste des colonnes.
Regroupons les deux ensembles de données par mois et visualisons-les.
Voici le code de l'ensemble de données «idées».
grouped_ideas_df = ideas_df.groupby(pd.Grouper(freq='M')).sum()[["clicks", "impressions"]]
J'ai mis en évidence en caractères gras une classe de pandas puissante, le mérou, qui permet un regroupement avancé par dates.
M représente la fréquence de fin de mois.

Publicité
Continuer la lecture ci-dessous

Nous utilisons également ré, qui correspond à la fréquence des jours civils.
Vous pouvez trouver la liste complète des alias de fréquence des séries chronologiques ici.

Maintenant, traçons les ensembles de données pour voir leurs performances historiques.

Nous allons utiliser la bibliothèque de traçage pour ce faire.
import plotly.express as px



fig = px.line(grouped_ideas_df, y="clicks", title="Clicks over Time for Ideas")
fig.show()

Ceci est l'intrigue pour les requêtes à proximité.


Ces visualisations montrent clairement une augmentation de la demande pour les deux opportunités, mais nous pouvons faire mieux et essayer de prévoir pour voir quel pourrait être l'impact futur.

Les points de données mensuels sont trop peu nombreux pour créer des modèles prédictifs.

Publicité
Continuer la lecture ci-dessous

Augmentons la fréquence en jours.
Voici à quoi ressemblent les graphiques avec les données quotidiennes.


Une fois que nous avons regroupé les ensembles de données par jour, nous pouvons utiliser la bibliothèque Facebook Prophet pour prévoir les clics plusieurs jours dans le futur.

Nous allons utiliser le code d'un récent Twittorial Python de mon équipe.

Nous sommes de retour avec un autre #RSTwittorial Jeudi!    Aujourd'hui, nous apprenons à prédire les clics en utilisant @Googlede #SearchConsole Données  
Voici la sortie ⬇️ pic.twitter.com/KodfdEWB2e
- RankSense (@RankSense) 22 octobre 2020


Publicité
Continuer la lecture ci-dessous

Nous avons juste besoin de renommer les colonnes pour correspondre à ce qui est attendu par la bibliothèque.
dft = grouped_ideas_df.reset_index().rename(columns={"date":"ds", "clicks":"y"})
Nous pouvons entraîner le modèle prédictif avec deux lignes.
m = Prophet()

m.fit(dft)
Une fois que le modèle est formé, nous pouvons prédire les 30 prochains jours avec cela.
#Predicting clicks for the next 30 days.

future_30 = m.make_future_dataframe(periods=30)

forecast_30 = m.predict(future_30)
Enfin, nous pouvons visualiser nos prévisions pour l'ensemble de données des idées de collecte de fonds.
#Visualizing the prediction for next 30 days.

plot_plotly(m, forecast_30, xlabel="Date", ylabel="Clicks")


Les points noirs représentent les points de données réels.
La ligne bleu foncé est le point central des prévisions et la bande bleu clair est l'incertitude.

Publicité
Continuer la lecture ci-dessous

Vous pouvez voir que le modèle essaie d'ajuster autant de points que possible dans le modèle, mais il ne parvient pas à s'adapter à la grande valeur aberrante vers mai.
Cette année, beaucoup de choses ont été imprévisibles, donc pas de surprise ici.
En pratique, les prédictions s'améliorent considérablement lorsque vous disposez d'un ensemble de données d'au moins quelques années.
La dernière étape consiste à prévoir le trafic de plusieurs idées candidates, à le résumer et à classer les idées en fonction du meilleur potentiel de trafic.
Ressources pour en savoir plus
La meilleure façon d'apprendre est de faire.  Vous trouvez un bloc-notes Google Colab avec toutes les étapes que j'ai couvertes ici.
Je vous encourage à l'essayer et à rapporter ce que vous apprenez avec moi sur Twitter