Trouver la cannibalisation des mots-clés à l'aide des intégrations de texte d'OpenAI avec des exemples

Cette nouvelle série d'articles se concentre sur la collaboration avec les LLM pour faire évoluer vos tâches de référencement. Nous espérons vous aider à intégrer l'IA dans le référencement afin que vous puissiez améliorer vos compétences.

Nous espérons que vous avez apprécié l’article précédent et que vous comprenez ce que sont les vecteurs, la distance vectorielle et les intégrations de texte.

Ensuite, il est temps de faire travailler vos « muscles de la connaissance de l’IA » en apprenant à utiliser les intégrations de texte pour trouver la cannibalisation des mots-clés.

Nous commencerons par les intégrations de texte d’OpenAI et les comparerons.

(*les jetons peuvent être considérés comme des mots.)

Mais avant de commencer, vous devez installer Python et Jupyter sur votre ordinateur.

Jupyter est un outil Web destiné aux professionnels et aux chercheurs. Il vous permet d'effectuer des analyses de données complexes et de développer des modèles d'apprentissage automatique à l'aide de n'importe quel langage de programmation.

Ne vous inquiétez pas, l'installation est très simple et prend peu de temps. Et n'oubliez pas que ChatGPT est votre ami en matière de programmation.

En un mot:

• Téléchargez et installez Python.
• Ouvrez votre ligne de commande Windows ou votre terminal sur Mac.
• Tapez ces commandes pip install jupyterlab et pip install notebook
• Exécutez Jupiter avec cette commande : jupyter lab

Nous utiliserons Jupyter pour expérimenter les intégrations de texte ; vous verrez à quel point c'est amusant de travailler avec !

Mais avant de commencer, vous devez vous inscrire à l'API d'OpenAI et configurer la facturation en remplissant votre solde.

Une fois que vous avez fait cela, configurez des notifications par e-mail pour vous informer lorsque vos dépenses dépassent un certain montant. Limites d'utilisation.

Ensuite, obtenez les clés API sous Tableau de bord > Clés API, que vous devriez garder privé et ne jamais partager publiquement.

Vous disposez désormais de tous les outils nécessaires pour commencer à jouer avec les intégrations.

• Ouvrez le terminal de commande de votre ordinateur et tapez jupyter lab.
• Vous devriez voir quelque chose comme l’image ci-dessous apparaître dans votre navigateur.
• Cliquer sur Python 3 sous Carnet de notes.

Dans la fenêtre ouverte, vous écrirez votre code.

Comme petite tâche, regroupons les URL similaires à partir d'un fichier CSV. L'exemple CSV comporte deux colonnes : URL et Titre. La tâche de notre script sera de regrouper les URL ayant des significations sémantiques similaires en fonction du titre afin que nous puissions consolider ces pages en une seule et résoudre les problèmes de cannibalisation des mots clés.

Voici les étapes à suivre :

Installez les bibliothèques Python requises avec les commandes suivantes dans le terminal de votre PC (ou dans le notebook Jupyter)

pip install pandas openai scikit-learn numpy unidecode

La bibliothèque « openai » est nécessaire pour interagir avec l'API OpenAI pour obtenir des intégrations, et « pandas » est utilisé pour la manipulation des données et la gestion des opérations de fichiers CSV.

La bibliothèque « scikit-learn » est nécessaire pour calculer la similarité cosinus, et « numpy » est indispensable pour les opérations numériques et la gestion des tableaux. Enfin, unidecode est utilisé pour nettoyer le texte.

Ensuite, téléchargez la feuille d’exemple au format CSV, renommez le fichier en pages.csv et téléchargez-le dans votre dossier Jupyter où se trouve votre script.

Définissez votre clé API OpenAI sur la clé que vous avez obtenue à l’étape ci-dessus et copiez-collez le code ci-dessous dans le bloc-notes.

Exécutez le code en cliquant sur l’icône du triangle de lecture en haut du bloc-notes.

import pandas as pd
import openai
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np
import csv
from unidecode import unidecode

