Örneklerle OpenAI'nin Metin Gömmelerini Kullanarak Anahtar Kelime Yamyamlığını Bulun

Bu yeni makale dizisi, SEO görevlerinizi ölçeklendirmek için LLM'lerle çalışmaya odaklanıyor. AI'yı SEO'ya entegre etmenize yardımcı olmayı umuyoruz, böylece becerilerinizi geliştirebilirsiniz.

Önceki makaleyi beğendiğinizi ve vektörlerin, vektör mesafesinin ve metin yerleştirmelerinin ne olduğunu anladığınızı umuyoruz.

Bunun ardından, anahtar kelime yamyamlığını bulmak için metin yerleştirmelerini nasıl kullanacağınızı öğrenerek “Yapay Zeka bilgi kaslarınızı” esnetmenin zamanı geldi.

OpenAI'nin metin yerleştirmeleriyle başlayıp bunları karşılaştıracağız.

(*jetonlar kelime kelime olarak düşünülebilir.)

Ancak başlamadan önce bilgisayarınıza Python ve Jupyter'i yüklemeniz gerekiyor.

Jupyter, profesyoneller ve araştırmacılar için web tabanlı bir araçtır. Herhangi bir programlama dilini kullanarak karmaşık veri analizi ve makine öğrenimi modeli geliştirmesi yapmanıza olanak tanır.

https://www.youtube.com/watch?v=HW29067qVWk

Endişelenmeyin – gerçekten kolay ve kurulumları tamamlamak çok az zaman alıyor. Ve unutmayın, programlama söz konusu olduğunda ChatGPT sizin dostunuzdur.

Kısaca:

• Python’ı indirin ve kurun.
• Mac'inizde Windows komut satırını veya terminali açın.
• Bu komutları yazın pip install jupyterlab Ve pip install notebook
• Jupiter'i şu komutla çalıştırın: jupyter lab

Metin yerleştirmeleri üzerinde deneyler yapmak için Jupyter'ı kullanacağız; onunla çalışmanın ne kadar eğlenceli olduğunu göreceksiniz!

Ancak başlamadan önce OpenAI'nin API'sine kaydolmalı ve bakiyenizi doldurarak faturalandırmayı ayarlamalısınız.

Bunu yaptıktan sonra, harcamalarınız belirli bir miktarı aştığında sizi bilgilendirmek için e-posta bildirimleri ayarlayın. Kullanım sınırları.

Daha sonra, API anahtarlarını edinin Gösterge Paneli > API anahtarları, gizli tutmanız ve asla kamuoyuyla paylaşmamanız gereken bilgiler.

Artık, yerleştirmelerle oynamaya başlamak için gereken tüm araçlara sahipsiniz.

• Bilgisayarınızın komut terminalini açın ve şunu yazın jupyter lab.
• Tarayıcınızda aşağıdaki görüntüye benzer bir şey görmelisiniz.
• Tıklamak piton 3 altında Not defteri.

Açılan pencerede kodunuzu yazacaksınız.

Küçük bir görev olarak, benzer URL'leri bir CSV'den gruplayalım. Örnek CSV'de iki sütun vardır: URL ve Başlık. Komut dosyamızın görevi, benzer anlamsal anlamlara sahip URL'leri başlığa göre gruplamak olacak, böylece bu sayfaları tek bir sayfaya birleştirebilecek ve anahtar kelime yamyamlığı sorunlarını düzeltebileceğiz.

Yapmanız gereken adımlar şunlardır:

Aşağıdaki komutları kullanarak gerekli Python kütüphanelerini bilgisayarınızın terminaline (veya Jupyter notebook'una) yükleyin

pip install pandas openai scikit-learn numpy unidecode

Gömülü verileri elde etmek için OpenAI API'siyle etkileşim kurmak için 'openai' kütüphanesi, veri işleme ve CSV dosya işlemlerini yönetmek için ise 'pandas' kütüphanesi gereklidir.

Kosinüs benzerliğini hesaplamak için 'scikit-learn' kütüphanesi gereklidir ve sayısal işlemler ve dizileri işlemek için 'numpy' gereklidir. Son olarak, unidecode metni temizlemek için kullanılır.

Daha sonra örnek çalışma sayfasını CSV olarak indirin, dosyanın adını pages.csv olarak değiştirin ve betiğinizin bulunduğu Jupyter klasörünüze yükleyin.

OpenAI API anahtarınızı yukarıdaki adımda elde ettiğiniz anahtarla değiştirin ve aşağıdaki kodu not defterinize kopyalayıp yapıştırın.

Not defterinin üst kısmındaki oynatma üçgeni simgesine tıklayarak kodu çalıştırın.

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}")

