چطور خوشه بندی کلمات کلیدی بر اساس هدف جستجو را با پایتون خودکار کنیم

5/5 - (1 امتیاز)

در این راهنمای کاربردی یاد می‌گیریم چطور با مقایسه نتایج گوگل (SERP) و استفاده از پایتون، کلمات کلیدی را بر اساس هدف جستجو (Search Intent) به صورت سریع‌تر و شهودی‌تر خوشه‌بندی کنیم.

ماجرا اینه که درباره هدف جستجو چیزای زیادی وجود داره که باید بدونیم؛ از استفاده از یادگیری عمیق (Deep Learning) برای تشخیص هدف جستجو از روی متن و تحلیل عنوان‌های نتایج گوگل با روش‌های پردازش زبان طبیعی (NLP)، گرفته تا خوشه‌بندی بر اساس شباهت معنایی و بررسی مزایای هر روش.

ما فقط از مزایای درک هدف جستجو مطلع نیستیم، بلکه کلی تکنیک هم برای انجام این کار به‌صورت گسترده و خودکار در اختیار داریم.

اما با وجود همه این‌ها، چرا هنوز به مقاله‌ای جدید درباره خودکارسازی هدف جستجو نیاز داریم؟

دلیلش واضحه: الان با ورود جستجوی مبتنی بر هوش مصنوعی (AI Search)، درک و شناسایی هدف جستجو اهمیت خیلی بیشتری پیدا کرده.

در گذشته که گوگل بیشتر بر اساس همون ۱۰ لینک آبی کلاسیک نتایج رو نشون می‌داد، هدف جستجو اونقدر پیچیده و حیاتی نبود. اما حالا با تکنولوژی جستجوی هوشمند، شرایط فرق کرده؛ چون این سیستم‌ها معمولاً دنبال این هستن که هزینه‌های پردازشی (FLOP) رو پایین نگه دارن و سریع‌تر نتیجه بدن.

هنوز هم بهترین راه تحلیل هدف جستجو، بررسی نتایج گوگل (SERPs) است

تا الان بیشتر روش‌هایی که برای درک هدف جستجو (Search Intent) معرفی شدن، به نوعی به استفاده از هوش مصنوعی خودمون ختم می‌شن. مثلاً باید تمام عنوان‌های محتواهایی که برای یک کلمه کلیدی رتبه گرفتن رو جمع کنیم، بعد اون‌ها رو وارد یک مدل شبکه عصبی (Neural Network) کنیم که تازه باید خودمون اون مدل رو طراحی و تست کنیم! یا اینکه با کمک پردازش زبان طبیعی (NLP) بیایم و کلمات کلیدی رو دسته‌بندی کنیم.

اما اگر نه وقتشو داشته باشی و نه دانششو که بخوای مدل هوش مصنوعی بسازی یا از APIهای OpenAI استفاده کنی، چی؟

درسته که شباهت کسینوسی (Cosine Similarity) به عنوان راهکاری برای کمک به سئوکارها در طراحی ساختار سایت و دسته‌بندی موضوعات معرفی شده، اما من هنوزم معتقدم دسته‌بندی بر اساس نتایج جستجو (Search Clustering by SERP Results) روش دقیق‌تر و بهتریه.

چرا؟ چون هوش مصنوعی خودش هم برای خروجی گرفتن، از نتایج گوگل الهام می‌گیره – و دلیل خوبی هم داره. چون نتایج گوگل بر اساس رفتار کاربران مدل‌سازی شدن.

یه روش دیگه هم وجود داره که از خودِ هوش مصنوعی گوگل برای این کار استفاده می‌کنه. بدون اینکه نیاز باشه کل نتایج جستجو رو اسکرپ (scrape) کنی یا یه مدل بسازی.

بیاین این فرض رو داشته باشیم که گوگل لینک‌ها و سایت‌ها رو بر اساس میزان احتمال پاسخ‌گویی محتوا به نیاز کاربر مرتب می‌کنه. پس اگر هدف جستجو برای دو تا کلمه کلیدی یکی باشه، نتایجشون هم احتمالاً شبیه هم خواهند بود.

