Extraire les données de l'API Google Search Console pour l'analyse des données en Python
Publié: 2022-03-01Google Search Console (GSC) est certainement l'un des outils les plus utiles pour les spécialistes du référencement, car il vous permet d'obtenir des informations sur la couverture de l'index et en particulier sur les requêtes pour lesquelles vous êtes actuellement classé. Sachant cela, beaucoup de gens analysent les données GSC à l'aide de feuilles de calcul et c'est bien, tant que vous comprenez qu'il y a beaucoup plus de place à l'amélioration avec des outils tels que les langages de programmation.
Malheureusement, l'interface GSC est assez limitée à la fois en termes de lignes affichées (seulement 5000) et de période de temps disponible, seulement 16 mois. Il est clair que cela peut limiter considérablement votre capacité à obtenir des informations et que cela ne convient pas aux sites Web plus volumineux.
Python vous permet d'obtenir facilement des données GSC et d'automatiser des calculs plus complexes qui demanderaient beaucoup plus d'efforts dans un tableur traditionnel.
C'est la solution à l'un des plus gros problèmes d'Excel, à savoir la limite et la vitesse des lignes. De nos jours, vous avez beaucoup plus d'alternatives pour analyser les données qu'auparavant et c'est là que Python entre en jeu.
Vous n'avez pas besoin de connaissances avancées en codage pour suivre ce didacticiel, juste la compréhension de certains concepts de base et une certaine pratique avec Google Colab.
Premiers pas avec l'API Google Search Console
Avant de commencer, il est important de configurer l'API Google Search Console. Le processus est assez simple, tout ce dont vous avez besoin est un compte Google. Les étapes sont les suivantes:
- Créez un projet sur Google Cloud Platform. Vous devriez avoir un compte Google et je suis sûr que vous en avez un. Accédez à la console, puis vous devriez trouver une option en haut pour créer un nouveau projet.
- Cliquez sur le menu de gauche et sélectionnez « API et services », vous arriverez sur un autre écran.
- Dans la barre de recherche en haut, recherchez "API Google Search Console" et activez-la.
- Passez ensuite à l'onglet "Identifiants", vous avez besoin d'une sorte d'autorisation pour utiliser l'API.
- Configurez l'écran "consentement", car il est obligatoire. Peu importe pour l'utilisation que nous allons en faire qu'elle soit publique ou non.
- Vous pouvez choisir "Application de bureau" pour le type d'application
- Nous utiliserons OAuth 2.0 pour ce tutoriel, vous devez télécharger un fichier json et maintenant vous avez terminé.
C'est en fait la partie la plus difficile pour la plupart des gens, en particulier ceux qui ne sont pas habitués aux API Google. Ne vous inquiétez pas, les prochaines étapes seront beaucoup plus faciles et moins problématiques.
Obtenir des données de l'API Google Search Console avec Python
Ma recommandation est que vous utilisiez un bloc-notes comme Jupyter Notebook ou Google Colab. Ce dernier est préférable car vous n'avez pas à vous soucier des exigences. Par conséquent, ce que je vais expliquer est basé sur Google Colab.
Avant de commencer, mettez à jour votre fichier JSON vers Google Colab avec le code suivant :
à partir de fichiers d'importation google.colab fichiers.upload()
Ensuite, installons toutes les bibliothèques dont nous aurons besoin pour notre analyse et améliorons la visualisation des tableaux avec cet extrait de code :
%%Capturer #charger ce qui est nécessaire !pip install git+https://github.com/joshcarty/google-searchconsole importer des pandas en tant que pd importer numpy en tant que np importer matplotlib.pyplot en tant que plt depuis google.colab importer data_table !git clone https://github.com/jroakes/querycat.git !pip install -r querycat/requirements_colab.txt !pip installer umap-learn data_table.enable_dataframe_formatter() #pour une meilleure visualisation du tableau
Enfin, vous pouvez charger la bibliothèque searchconsole, qui offre le moyen le plus simple de le faire sans compter sur de longues fonctions. Exécutez le code suivant avec les arguments que j'utilise et assurez-vous que client_config porte le même nom que le fichier json téléchargé.
importer la console de recherche compte = searchconsole.authenticate(client_config='client_secret_.json',serialize='credentials.json', flow='console')
Vous serez redirigé vers une page Google pour autoriser l'application, sélectionnez votre compte Google, puis copiez et collez le code que vous obtiendrez dans la barre Google Colab.
Nous n'avons pas encore terminé, vous devez sélectionner la propriété pour laquelle vous allez avoir besoin de données. Vous pouvez facilement vérifier vos propriétés via account.webproperties pour voir ce que vous devez choisir.
property_name = input('Insérez le nom de votre site Web tel qu'il figure dans GSC : ')
propriétéweb=compte[str(nom_propriété)]
Une fois que vous avez terminé, vous allez exécuter une fonction personnalisée pour créer un objet contenant nos données.
def extract_gsc_data(webproperty, start, stop, *args):
si la propriété Web n'est pas None :
print(f'Extraction des données pour {webproperty}')
gsc_data = webproperty.query.range(start, stop).dimension(*args).get()
retourner gsc_data
autre:
print('Propriété Web introuvable, veuillez sélectionner la bonne')
retour Aucun
L'idée de la fonction est de prendre la propriété que vous avez définie auparavant et une période, sous la forme de dates de début et de fin, ainsi que des dimensions.
Le choix de pouvoir sélectionner des dimensions est crucial pour les spécialistes SEO car cela permet de comprendre si vous avez besoin d'un certain niveau de granularité. Par exemple, il se peut que vous ne souhaitiez pas obtenir la dimension de date, dans certains cas.
Ma suggestion est de toujours choisir la requête et la page, car l'interface de la console de recherche Google peut les exporter séparément et il est très ennuyeux de les fusionner à chaque fois. C'est un autre avantage de l'API Search Console.
Dans notre cas, nous pouvons également obtenir directement la dimension de date, pour montrer des scénarios intéressants où vous devez prendre en compte le temps.
ex = extract_gsc_data(webproperty, '2021-09-01', '2021-12-31', 'query', 'page', 'date')
Sélectionnez un délai approprié, étant donné que pour les grandes propriétés, vous devrez attendre beaucoup de temps. Pour cet exemple, j'envisage simplement une période de 3 mois, ce qui est suffisant pour obtenir des informations précieuses sur la plupart des ensembles de données, en moyenne.
Vous pouvez même sélectionner une semaine si vous traitez une énorme quantité de données, ce qui nous intéresse, c'est le processus.
Ce que je vais vous montrer ici est soit basé sur des données synthétiques, soit sur des données réelles modifiées pour pouvoir servir d'exemples. Par conséquent, ce que vous voyez ici est totalement réaliste et peut refléter des scénarios du monde réel.
Nettoyage des données
Pour ceux qui ne le savent pas, nous ne pouvons pas utiliser nos données telles quelles, il y a quelques étapes supplémentaires pour s'assurer que nous travaillons correctement. Tout d'abord, nous devons convertir notre objet en une dataframe Pandas, une structure de données que vous devez connaître car c'est la base de l'analyse de données en Python.
df = pd.DataFrame(data=ex) df.head()
La méthode head peut afficher les 5 premières lignes de votre jeu de données, c'est très pratique pour avoir un aperçu de ce à quoi ressemblent vos données. Nous pouvons compter le nombre de pages que nous avons en utilisant une fonction simple.
Un bon moyen de supprimer les doublons consiste à convertir un objet en ensemble, car les ensembles ne peuvent pas contenir d'éléments en double.
Certains des extraits de code ont été inspirés du cahier de Hamlet Batista et un autre de Masaki Okazawa.
Suppression des termes de marque
La toute première chose à faire est de supprimer les mots clés de marque, nous recherchons les requêtes ne contenant pas nos termes de marque. C'est assez simple à faire avec une fonction personnalisée et vous aurez généralement un ensemble de termes de marque.
À des fins de démonstration, vous n'avez pas besoin de tous les filtrer, mais faites-le pour de vraies analyses. C'est l'une des étapes les plus importantes du nettoyage des données dans le référencement, sinon vous risquez de présenter des résultats trompeurs.
nom_domaine = str(input('Insérer les termes de la marque séparés par une virgule : ')).replace(',', '|')
importer re
nom_domaine = re.sub(r"\s+", "", nom_domaine)
print('Supprimer tous les espaces à l'aide de RegEx :\n')
df['Marque/Non-marque'] = np.where(
df['query'].str.contains(domain_name), 'Brand', 'Non-branded'
)
Nous allons ajouter une nouvelle colonne à notre ensemble de données pour reconnaître la différence entre les deux classes. Nous pouvons visualiser via des tables ou des barplots combien ils représentent le nombre total de requêtes.
Je ne vous montrerai pas le barplot car il est très simple et je pense qu'un tableau est préférable dans ce cas.
brand_count_df = df['Brand/Non-branded'].value_counts().rename_axis('cats').to_frame('counts')
brand_count_df['Pourcentage'] = brand_count_df['counts']/sum(brand_count_df['counts'])
pd.options.display.float_format = '{:.2%}'.format
brand_count_df
Vous pouvez rapidement voir quel est le rapport entre les mots clés de marque et les mots clés sans marque pour avoir une idée de la quantité que vous allez supprimer de votre ensemble de données. Il n'y a pas de ratio idéal ici, bien que vous souhaitiez certainement avoir un pourcentage plus élevé de mots clés sans marque.
Ensuite, nous pouvons simplement supprimer toutes les lignes marquées comme marquées et procéder à d'autres étapes.
#sélectionner uniquement des mots clés sans marque df = df.loc[df['Marque/Sans marque'] == 'Sans marque']
Remplir les valeurs manquantes et autres étapes
Si votre jeu de données comporte des valeurs manquantes (ou NA dans le jargon), vous avez plusieurs options. Les plus courantes consistent soit à les supprimer tous, soit à les remplir avec une valeur d'espace réservé comme 0 ou la moyenne de cette colonne.
Il n'y a pas de bonne réponse et les deux approches ont leurs avantages et leurs inconvénients, ainsi que des risques. Pour les données de Google Search Console, mon meilleur conseil est de mettre une valeur d'espace réservé comme 0, pour sous-estimer l'effet de certaines métriques.
df.fillna(0, en place = Vrai)
Avant de passer à l'analyse des données proprement dites, nous devons ajuster nos fonctionnalités, à savoir les colonnes de notre ensemble de données. La position est particulièrement intéressante, car nous voulons l'utiliser pour des tableaux croisés dynamiques sympas.
Nous pouvons arrondir la position à un nombre entier, ce qui sert notre objectif.
df['position'] = df['position'].round(0).astype('int64')
Vous devez suivre toutes les autres étapes de nettoyage décrites ci-dessus, puis ajuster la colonne de date.
Nous extrayons des mois et des années avec l'aide de pandas. Vous n'avez pas besoin d'être aussi précis si vous travaillez avec une période plus courte, c'est un exemple qui prend en compte six mois.
#convertir la date au format approprié df['date'] = pd.to_datetime(df['date']) #extraire les mois df['mois'] = df['date'].dt.mois #extraire des années df['année'] = df['date'].dt.année
[Ebook] Data SEO : la prochaine grande aventure
Lire l'ebookL'analyse exploratoire des données
Le principal avantage de Python est que vous pouvez faire les mêmes choses que vous faites dans Excel mais avec beaucoup plus d'options et plus facilement. Commençons par quelque chose que tout analyste connaît très bien : les tableaux croisés dynamiques.
Analyse du CTR moyen par groupe de positions
Analyse Moy. Le CTR par groupe de positions est l'une des activités les plus perspicaces car il vous permet de comprendre la situation générale d'un site Web. Appliquez le pivot, puis traçons-le.
pd.options.display.float_format = '{:.2%}'.format
query_analysis = df.pivot_table(index=['position'], values=['ctr'], aggfunc=['mean'])
query_analysis.sort_values(by=['position'], ascending=True).head(10)
hache = query_analysis.head(10).plot(kind='bar')
ax.set_xlabel('Position moyenne')
ax.set_ylabel('CTR')
ax.set_title('CTR par position moyenne')
ax.grid('on')
ax.get_legend().remove()
plt.xticks(rotation=0)
Figure 1 : Représentation du CTR par position pour repérer les anomalies.
Le scénario idéal ici est d'avoir un meilleur CTR sur le côté gauche du graphique, car normalement les résultats en position 1 devraient présenter un CTR beaucoup plus élevé. Attention cependant, vous pouvez voir des cas où les 3 premiers spots ont un CTR plus bas que prévu, et vous devez enquêter.
S'il vous plaît, considérez également les cas extrêmes, par exemple ceux où la position 11 est meilleure que la première. Comme expliqué dans la documentation de Google pour la Search Console, cette métrique ne suit pas l'ordre auquel vous pourriez penser au premier abord.
De plus, il ajoute que cette métrique est une moyenne, car la position du lien change à chaque fois et il est impossible d'avoir une précision de 100 %.
Parfois, vos pages sont bien classées mais ne sont pas assez convaincantes, vous pouvez donc essayer de corriger le titre. Comme il s'agit d'un aperçu de haut niveau, vous n'allez pas voir de différences granulaires, alors attendez-vous à agir rapidement si ce problème est à grande échelle.
Soyez également conscient lorsqu'un groupe de pages dans des positions inférieures a un CTR moyen plus élevé que celles situées à de meilleurs endroits.
Pour cette raison, vous voudrez peut-être étendre votre analyse jusqu'à la position 15 ou plus, pour repérer des modèles étranges.
Nombre de requêtes par position et mesure des efforts de référencement
Une augmentation des requêtes pour lesquelles vous vous classez est toujours un bon signal, mais cela ne signifie pas nécessairement de meilleurs classements à l'avenir. Le nombre de requêtes est le processus de comptage du nombre de requêtes pour lesquelles vous vous classez et est l'une des tâches les plus importantes que vous pouvez effectuer avec les données GSC.
Les tableaux croisés dynamiques sont une fois de plus d'une grande aide et nous pouvons tracer les résultats.
ranking_queries = df.pivot_table(index=['position'], values=['query'], aggfunc=['count']) classement_queries.sort_values(by=['position']).head(10)
Ce que vous voulez en tant que spécialiste du référencement, c'est avoir un nombre de requêtes plus élevé sur le côté le plus à gauche, les premières places. La raison est assez naturelle, les positions élevées obtiennent en moyenne un meilleur CTR, ce qui peut se traduire par plus de personnes cliquant sur votre page.
hache = classement_queries.head(10).plot(kind='bar')
ax.set_ylabel('Nombre de requêtes')
ax.set_xlabel('Position')
ax.set_title('Répartition du classement')
ax.grid('on')
ax.get_legend().remove()
Figure 2 : Combien de requêtes ai-je par poste ?
Ce qui vous intéresse, c'est d'augmenter le nombre de requêtes dans les premières positions au fil du temps.
Jouer avec la dimension date
Voyons comment les clics varient dans un intervalle de temps considéré, obtenons d'abord la somme des clics :
clicks_sum = df.groupby('date')['clicks'].sum()
Nous regroupons les données par dimension de date et obtenons la somme des clics pour chacun d'eux, c'est un type de résumé.
Nous sommes maintenant prêts à tracer ce que nous avons obtenu, le code va être assez long juste pour améliorer la visualisation, ne soyez pas effrayé par cela.
# Somme des clics sur la période
%config InlineBackend.figure_format = 'rétine'
à partir de la figure d'importation matplotlib.pyplot
figure(figsize=(8, 6), dpi=80)
ax = clicks_sum.plot(color='red')
ax.grid('on')
ax.set_ylabel('Somme des clics')
ax.set_xlabel('Mois')
ax.set_title('Comment les clics ont varié sur une base mensuelle')
xlab = ax.xaxis.get_label()
ylab = ax.yaxis.get_label()
xlab.set_style('italique')
xlab.set_size(10)
ylab.set_style('italique')
ylab.set_size(10)
ttl = ax.titre
ttl.set_weight('gras')
ax.spines['right'].set_color((.8,.8,.8))
ax.spines['top'].set_color((.8,.8,.8))
ax.yaxis.set_label_coords(-.15, .50)
ax.fill_between(clicks_sum.index, clicks_sum.values, facecolor='yellow')
Figure 3 : Tracé de la somme des clics par rapport à la variable du mois
Ceci est un exemple commençant à partir de juin 2021 et allant directement à la mi-janvier 2022. Toutes les lignes que vous voyez ci-dessus ont pour rôle de rendre cette visualisation plus jolie, vous pouvez essayer de jouer avec pour voir ce qui se passe.
Nombre de requêtes par position, instantané mensuel
Une autre visualisation intéressante que nous pouvons tracer en Python est la heatmap, qui est encore plus visuelle qu'un simple barplot. Je vais vous montrer comment afficher le nombre de requêtes dans le temps et selon sa position.
importer seaborn en tant que sns sns.set_theme() df_new = df.loc[(df['position'] <= 10) & (df['année'] != 2022),:] # Chargez l'exemple de jeu de données de vols et convertissez-le en forme longue df_heat = df_new.pivot_table(index = "position", colonnes = "mois", valeurs = "query", aggfunc='count') # Dessinez une carte thermique avec les valeurs numériques dans chaque cellule f, ax = plt.subplots(figsize=(20, 12)) x_axis_labels = ["Septembre", "Octobre", "Novembre", "Décembre"] sns.heatmap(df_heat, annot=True, linewidths=.5, ax=ax, fmt='g', cmap = sns.cm.rocket_r, xticklabels=x_axis_labels) ax.set(xlabel = 'Month', ylabel='Position', title = 'Comment le nombre de requêtes par position change avec le temps') #faire pivoter les étiquettes de position pour les rendre plus lisibles plt.yticks(rotation=0)
Figure 4 : Heatmap montrant la progression du nombre de requêtes en fonction de la position et du mois.
C'est l'un de mes préférés, les heatmaps peuvent être assez efficaces pour afficher des tableaux croisés dynamiques, comme dans cet exemple. La période s'étend sur 4 mois et si vous la lisez horizontalement, vous pouvez voir comment le nombre de requêtes change au fil du temps. Pour la position 10, vous avez une petite augmentation de septembre à décembre, mais pour la position 2, vous avez une diminution frappante, comme le montre la couleur violette.
Dans le scénario suivant, vous avez la majorité des requêtes dans les premières places, ce qui peut être étonnamment inhabituel. Si cela se produit, vous voudrez peut-être revenir en arrière et analyser la base de données, en recherchant d'éventuels termes de marque, le cas échéant.
Comme vous le voyez dans le code, il n'est pas si difficile de créer des tracés complexes, tant que vous maîtrisez la logique.
Le nombre de requêtes devrait augmenter avec le temps si vous faites les "bonnes" choses et nous pouvons tracer la différence sur deux périodes différentes. Dans l'exemple que j'ai fourni, ce n'est clairement pas le cas, car, en particulier pour les premières positions, où vous êtes censé avoir un CTR plus élevé.
Présentation de quelques concepts de base de la PNL
Le traitement du langage naturel (NLP) est une aubaine pour le référencement et vous n'avez pas besoin d'être un expert pour appliquer les algorithmes de base. Les N-grammes sont l'une des idées les plus puissantes mais les plus simples qui peuvent vous donner un aperçu des données GSC.
Les N-grammes sont des séquences contiguës de lettres, de syllabes ou de mots. Pour notre analyse, les mots seront l'unité de mesure. Un n-gramme est appelé bigramme lorsque les éléments adjacents sont au nombre de deux (une paire) et trigramme s'ils sont au nombre de trois, et ainsi de suite. Je vous propose de tester avec différentes combinaisons et de monter à 5 grammes maximum.
De cette façon, vous êtes en mesure de repérer les phrases les plus courantes dans les pages de vos concurrents ou d'évaluer les vôtres. Étant donné que Google peut s'appuyer sur l'indexation basée sur des phrases, il est préférable d'optimiser les phrases plutôt que les mots clés individuels, comme le montrent les brevets de Google concernant ce sujet.
Comme indiqué dans la page ci-dessus par Bill Slawski lui-même, la valeur de la compréhension des termes associés est d'une grande valeur pour l'optimisation et pour vos utilisateurs.
La bibliothèque nltk est très connue pour les applications NLP et nous offre la possibilité de supprimer les mots vides dans une langue donnée, comme l'anglais. Considérez-les comme du bruit que vous souhaitez supprimer, en effet, les articles et les mots très fréquents n'ajoutent aucune valeur à la compréhension d'un texte.
importer nltk
nltk.download('mots vides')
à partir de nltk.corpus importer des mots vides
stoplist = stopwords.words('anglais')
à partir de sklearn.feature_extraction.text importer CountVectorizer
c_vec = CountVectorizer(stop_words=stoplist, ngram_range=(2,3))
# matrice de ngrammes
ngrams = c_vec.fit_transform(df['query'])
# compter la fréquence des ngrammes
count_values = ngrams.toarray().sum(axis=0)
# liste de ngrams
vocabulaire = c_vec.vocabulary_
df_ngram = pd.DataFrame(sorted([(count_values[i],k) for k,i in vocab.items()], reverse=True)
).rename(columns={0 : 'fréquence', 1 : 'bigramme/trigramme'})
df_ngram.head(20).style.background_gradient()
Nous prenons la colonne de requête et comptons la fréquence des bi-grammes pour créer une base de données stockant les bi-grammes et leur nombre d'occurrences.
Cette étape est en fait très importante pour analyser également les sites Web des concurrents. Vous pouvez simplement gratter leur texte et vérifier quels sont les n-grammes les plus courants, en réglant le n à chaque fois pour voir si vous repérez des modèles différents sur les pages de haut rang.
Si vous y réfléchissez une seconde, cela a beaucoup plus de sens, car un mot-clé individuel ne vous dit rien sur le contexte.
Fruits à portée de main
L'une des choses les plus agréables à faire est de vérifier les fruits à portée de main, ces pages que vous pouvez améliorer facilement pour voir de bons résultats le plus tôt possible. Ceci est crucial dans les premières étapes de chaque projet SEO pour convaincre vos parties prenantes. Par conséquent, s'il existe une opportunité de tirer parti de ces pages, faites-le !
Nos critères pour considérer une page en tant que telle sont les quantiles d'impressions et le CTR. En d'autres termes, nous filtrons les lignes qui se situent dans les 80 % d'impressions les plus élevées, mais dans les 20 % qui reçoivent le CTR le plus bas. Ces lignes auront un CTR pire que 80 % des autres.
top_impressions = df[df['impressions'] >= df['impressions'].quantile(0.8)]
(top_impressions[top_impressions['ctr'] <= top_impressions['ctr'].quantile(0.2)].sort_values('impressions', ascending = False))
Vous avez maintenant une liste avec toutes les opportunités triées par impressions, par ordre décroissant.
Vous pouvez penser à d'autres critères pour définir ce qu'est un fruit à portée de main, selon les besoins de votre site Web et sa taille.
Pour les petits sites Web, vous pouvez envisager de rechercher des pourcentages plus élevés, alors que dans les grands sites Web, vous devriez déjà obtenir de nombreuses informations avec les critères que j'utilise.
[Ebook] SEO technique pour les penseurs non techniques
Lire l'ebookPrésentation de querycat : classification et associations
Querycat est une bibliothèque simple mais puissante qui propose l'exploration de règles d'association pour les mots-clés de clustering et bien plus encore. Je ne vous montrerai que les associations car elles sont plus précieuses dans ce type d'analyse.
Vous pouvez en savoir plus sur cette bibliothèque géniale en consultant le référentiel querycat GitHub.
Brève introduction sur l'apprentissage des règles d'association
L'apprentissage des règles d'association est une méthode pour trouver des règles qui définissent des associations et des cooccurrences entre des ensembles d'éléments. Ceci est légèrement différent d'une autre méthode d'apprentissage automatique non supervisée, appelée clustering.
L'objectif final est le même cependant, obtenir des groupes de mots-clés pour comprendre comment notre site Web se comporte pour certains sujets.
Querycat vous donne la possibilité de choisir entre deux algorithmes : Apriori et FP-Growth. Nous allons choisir ce dernier pour de meilleures performances, vous pouvez donc ignorer le premier.
FP-Growth est une version améliorée d'Apriori pour trouver des modèles fréquents dans des ensembles de données. L'apprentissage des règles d'association est également très utile pour les transactions de commerce électronique, vous pourriez être intéressé par la compréhension de ce que les gens achètent ensemble, par exemple.
Dans ce cas, nous nous concentrons uniquement sur les requêtes, mais l'autre application que j'ai mentionnée peut être une autre idée utile pour les données de Google Analytics.
Expliquer ces algorithmes du point de vue de la structure des données est assez difficile et, à mon avis, pas nécessaire pour vos tâches de référencement. Je vais juste expliquer quelques concepts de base pour comprendre ce que signifient les paramètres.
Les 3 éléments principaux des 2 algorithmes sont :
- Support - Il exprime la popularité d'un élément ou d'un ensemble d'éléments. En termes techniques, c'est le nombre de transactions où la requête X et la requête Y apparaissent ensemble divisé par le nombre total de transactions.
De plus, il peut être utilisé comme seuil pour supprimer les éléments peu fréquents. Très utile pour augmenter la signification statistique et les performances. Fixer un bon support minimum, c'est très bien. - Confiance - vous pouvez la considérer comme la probabilité de cooccurrence des termes.
- Ascenseur - Le rapport entre le support pour (terme 1 et terme 2) et le support du terme 1. Nous pouvons examiner sa valeur pour avoir un aperçu de la relation entre les termes. Si supérieur à 1, les termes sont corrélés ; s'il est inférieur à 1, il est peu probable que les termes aient une association : si l'ascenseur est exactement égal à 1 (ou proche), il n'y a pas de relation significative.
Plus de détails sont fournis dans cet article sur querycat écrit par l'auteur de la bibliothèque.
Nous sommes maintenant prêts à passer à la partie pratique.
importer un chat de requête
query_cat = querycat.Categorize(df, 'query', min_support=10, alg='fpgrowth')
dfgrouped = df.groupby('category').agg(sumclicks = ('clicks', 'sum')).sort_values('sumclicks', ascending=False)
#créer un groupe pour filtrer les catégories avec moins de 15 clics (nombre arbitraire)
filtergroup = dfgrouped[dfgrouped['sumclicks'] > 15]
groupe de filtres
#appliquer le filtre
df = df.merge(filtergroup, on=['category','category'], how='inner')
Nous avons filtré les catégories moins fréquentes dans le processus, j'ai choisi 15 comme référence dans mon cas. C'est juste un nombre arbitraire, il n'y a aucun critère derrière.
Vérifions nos catégories avec l'extrait suivant :
df['category'].value_counts()
Qu'en est-il des 10 catégories les plus cliquées ? Vérifions combien de requêtes nous avons pour chacun d'eux.
df.groupby('category').sum()['clicks'].sort_values(ascending=False).head(10)
Le nombre à choisir est arbitraire, assurez-vous d'en choisir un qui filtre un bon pourcentage de groupes. Une idée potentielle consiste à obtenir la médiane des impressions et à supprimer les 50 % les plus bas, à condition que vous souhaitiez exclure les petits groupes.
Obtenir des clusters et quoi faire avec la sortie
Ma recommandation est d'exporter votre nouveau dataframe pour éviter d'exécuter à nouveau FP-Growth, veuillez le faire pour gagner du temps utile.
Dès que vous avez des clusters, vous souhaitez connaître les clics et les impressions pour chacun d'eux afin d'évaluer les domaines nécessitant le plus d'améliorations.
grouped_df = df.groupby('category')[['clicks', 'impressions']].agg('sum')
Avec quelques manipulations de données, nous sommes en mesure d'améliorer nos résultats d'association et d'avoir des clics et des impressions pour chaque cluster.
group_ex = df.groupby(['category'])['query'].apply(' | '.join).reset_index()
#supprimer les requêtes en double, puis les trier par ordre alphabétique
group_ex['query'] = group_ex['query'].apply(lambda x : ' | '.join(sorted(list(set(x.split('|'))))))
df_final = group_ex.merge(grouped_df, on=['category', 'category'], how='inner')
df_final.head()
Vous avez maintenant un fichier CSV avec tous vos groupes de mots clés ainsi que les clics et les impressions.
#save fichier csv et téléchargez-le sur votre ordinateur local. Si vous utilisez Safari, envisagez de passer à Chrome pour télécharger ces fichiers, car cela pourrait ne pas fonctionner.
df_final.to_csv('clusters_queries.csv')
files.download('clusters_queries.csv')
En fait, il existe de meilleures méthodes de clustering, ceci n'est qu'un exemple sur la façon dont vous pouvez utiliser querycat pour effectuer plusieurs tâches pour une utilisation immédiate. L'objectif principal ici est d'obtenir autant d'informations que possible, en particulier pour les nouveaux sites Web où vous n'avez pas beaucoup de connaissances.
À l'heure actuelle, les meilleures approches impliquent la sémantique, donc si vous voulez vous concentrer sur le clustering, je vous suggère d'envisager l'apprentissage de graphes ou d'intégrations.
Cependant, ce sont des sujets avancés si vous êtes novice et vous pouvez simplement essayer certaines applications Streamlit prédéfinies disponibles en ligne.
Oncrawl Data³
Apprendre encore plusConclusion et la suite
Python peut offrir une aide majeure dans l'analyse de votre site Web et peut vous aider à combiner le nettoyage, la visualisation et l'analyse des données en un seul endroit. L'extraction de données à partir de l'API GSC est absolument nécessaire pour les tâches plus avancées et constitue une introduction "en douceur" à l'automatisation des données.
Bien que vous puissiez effectuer de nombreux calculs plus avancés avec Python, ma recommandation est de vérifier ce qui a du sens en termes de valeur SEO.
Par exemple, le nombre de requêtes est bien plus important dans son ensemble à long terme, car vous souhaitez que votre site Web soit pris en compte pour plus de requêtes.
L'utilisation de blocs-notes est d'une grande aide pour emballer le code avec des commentaires et c'est la principale raison pour laquelle je vous suggère de vous habituer à Google Colab.
Ce n'est que le début de ce que l'analyse de données peut vous offrir, car les meilleures idées proviennent de la fusion de différents ensembles de données.
Google Search Console est en soi un outil puissant et totalement gratuit, la quantité d'informations pratiques que vous pouvez en tirer est presque illimitée entre de bonnes mains.