# Function to clean text
def clean_text(text: str) -> str:
    # First, replace known problematic characters with their correct equivalents
    replacements = {
        '–': '–',   # en dash
        '’': '’',   # right single quotation mark
        '“': '“',   # left double quotation mark
        '”': '”',   # right double quotation mark
        '‘': '‘',   # left single quotation mark
        'â€': '—'     # em dash
    }
    for old, new in replacements.items():
        text = text.replace(old, new)
    # Then, use unidecode to transliterate any remaining problematic Unicode characters
    text = unidecode(text)
    return text

# Load the CSV file with UTF-8 encoding from root folder of Jupiter project folder
df = pd.read_csv('pages.csv', encoding='utf-8')

# Clean the 'Title' column to remove unwanted symbols
df['Title'] = df['Title'].apply(clean_text)

# Set your OpenAI API key
openai.api_key = 'your-api-key-goes-here'

# Function to get embeddings
def get_embedding(text):
    response = openai.Embedding.create(input=[text], engine="text-embedding-ada-002")
    return response['data'][0]['embedding']

# Generate embeddings for all titles
df['embedding'] = df['Title'].apply(get_embedding)

# Create a matrix of embeddings
embedding_matrix = np.vstack(df['embedding'].values)

# Compute cosine similarity matrix
similarity_matrix = cosine_similarity(embedding_matrix)

# Define similarity threshold
similarity_threshold = 0.9  # since threshold is 0.1 for dissimilarity

# Create a list to store groups
groups = []

# Keep track of visited indices
visited = set()

# Group similar titles based on the similarity matrix
for i in range(len(similarity_matrix)):
    if i not in visited:
        # Find all similar titles
        similar_indices = np.where(similarity_matrix[i] >= similarity_threshold)[0]
        
        # Log comparisons
        print(f"nChecking similarity for '{df.iloc[i]['Title']}' (Index {i}):")
        print("-" * 50)
        for j in range(len(similarity_matrix)):
            if i != j:  # Ensure that a title is not compared with itself
                similarity_value = similarity_matrix[i, j]
                comparison_result="greater" if similarity_value >= similarity_threshold else 'less'
                print(f"Compared with '{df.iloc[j]['Title']}' (Index {j}): similarity = {similarity_value:.4f} ({comparison_result} than threshold)")

        # Add these indices to visited
        visited.update(similar_indices)
        # Add the group to the list
        group = df.iloc[similar_indices][['URL', 'Title']].to_dict('records')
        groups.append(group)
        print(f"nFormed Group {len(groups)}:")
        for item in group:
            print(f"  - URL: {item['URL']}, Title: {item['Title']}")

# Check if groups were created
if not groups:
    print("No groups were created.")

# Define the output CSV file
output_file="grouped_pages.csv"

# Write the results to the CSV file with UTF-8 encoding
with open(output_file, 'w', newline="", encoding='utf-8') as csvfile:
    fieldnames = ['Group', 'URL', 'Title']
    writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
    
    writer.writeheader()
    for group_index, group in enumerate(groups, start=1):
        for page in group:
            cleaned_title = clean_text(page['Title'])  # Ensure no unwanted symbols in the output
            writer.writerow({'Group': group_index, 'URL': page['URL'], 'Title': cleaned_title})
            print(f"Writing Group {group_index}, URL: {page['URL']}, Title: {cleaned_title}")

print(f"Output written to {output_file}")

Ce code lit un fichier CSV, « pages.csv », contenant des titres et des URL, que vous pouvez facilement exporter depuis votre CMS ou obtenir en explorant un site Web client à l'aide de Screaming Frog.

Ensuite, il nettoie les titres des caractères non UTF, génère des vecteurs d'intégration pour chaque titre à l'aide de l'API d'OpenAI, calcule la similitude entre les titres, regroupe les titres similaires et écrit les résultats groupés dans un nouveau fichier CSV, « grouped_pages.csv ».