Bu kod, başlıklar ve URL'ler içeren 'pages.csv' adlı bir CSV dosyasını okur. Bu dosyayı CMS'nizden kolayca dışarı aktarabilir veya Screaming Frog'u kullanarak bir müşteri web sitesini tarayarak alabilirsiniz.

Daha sonra, başlıkları UTF olmayan karakterlerden temizler, OpenAI'nin API'sini kullanarak her başlık için gömme vektörleri oluşturur, başlıklar arasındaki benzerliği hesaplar, benzer başlıkları gruplandırır ve gruplanmış sonuçları yeni bir CSV dosyası olan 'grouped_pages.csv'ye yazar.

Anahtar kelime yamyamlaştırma görevinde, 0,9'luk bir benzerlik eşiği kullanırız, bu da kosinüs benzerliği 0,9'dan azsa makaleleri farklı olarak kabul edeceğimiz anlamına gelir. Bunu basitleştirilmiş iki boyutlu bir uzayda görselleştirmek için, aralarında yaklaşık 25 derecelik bir açı bulunan iki vektör olarak görünecektir.

Sizin durumunuzda, 0,85 (aralarında yaklaşık 31 derece) gibi farklı bir eşik kullanmak ve sonuçları ve eşleşmelerin genel kalitesini değerlendirmek için bunu verilerinizin bir örneği üzerinde çalıştırmak isteyebilirsiniz. Tatmin edici değilse, daha iyi hassasiyet için eşiği daha katı hale getirmek üzere artırabilirsiniz.

'matplotlib' kurulumunu terminal üzerinden yapabilirsiniz.

Ve aşağıdaki Python kodunu ayrı bir Jupyter not defterinde kullanarak iki boyutlu uzayda kosinüs benzerliklerini kendi başınıza görselleştirin. Deneyin; eğlenceli!

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()

Anahtar kelime yamyamlığı sorunlarını tanımlamak için genellikle 0.9 ve üzerini kullanırım, ancak eski makale yönlendirmeleriyle uğraşırken bunu 0.5 olarak ayarlamanız gerekebilir, çünkü eski makalelerde daha yeni ancak kısmen benzer olan neredeyse aynı makaleler olmayabilir.

Yönlendirmeler durumunda başlığa ek olarak meta açıklamasının da başlıkla birleştirilmesi daha iyi olabilir.

Yani, gerçekleştirdiğiniz göreve bağlıdır. Yönlendirmelerin nasıl uygulanacağını bu serinin ilerleyen kısımlarında ayrı bir makalede inceleyeceğiz.

Şimdi yukarıda bahsi geçen üç modelle sonuçları inceleyelim ve Search Engine Journal makalelerinden oluşan veri örneğimizden yakın makaleleri nasıl tespit edebildiklerine bakalım.

Listeden, 2. ve 4. makalelerin 'meta etiketler' konusunda aynı konuyu ele aldığını görüyoruz. 5. ve 7. satırlardaki makaleler hemen hemen aynı – SEO'da H1 etiketlerinin önemini tartışıyorlar – ve birleştirilebilirler.

3. sıradaki makale, listedeki makalelerin hiçbiriyle benzerlik göstermiyor ancak “Etiket” veya “SEO” gibi ortak kelimeler içeriyor.

6. sıradaki makale yine H1 ile ilgili, ancak H1'in SEO için önemiyle tam olarak aynı değil. Bunun yerine, Google'ın eşleşmeleri gerekip gerekmediğine dair görüşünü temsil ediyor.

8. ve 9. sıradaki maddeler birbirine oldukça yakın ama yine de farklı; birleştirilebilirler.

metin-gömme-ada-002

'text-embedding-ada-002' ifadesini kullanarak 2. ve 4. makaleleri 0,92'lik bir kosinüs benzerliğiyle, 5. ve 7. makaleleri ise 0,91'lik bir benzerliğiyle tam olarak bulduk.

Ve benzer makaleler için aynı grup numarasını kullanarak gruplanmış URL'lerle çıktı üretti. (renkler görselleştirme amacıyla manuel olarak uygulandı).

Ortak kelimeler “Etiket” ve “SEO” içeren ancak ilgisiz olan 2. ve 3. makaleler için kosinüs benzerliği 0,86 idi. Bu, 0,9 veya daha yüksek bir yüksek benzerlik eşiğinin neden gerekli olduğunu gösterir. Bunu 0,85'e ayarlarsak, yanlış pozitiflerle dolu olur ve ilgisiz makalelerin birleştirilmesini önerebilir.