برای سال‌ها، خیلی از متخصص‌های سئو با مقایسه نتایج جستجوی چند کلمه کلیدی سعی می‌کردن بفهمن که هدف جستجو چیه، مخصوصاً برای اینکه توی آپدیت هسته عقب نمونن. پس این روش چیز جدیدی نیست.

چیزی که اینجا ارزشمنده، اتوماتیک کردن این مقایسه‌هاست؛ چیزی که باعث می‌شه هم سریع‌تر پیش بریم و هم دقت بیشتری داشته باشیم.

چطور کلمات کلیدی رو با توجه به نیت جستجو در مقیاس بالا خوشه‌بندی کنیم (با پایتون و کد نمونه)

فرض کنیم شما فایل نتایج جستجو (SERPs) رو برای مجموعه‌ای از کلمات کلیدی به‌صورت CSV دارید. حالا می‌خوایم این فایل رو وارد پایتون کنیم و قدم به قدم برای خوشه‌بندی موضوعی بر اساس نیت جستجو آماده‌اش کنیم.

1. وارد کردن فایل SERP در پایتون

در این مرحله، با استفاده از کتابخانه‌های Pandas و NumPy، فایل CSV رو به یه دیتافریم (DataFrame) تبدیل می‌کنیم:

کپی کد

با اجرای این کد، فایل SERP شما وارد محیط پایتون می‌شه و حالا آماده‌ایم تا شروع به فیلتر کردن نتایج کنیم.

2. فیلتر کردن نتایج صفحه اول گوگل

هدف اینه که فقط نتایج صفحه اول گوگل برای هر کلمه کلیدی رو نگه داریم، چون دقیق‌ترین سیگنال‌ها از نیت جستجو معمولاً توی همین صفحه هستن.

برای این کار، دیتافریم رو بر اساس کلمه کلیدی گروه‌بندی می‌کنیم، نتایج فاقد URL یا رنک بالاتر از ۱۵ رو حذف می‌کنیم، و دوباره همه چیز رو به یه جدول واحد تبدیل می‌کنیم:

کپی کد

حالا یه جدول تمیز داریم که فقط شامل نتایج صفحه اول برای هر کلمه کلیدی هست و آماده‌ایم که وارد مراحل بعدی برای خوشه‌بندی موضوعی بشیم.

۳. تبدیل URLهای نتایج جستجو به یک رشته برای هر کلمه کلیدی

تا اینجای کار، برای هر کلمه کلیدی، چندین URL مربوط به صفحه اول نتایج جستجو داریم. اما چون می‌خوایم در نهایت بتونیم مقایسه راحت‌تری بین کلمات کلیدی انجام بدیم، لازمه که همه‌ی URLهای مربوط به یک کلمه رو به صورت یک رشته‌ی متنی توی یک خط جمع کنیم.

درواقع داریم برای هر کلمه کلیدی، یه نمای کلی از نتایج صفحه اول گوگل رو به شکل یه متن ساده در میاریم.

نحوه انجام کار:

کپی کد

در نهایت، برای هر کلمه کلیدی، یه رشته‌ی متنی داریم که شامل تمام URLهای صفحه اول اون کلمه‌ست. این ساختار جدید خیلی به کار ما برای مرحله بعدی یعنی تحلیل شباهت و خوشه‌بندی موضوعی کلمات کلیدی کمک می‌کنه.

۴. مقایسه فاصله نتایج جستجو (ادامه)

برای اینکه مقایسه بین نتایج جستجوی گوگل (SERP) به درستی انجام بشه، باید هر کلمه کلیدی رو با سایر کلمات موجود جفت کنیم و نتایجشون رو در کنار هم قرار بدیم.