Dans la tâche de cannibalisation des mots-clés, nous utilisons un seuil de similarité de 0,9, ce qui signifie que si la similarité cosinus est inférieure à 0,9, nous considérerons les articles comme différents. Pour visualiser cela dans un espace bidimensionnel simplifié, cela apparaîtra comme deux vecteurs avec un angle d'environ 25 degrés entre eux.

Dans votre cas, vous souhaiterez peut-être utiliser un seuil différent, comme 0,85 (environ 31 degrés entre eux), et l'exécuter sur un échantillon de vos données pour évaluer les résultats et la qualité globale des correspondances. S'il n'est pas satisfaisant, vous pouvez augmenter le seuil pour le rendre plus strict et ainsi obtenir une meilleure précision.

Vous pouvez installer 'matplotlib' via le terminal.

Et utilisez le code Python ci-dessous dans un bloc-notes Jupyter séparé pour visualiser vous-même les similitudes cosinus dans un espace bidimensionnel. Essayez, c'est amusant !

import matplotlib.pyplot as plt
import numpy as np

# Define the angle for cosine similarity of 0.9. Change here to your desired value. 
theta = np.arccos(0.9)

# Define the vectors
u = np.array([1, 0])
v = np.array([np.cos(theta), np.sin(theta)])

# Define the 45 degree rotation matrix
rotation_matrix = np.array([
    [np.cos(np.pi/4), -np.sin(np.pi/4)],
    [np.sin(np.pi/4), np.cos(np.pi/4)]
])

# Apply the rotation to both vectors
u_rotated = np.dot(rotation_matrix, u)
v_rotated = np.dot(rotation_matrix, v)

# Plotting the vectors
plt.figure()
plt.quiver(0, 0, u_rotated[0], u_rotated[1], angles="xy", scale_units="xy", scale=1, color="r")
plt.quiver(0, 0, v_rotated[0], v_rotated[1], angles="xy", scale_units="xy", scale=1, color="b")

# Setting the plot limits to only positive ranges
plt.xlim(0, 1.5)
plt.ylim(0, 1.5)

# Adding labels and grid
plt.xlabel('X-axis')
plt.ylabel('Y-axis')
plt.grid(True)
plt.title('Visualization of Vectors with Cosine Similarity of 0.9')

# Show the plot
plt.show()

J'utilise généralement 0,9 et plus pour identifier les problèmes de cannibalisation des mots clés, mais vous devrez peut-être le définir sur 0,5 lorsque vous traitez d'anciens redirections d'articles, car les anciens articles peuvent ne pas avoir d'articles presque identiques qui sont plus récents mais partiellement proches.

Il peut également être préférable d'avoir la méta description concaténée avec le titre en cas de redirections, en plus du titre.

Cela dépend donc de la tâche que vous effectuez. Nous verrons comment implémenter les redirections dans un article séparé plus loin dans cette série.

Maintenant, examinons les résultats avec les trois modèles mentionnés ci-dessus et voyons comment ils ont pu identifier des articles proches de notre échantillon de données à partir des articles du Search Engine Journal.

Dans la liste, nous voyons déjà que les articles 2 et 4 traitent du même sujet sur les « balises méta ». Les articles des 5 et 7 lignes sont à peu près les mêmes, ils traitent de l'importance des balises H1 dans le référencement, et peuvent être fusionnés.

L'article de la 3e ligne ne présente aucune similitude avec aucun des articles de la liste, mais contient des mots communs comme « Tag » ou « SEO ».

L'article de la 6e ligne porte à nouveau sur H1, mais pas exactement sur l'importance de H1 pour le référencement. Il représente plutôt l'opinion de Google sur la question de savoir s'ils doivent correspondre.

Les articles des 8e et 9e rangées sont assez proches mais néanmoins différents ; ils peuvent être combinés.

intégration-de-texte-ada-002

En utilisant « text-embedding-ada-002 », nous avons trouvé précisément les 2e et 4e articles avec une similarité cosinus de 0,92 et les 5e et 7e articles avec une similarité de 0,91.

Et il a généré une sortie avec des URL groupées en utilisant le même numéro de groupe pour des articles similaires. (les couleurs sont appliquées manuellement à des fins de visualisation).