metin-gömme-3-küçük

'text-embedding-3-small' ifadesini kullanarak, şaşırtıcı bir şekilde, 0,9 veya daha yüksek olan benzerlik eşiğimize göre herhangi bir eşleşme bulamadı.

2. ve 4. maddeler için kosinüs benzerliği 0,76, 5. ve 7. maddeler için ise benzerlik 0,77 olarak bulunmuştur.

Bu modeli deneylerle daha iyi anlayabilmek için, örneğe 1. satırın biraz değiştirilmiş bir versiyonunu, '15' yerine '14' olarak ekledim.

1. “SEO İçin Bilmeniz Gereken En Önemli 14 Meta ve HTML Etiketi”
2. “SEO İçin Bilmeniz Gereken En Önemli 15 Meta ve HTML Etiketi”

Buna karşılık, 'text-embedding-ada-002' bu versiyonlar arasında 0.98 kosinüs benzerliği verdi.

Burada bu modelin başlıkları karşılaştırmak için pek de uygun olmadığını görüyoruz.

metin-gömme-3-büyük

Bu modelin boyutluluğu 3072'dir ve bu da 1536 boyutluluğa sahip 'text-embedding-3-small' ve 'text-embedding-ada-002' modellerinden 2 kat daha fazladır.

Diğer modellere göre daha fazla boyuta sahip olması nedeniyle semantik anlamı daha yüksek hassasiyetle yakalamasını bekleyebiliriz.

Ancak 2. ve 4. maddelere 0,70 kosinüs benzerliği, 5. ve 7. maddelere ise 0,75 kosinüs benzerliği vermiştir.

İlk makalenin biraz değiştirilmiş versiyonlarıyla, '15' ve '14' ile ve başlıkta 'En Önemli' olmadan tekrar denedim.

1. “SEO İçin Bilmeniz Gereken En Önemli 14 Meta ve HTML Etiketi”
2. “SEO İçin Bilmeniz Gereken En Önemli 15 Meta ve HTML Etiketi”
3. “SEO İçin Bilmeniz Gereken 14 Meta ve HTML Etiketi”

Yani başlıklar arasındaki kosinüs benzerliklerini hesapladığımızda 'text-embedding-3-large'ın 'text-embedding-ada-002' ile karşılaştırıldığında daha düşük performans gösterdiğini görebiliriz.

'text-embedding-3-large'ın doğruluğunun metnin uzunluğuyla arttığını, ancak 'text-embedding-ada-002'nin genel olarak daha iyi performans gösterdiğini belirtmek isterim.

Başka bir yaklaşım, metinden durdurma sözcüklerini çıkarmak olabilir. Bunları kaldırmak bazen yerleştirmeleri daha anlamlı sözcüklere odaklamaya yardımcı olabilir ve bu da benzerlik hesaplamaları gibi görevlerin doğruluğunu potansiyel olarak artırabilir.

Durdurma sözcüklerini kaldırmanın belirli göreviniz ve veri kümeniz için doğruluğu artırıp artırmadığını belirlemenin en iyi yolu, her iki yaklaşımı da deneysel olarak test etmek ve sonuçları karşılaştırmaktır.

Çözüm

Bu örneklerle OpenAI'nin gömme modelleriyle nasıl çalışacağınızı öğrendiniz ve çok çeşitli görevleri gerçekleştirebilirsiniz.

Benzerlik eşikleri için, kendi veri kümelerinizle denemeler yapmanız ve daha küçük veri örneklerinde çalıştırarak ve çıktıyı insan incelemesiyle inceleyerek hangi eşiklerin sizin özel göreviniz için mantıklı olduğunu görmeniz gerekir.

Bu makaledeki kodun büyük veri kümeleri için uygun olmadığını lütfen unutmayın; çünkü veri kümenizde bir değişiklik olduğunda diğer satırlarla karşılaştırmak için makalelerin metin yerleştirmelerini oluşturmanız gerekir.

Verimli hale getirmek için vektör veritabanlarını kullanmalı ve oluşturulduktan sonra gömme bilgilerini orada depolamalıyız. Çok yakında vektör veritabanlarının nasıl kullanılacağını ele alacağız ve buradaki kod örneğini vektör veritabanı kullanacak şekilde değiştireceğiz.

Daha fazla kaynak:

Öne Çıkan Görsel: BestForBest/Shutterstock