در این کد پایتون، تابع serps_align طراحی شده تا دقیقاً همین کار رو انجام بده. این تابع برای یک کلمه کلیدی خاص، تمام SERPهای دیگر کلمات رو کنار اون قرار میده و آماده مقایسه می‌کنه. به زبان ساده، این تابع، داده‌ها رو طوری تنظیم می‌کنه که بشه بررسی کرد آیا نتایج جستجو برای کلمات مختلف به هم شباهت دارن یا نه.

کپی کد

تصویری که بالا نشون داده شده، تمام ترکیب‌های ممکن بین SERPهای کلمات کلیدی رو نشون میده و حالا آماده مقایسه دقیق متن نتایج جستجو هستیم.

نکته مهم اینجاست که هیچ کتابخانه متن‌باز (Open-source library) شناخته‌شده‌ای وجود نداره که بتونه لیست‌های نتایج جستجو رو بر اساس ترتیب آیتم‌ها با هم مقایسه کنه. به همین خاطر، تابعی برای این کار نوشته شده.

این تابع با نام serp_compare طراحی شده تا میزان اشتراک بین سایت‌ها و ترتیب نمایش اون‌ها رو در بین دو SERP بررسی کنه. این مقایسه به شما کمک میکنه تا متوجه بشید که کلمه‌های کلیدی مشابه چقدر از نظر نتایج به هم نزدیک هستن، و این موضوع میتونه در بهینه‌سازی ساختار سایت و استراتژی سئو نقش خیلی مهمی داشته باشه.

کپی کد

import py_stringmatching as sm
ws_tok = sm.WhitespaceTokenizer()

# Only compare the top k_urls results 
def serps_similarity(serps_str1, serps_str2, k=15):
    denom = k+1
    norm = sum([2*(1/i - 1.0/(denom)) for i in range(1, denom)])
    #use to tokenize the URLs
    ws_tok = sm.WhitespaceTokenizer()
    #keep only first k URLs
    serps_1 = ws_tok.tokenize(serps_str1)[:k]
    serps_2 = ws_tok.tokenize(serps_str2)[:k]
    #get positions of matches 
    match = lambda a, b: [b.index(x)+1 if x in b else None for x in a]
    #positions intersections of form [(pos_1, pos_2), ...]
    pos_intersections = [(i+1,j) for i,j in enumerate(match(serps_1, serps_2)) if j is not None] 
    pos_in1_not_in2 = [i+1 for i,j in enumerate(match(serps_1, serps_2)) if j is None]
    pos_in2_not_in1 = [i+1 for i,j in enumerate(match(serps_2, serps_1)) if j is None]
    
    a_sum = sum([abs(1/i -1/j) for i,j in pos_intersections])
    b_sum = sum([abs(1/i -1/denom) for i in pos_in1_not_in2])
    c_sum = sum([abs(1/i -1/denom) for i in pos_in2_not_in1])

intent_prime = a_sum + b_sum + c_sum
    intent_dist = 1 - (intent_prime/norm)
    return intent_dist

# Apply the function
matched_serps['si_simi'] = matched_serps.apply(lambda x: serps_similarity(x.serp_string, x.serp_string_b), axis=1)

# This is what you get
matched_serps[['keyword', 'keyword_b', 'si_simi']]

حالا که مقایسه‌ها انجام شده، می‌تونیم خوشه‌بندی کلمات کلیدی رو شروع کنیم.

ما هر کلمه کلیدی‌ای که شباهت وزنی (weighted similarity) بین‌شون ۴۰ درصد یا بیشتر باشه رو در یک گروه یا خوشه قرار می‌دیم.

این کار به ما کمک می‌کنه کلمات کلیدی مرتبط رو کنار هم داشته باشیم و بتونیم برای هر خوشه، محتوای بهتری تولید کنیم که به رشد سایت در نتایج گوگل کمک زیادی می‌کنه.

کپی کد

حالا ما اسم احتمالی موضوع، شباهت نتایج جستجوی کلمات کلیدی (keywords SERP similarity) و حجم جستجوی هر کدوم رو داریم.

توجه کن که ستون‌های keyword و keyword_b به ترتیب به topic و keyword تغییر نام دادن.

حالا قراره روی ستون‌های دیتافریم با استفاده از تکنیک lambda تکرار (iterate) کنیم.

تکنیک lambda یک روش بهینه و سریع برای تکرار روی ردیف‌های دیتافریم پانداس (Pandas) هست، چون برخلاف تابع معمول .iterrows()، ردیف‌ها رو به لیست تبدیل می‌کنه و این باعث افزایش سرعت اجرای کد میشه.

خب، بریم سراغ کد:

کپی کد

queries_in_df = list(set(matched_serps['keyword'].to_list()))
topic_groups = {}

def dict_key(dicto, keyo):
    return keyo in dicto

def dict_values(dicto, vala):
    return any(vala in val for val in dicto.values())

def what_key(dicto, vala):
    for k, v in dicto.items():
            if vala in v:
                return k

def find_topics(si, keyw, topc):
    if (si >= simi_lim):

if (not dict_key(sim_topic_groups, keyw)) and (not dict_key(sim_topic_groups, topc)):

if (not dict_values(sim_topic_groups, keyw)) and (not dict_values(sim_topic_groups, topc)): 
                sim_topic_groups[keyw] = [keyw] 
                sim_topic_groups[keyw] = [topc] 
                if dict_key(non_sim_topic_groups, keyw):
                    non_sim_topic_groups.pop(keyw)
                if dict_key(non_sim_topic_groups, topc): 
                    non_sim_topic_groups.pop(topc)
            if (dict_values(sim_topic_groups, keyw)) and (not dict_values(sim_topic_groups, topc)): 
                d_key = what_key(sim_topic_groups, keyw)
                sim_topic_groups[d_key].append(topc)
                if dict_key(non_sim_topic_groups, keyw):
                    non_sim_topic_groups.pop(keyw)
                if dict_key(non_sim_topic_groups, topc): 
                    non_sim_topic_groups.pop(topc)
            if (not dict_values(sim_topic_groups, keyw)) and (dict_values(sim_topic_groups, topc)): 
                d_key = what_key(sim_topic_groups, topc)
                sim_topic_groups[d_key].append(keyw)
                if dict_key(non_sim_topic_groups, keyw):
                    non_sim_topic_groups.pop(keyw)
                if dict_key(non_sim_topic_groups, topc): 
                    non_sim_topic_groups.pop(topc)

elif (keyw in sim_topic_groups) and (not topc in sim_topic_groups): 
            sim_topic_groups[keyw].append(topc)
            sim_topic_groups[keyw].append(keyw)
            if keyw in non_sim_topic_groups:
                non_sim_topic_groups.pop(keyw)
            if topc in non_sim_topic_groups: 
                non_sim_topic_groups.pop(topc)
        elif (not keyw in sim_topic_groups) and (topc in sim_topic_groups):
            sim_topic_groups[topc].append(keyw)
            sim_topic_groups[topc].append(topc)
            if keyw in non_sim_topic_groups:
                non_sim_topic_groups.pop(keyw)
            if topc in non_sim_topic_groups: 
                non_sim_topic_groups.pop(topc)
        elif (keyw in sim_topic_groups) and (topc in sim_topic_groups):
            if len(sim_topic_groups[keyw]) > len(sim_topic_groups[topc]):
                sim_topic_groups[keyw].append(topc) 
                [sim_topic_groups[keyw].append(x) for x in sim_topic_groups.get(topc)] 
                sim_topic_groups.pop(topc)

elif len(sim_topic_groups[keyw]) < len(sim_topic_groups[topc]):
            sim_topic_groups[topc].append(keyw) 
            [sim_topic_groups[topc].append(x) for x in sim_topic_groups.get(keyw)]
            sim_topic_groups.pop(keyw) 
        elif len(sim_topic_groups[keyw]) == len(sim_topic_groups[topc]):
            if sim_topic_groups[keyw] == topc and sim_topic_groups[topc] == keyw:
            sim_topic_groups.pop(keyw)

elif si < simi_lim:
  
        if (not dict_key(non_sim_topic_groups, keyw)) and (not dict_key(sim_topic_groups, keyw)) and (not dict_values(sim_topic_groups,keyw)): 
            non_sim_topic_groups[keyw] = [keyw]
        if (not dict_key(non_sim_topic_groups, topc)) and (not dict_key(sim_topic_groups, topc)) and (not dict_values(sim_topic_groups,topc)): 
            non_sim_topic_groups[topc] = [topc]

در ادامه، یک دیکشنری (فرمت داده‌ای) می‌بینیم که تمام کلمات کلیدی رو بر اساس نیت جستجو (Search Intent) به گروه‌های شماره‌دار تقسیم کرده.

کپی کد

حالا این داده‌ها رو داخل یک دیتافریم (DataFrame) قرار می‌دیم.

کپی کد

گروه‌های نیت جستجو که بالا دیدیم، تقریب خوبی از کلمات کلیدی داخل هر گروه نشون میدن — چیزی که یک کارشناس حرفه‌ای سئو معمولاً بهش می‌رسه.

هرچند ما فقط از یه مجموعه کوچک از کلمات کلیدی استفاده کردیم، اما این روش به راحتی می‌تونه برای هزاران کلمه کلیدی (یا حتی بیشتر) گسترش پیدا کنه.

فعال‌سازی خروجی‌ها برای بهبود جستجوی شما

البته، این کار می‌تونه خیلی فراتر بره و با استفاده از شبکه‌های عصبی (Neural Networks)، محتوای رتبه‌بندی شده رو تحلیل کنه تا خوشه‌ها و اسم‌های گروه‌ها دقیق‌تر ساخته بشن؛ مثل بعضی محصولات تجاری که الان این کار رو انجام میدن.

اما فعلاً با همین خروجی‌ها می‌تونید:

این روش رو وارد سیستم‌های داشبورد سئو خودتون کنید تا روندها و گزارش‌های سئو براتون معنی‌دارتر بشه.
کمپین‌های تبلیغات پولی‌تون رو بهتر بسازید، مثلا حساب‌های گوگل ادز رو بر اساس نیت جستجو سازماندهی کنید تا کیفیت تبلیغات (Quality Score) بالاتر بره.
آدرس‌های تکراری جستجوی فروشگاه‌های اینترنتی (facet URLs) رو با هم ادغام کنید.
ساختار طبقه‌بندی سایت‌های فروشگاهی رو بر اساس نیت جستجو بچینید، نه مثل یک کاتالوگ معمولی محصولات.

مطمئنم کاربردهای بیشتری هم وجود داره که من اشاره نکردم — اگر به ذهنتون اومد خوشحال میشم توی کامنت‌ها بگید.

در هر صورت، تحقیقات کلمات کلیدی سئوی شما حالا دقیق‌تر، قابل گسترش‌تر و سریع‌تر شده!

کد کامل رو می‌تونید برای استفاده خودتون از اینجا دانلود کنید.

کد نهایی و مناسب شده برای عبارات فارسی به صورت کامل :

کپی کد

import pandas as pd
import numpy as np

# چون فایل Excel هست، باید از read_excel استفاده کنیم
serps_input = pd.read_excel('/content/Untitled Report_Untitled Page_Table.xlsx')
display(serps_input)

# ادامه کد بدون تغییر
serps_grpby_keyword = serps_input.groupby("keyword")
k_urls = 15

def filter_k_urls(group_df):
    filtered_df = group_df.loc[group_df['url'].notnull()]
    filtered_df = filtered_df.loc[filtered_df['rank'] <= k_urls]
    return filtered_df

filtered_serps = serps_grpby_keyword.apply(filter_k_urls)

filtered_serps_df = pd.concat([filtered_serps], axis=0)
del filtered_serps_df['keyword']
filtered_serps_df = filtered_serps_df.reset_index()
del filtered_serps_df['level_1']

filtserps_grpby_keyword = filtered_serps_df.groupby("keyword")

def string_serps(df):
    df['serp_string'] = ''.join(df['url'])
    return df

strung_serps = filtserps_grpby_keyword.apply(string_serps)

strung_serps = pd.concat([strung_serps], axis=0)
strung_serps = strung_serps[['keyword', 'serp_string']]
strung_serps = strung_serps.drop_duplicates()

def serps_align(k, df):
    prime_df = df.loc[df.keyword == k]
    prime_df = prime_df.rename(columns={"serp_string": "serp_string_a", 'keyword': 'keyword_a'})
    comp_df = df.loc[df.keyword != k].reset_index(drop=True)
    prime_df = prime_df.loc[prime_df.index.repeat(len(comp_df.index))].reset_index(drop=True)
    prime_df = pd.concat([prime_df, comp_df], axis=1)
    prime_df = prime_df.rename(columns={"serp_string": "serp_string_b", 'keyword': 'keyword_b', 
                                        "serp_string_a": "serp_string", 'keyword_a': 'keyword'})
    return prime_df

columns = ['keyword', 'serp_string', 'keyword_b', 'serp_string_b']
matched_serps = pd.DataFrame(columns=columns).fillna(0)
queries = strung_serps.keyword.to_list()

for q in queries:
    temp_df = serps_align(q, strung_serps)
    matched_serps = pd.concat([matched_serps, temp_df], ignore_index=True)

import py_stringmatching as sm
ws_tok = sm.WhitespaceTokenizer()

def serps_similarity(serps_str1, serps_str2, k=15):
    denom = k+1
    norm = sum([2*(1/i - 1.0/(denom)) for i in range(1, denom)])

serps_1 = ws_tok.tokenize(serps_str1)[:k]
    serps_2 = ws_tok.tokenize(serps_str2)[:k]

match = lambda a, b: [b.index(x)+1 if x in b else None for x in a]

pos_intersections = [(i+1,j) for i,j in enumerate(match(serps_1, serps_2)) if j is not None] 
    pos_in1_not_in2 = [i+1 for i,j in enumerate(match(serps_1, serps_2)) if j is None]
    pos_in2_not_in1 = [i+1 for i,j in enumerate(match(serps_2, serps_1)) if j is None]
    a_sum = sum([abs(1/i -1/j) for i,j in pos_intersections])
    b_sum = sum([abs(1/i -1/denom) for i in pos_in1_not_in2])
    c_sum = sum([abs(1/i -1/denom) for i in pos_in2_not_in1])

intent_prime = a_sum + b_sum + c_sum
    intent_dist = 1 - (intent_prime/norm)
    return intent_dist

matched_serps['si_simi'] = matched_serps.apply(lambda x: serps_similarity(x.serp_string, x.serp_string_b), axis=1)
serps_compared = matched_serps[['keyword', 'keyword_b', 'si_simi']]

simi_lim = 0.5
keysv_df = serps_input[['keyword', 'search_volume']].drop_duplicates()

keywords_crossed_vols = serps_compared.merge(keysv_df, on='keyword', how='left')
keywords_crossed_vols = keywords_crossed_vols.rename(columns={'keyword': 'topic', 'keyword_b': 'keyword', 
                                                              'search_volume': 'topic_volume'})

keywords_crossed_vols.sort_values('topic_volume', ascending=False, inplace=True)

keywords_filtered_nonnan = keywords_crossed_vols.dropna()

queries_in_df = list(set(matched_serps['keyword'].to_list()))
topic_groups = {}

# توابع کمکی...

topic_groups_lst = []
for k, l in topic_groups.items():
    for v in l:
        topic_groups_lst.append([k, v])

topic_groups_dictdf = pd.DataFrame(topic_groups_lst, columns=['topic_group_no', 'keyword'])
display(topic_groups_dictdf)

ترجمه : How To Automate SEO Keyword Clustering By Search Intent With Python