Pour les articles 2 et 3, qui ont en commun les mots « Tag » et « SEO » mais qui ne sont pas liés, la similarité cosinus était de 0,86. Cela montre pourquoi un seuil de similarité élevé de 0,9 ou plus est nécessaire. Si nous le fixions à 0,85, il serait rempli de faux positifs et pourrait suggérer de fusionner des articles non liés.

intégration-de-texte-3-petit

En utilisant « text-embedding-3-small », de manière assez surprenante, aucune correspondance n'a été trouvée selon notre seuil de similarité de 0,9 ou plus.

Pour les 2e et 4e articles, la similarité cosinus était de 0,76, et pour les 5e et 7e articles, la similarité était de 0,77.

Pour mieux comprendre ce modèle grâce à l'expérimentation, j'ai ajouté une version légèrement modifiée de la 1ère ligne avec « 15 » contre « 14 » à l'échantillon.

1. « Les 14 balises méta et HTML les plus importantes que vous devez connaître pour le référencement »
2. « Les 15 balises méta et HTML les plus importantes que vous devez connaître pour le référencement »

Au contraire, « text-embedding-ada-002 » a donné une similarité cosinus de 0,98 entre ces versions.

Ici, nous voyons que ce modèle n’est pas tout à fait adapté à la comparaison des titres.

intégration-de-texte-3-large

La dimensionnalité de ce modèle est de 3072, ce qui est 2 fois plus élevé que celle de 'text-embedding-3-small' et 'text-embedding-ada-002', avec une dimensionnalité de 1536.

Comme il possède plus de dimensions que les autres modèles, on pourrait s’attendre à ce qu’il capture le sens sémantique avec une plus grande précision.

Cependant, il a donné aux 2e et 4e articles une similarité cosinus de 0,70 et aux 5e et 7e articles une similarité de 0,75.

Je l'ai testé à nouveau avec des versions légèrement modifiées du premier article avec « 15 » contre « 14 » et sans « Le plus important » dans le titre.

1. « Les 14 balises méta et HTML les plus importantes que vous devez connaître pour le référencement »
2. « Les 15 balises méta et HTML les plus importantes que vous devez connaître pour le référencement »
3. « 14 balises méta et HTML à connaître pour le référencement »

Nous pouvons donc voir que « text-embedding-3-large » est sous-performant par rapport à « text-embedding-ada-002 » lorsque nous calculons les similitudes cosinus entre les titres.

Je tiens à souligner que la précision de « text-embedding-3-large » augmente avec la longueur du texte, mais « text-embedding-ada-002 » est toujours plus performant dans l'ensemble.

Une autre approche pourrait consister à supprimer les mots vides du texte. Leur suppression peut parfois aider à concentrer les inclusions sur des mots plus significatifs, améliorant ainsi potentiellement la précision de tâches telles que les calculs de similarité.

La meilleure façon de déterminer si la suppression des mots vides améliore la précision de votre tâche et de votre ensemble de données spécifiques est de tester empiriquement les deux approches et de comparer les résultats.

Conclusion

Grâce à ces exemples, vous avez appris à travailler avec les modèles d'intégration d'OpenAI et pouvez déjà effectuer un large éventail de tâches.

Pour les seuils de similarité, vous devez expérimenter avec vos propres ensembles de données et voir quels seuils sont logiques pour votre tâche spécifique en l'exécutant sur des échantillons de données plus petits et en effectuant un examen humain du résultat.

Veuillez noter que le code que nous avons dans cet article n'est pas optimal pour les grands ensembles de données, car vous devez créer des intégrations de texte d'articles à chaque fois qu'il y a un changement dans votre ensemble de données pour évaluer par rapport à d'autres lignes.

Pour que cela soit efficace, nous devons utiliser des bases de données vectorielles et y stocker les informations d'intégration une fois générées. Nous verrons très bientôt comment utiliser les bases de données vectorielles et modifierons l'exemple de code ici pour utiliser une base de données vectorielle.

Davantage de ressources: