Nota de l’editor: A mesura que s’acaba el 2021, estem celebrant amb un compte enrere dels 12 dies de Nadal dels articles d’experts més populars i útils del Search Engine Journal d’aquest any.
Aquesta col·lecció va ser seleccionada pel nostre equip editorial en funció del rendiment, la utilitat, la qualitat i el valor creat per a cada article, els nostres lectors.
Cada dia fins al 24 de desembre, tornarem a publicar una de les millors columnes de l’any, començant pel número 12 i fent el compte enrere fins al número 1. Avui és el número 11, publicat originalment el 28 de juliol de 2021.
Andreas Voniatis va fer un treball fantàstic explicant com crear grups de paraules clau per intenció de cerca amb Python. Les imatges i les captures de pantalla fan que sigui fàcil de seguir pas a pas, de manera que fins i tot l’usuari de Python més principiant pot seguir. Molt bé, Andreas!
Anunci
Continueu llegint a continuació
Gràcies per contribuir a Search Engine Journal i compartir la vostra saviesa amb els lectors.
Gaudiu tots!
Hi ha molt a saber sobre la intenció de cerca, de l’ús aprenentatge profund per inferir la intenció de cerca classificant el text i desglossar els títols SERP mitjançant el processament del llenguatge natural (NLP) tècniques, a agrupació basada en la rellevància semàntica amb els beneficis explicats.
No només coneixem els avantatges de desxifrar la intenció de cerca, sinó que també tenim diverses tècniques a la nostra disposició per a l’escala i l’automatització.
Però sovint, això implica construir la teva pròpia IA. Què passa si no tens temps ni coneixements per a això?
Anunci
Continueu llegint a continuació
En aquesta columna, aprendràs un procés pas a pas per automatitzar l’agrupació de paraules clau per intenció de cerca amb Python.
Les SERP contenen estadístiques per a la intenció de cerca
Alguns mètodes requereixen que obtingueu tota la còpia dels títols del contingut de la classificació per a una paraula clau determinada i, a continuació, l’introduïu en un model de xarxa neuronal (que després haureu de crear i provar), o potser utilitzeu PNL per agrupar paraules clau. .
Hi ha un altre mètode que us permet utilitzar la pròpia IA de Google per fer la feina per vosaltres, sense haver de raspar tot el contingut de SERP i crear un model d’IA.
Suposem que Google classifica els URL dels llocs segons la probabilitat que el contingut satisfaci la consulta de l’usuari en ordre descendent. Es dedueix que si la intenció de dues paraules clau és la mateixa, és probable que les SERP siguin similars.
Durant anys, molts professionals del SEO van comparar els resultats de SERP paraules clau per inferir la intenció de cerca compartida (o compartida) per mantenir-se al capdavant de les actualitzacions bàsiques, de manera que això no és cap novetat.
El valor afegit aquí és l’automatització i l’escala d’aquesta comparació, que ofereix tant velocitat com una major precisió.
Com agrupar paraules clau per intenció de cerca a escala mitjançant Python (amb codi)
Comenceu amb els resultats de les SERP en una descàrrega CSV.
Anunci
Continueu llegint a continuació
1. Importeu la llista al vostre quadern Python.
import pandas as pd
import numpy as np
serps_input = pd.read_csv('data/sej_serps_input.csv')
serps_inputA continuació es mostra el fitxer SERPs ara importat a un marc de dades de Pandas.
2. Filtra les dades de la pàgina 1
Volem comparar els resultats de la pàgina 1 de cada SERP entre paraules clau.
Anunci
Continueu llegint a continuació
Dividirem el marc de dades en marcs de dades de mini paraules clau per executar la funció de filtrat abans de recombinar-lo en un únic marc de dades, perquè volem filtrar a nivell de paraula clau:
# Split
serps_grpby_keyword = serps_input.groupby("keyword")
k_urls = 15
# Apply Combine
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)
# Combine
## Add prefix to column names
#normed = normed.add_prefix('normed_')
# Concatenate with initial data frame
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']
filtered_serps_df
3. Converteix URL de classificació en una cadena
Com que hi ha més URL de resultats SERP que paraules clau, hem de comprimir aquests URL en una sola línia per representar la SERP de la paraula clau.
Així és com:
# convert results to strings using Split Apply Combine
filtserps_grpby_keyword = filtered_serps_df.groupby("keyword")
def string_serps(df):
df['serp_string'] = ''.join(df['url'])
return df
# Combine
strung_serps = filtserps_grpby_keyword.apply(string_serps)
# Concatenate with initial data frame and clean
strung_serps = pd.concat([strung_serps],axis=0)
strung_serps = strung_serps[['keyword', 'serp_string']]#.head(30)
strung_serps = strung_serps.drop_duplicates()
strung_serpsA continuació es mostra la SERP comprimida en una sola línia per a cada paraula clau.
4. Compara la semblança de SERP
Per realitzar la comparació, ara necessitem totes les combinacions de paraules clau SERP emparellades amb altres parells:
Anunci
Continueu llegint a continuació
# align serps
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)
matched_serps = matched_serps.fillna(0)
queries = strung_serps.keyword.to_list()
for q in queries:
temp_df = serps_align(q, strung_serps)
matched_serps = matched_serps.append(temp_df)
matched_serps
L’anterior mostra totes les combinacions de parelles SERP de paraules clau, de manera que es prepara per a la comparació de cadenes SERP.
No hi ha cap biblioteca de codi obert que compare els objectes de llista per ordre, de manera que la funció s’ha escrit a continuació.
Anunci
Continueu llegint a continuació
La funció ‘serp_compare’ compara la superposició de llocs i l’ordre d’aquests llocs entre 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)])
ws_tok = sm.WhitespaceTokenizer()
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
# Apply the function
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']]
serps_compared
Ara que s’han executat les comparacions, podem començar a agrupar les paraules clau.
Anunci
Continueu llegint a continuació
Tractarem les paraules clau que tinguin una similitud ponderada del 40% o més.
# group keywords by search intent
simi_lim = 0.4
# join search volume
keysv_df = serps_input[['keyword', 'search_volume']].drop_duplicates()
keysv_df.head()
# append topic vols
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'})
# sim si_simi
keywords_crossed_vols.sort_values('topic_volume', ascending = False)
# strip NANs
keywords_filtered_nonnan = keywords_crossed_vols.dropna()
keywords_filtered_nonnanAra tenim el nom del tema potencial, la similitud de les paraules clau SERP i els volums de cerca de cadascun.
Tingueu en compte que la paraula clau i la paraula clau_b s’han canviat de nom a tema i paraula clau, respectivament.
Anunci
Continueu llegint a continuació
Ara repetirem les columnes del marc de dades mitjançant la tècnica lamdas.
La tècnica lamdas és una manera eficient d’iterar sobre files en un marc de dades de Pandas perquè converteix les files en una llista en lloc de la funció .iterrows().
Aquí va:
queries_in_df = list(set(keywords_filtered_nonnan.topic.to_list()))
topic_groups_numbered = {}
topics_added = []
def find_topics(si, keyw, topc):
i = 0
if (si >= simi_lim) and (not keyw in topics_added) and (not topc in topics_added):
i += 1
topics_added.append(keyw)
topics_added.append(topc)
topic_groups_numbered[i] = [keyw, topc]
elif si >= simi_lim and (keyw in topics_added) and (not topc in topics_added):
j = [key for key, value in topic_groups_numbered.items() if keyw in value]
topics_added.append(topc)
topic_groups_numbered[j[0]].append(topc)
elif si >= simi_lim and (not keyw in topics_added) and (topc in topics_added):
j = [key for key, value in topic_groups_numbered.items() if topc in value]
topics_added.append(keyw)
topic_groups_numbered[j[0]].append(keyw)
def apply_impl_ft(df):
return df.apply(
lambda row:
find_topics(row.si_simi, row.keyword, row.topic), axis=1)
apply_impl_ft(keywords_filtered_nonnan)
topic_groups_numbered = {k:list(set(v)) for k, v in topic_groups_numbered.items()}
topic_groups_numberedA continuació es mostra un diccionari que conté totes les paraules clau agrupades per intenció de cerca en grups numerats:
{1: ['fixed rate isa',
'isa rates',
'isa interest rates',
'best isa rates',
'cash isa',
'cash isa rates'],
2: ['child savings account', 'kids savings account'],
3: ['savings account',
'savings account interest rate',
'savings rates',
'fixed rate savings',
'easy access savings',
'fixed rate bonds',
'online savings account',
'easy access savings account',
'savings accounts uk'],
4: ['isa account', 'isa', 'isa savings']}Fixem-ho en un marc de dades:
topic_groups_lst = []
for k, l in topic_groups_numbered.items():
for v in l:
topic_groups_lst.append([k, v])
topic_groups_dictdf = pd.DataFrame(topic_groups_lst, columns=['topic_group_no', 'keyword'])
topic_groups_dictdf
Els grups d’intencions de cerca anteriors mostren una bona aproximació de les paraules clau dins d’ells, cosa que probablement aconseguiria un expert en SEO.
Anunci
Continueu llegint a continuació
Tot i que només hem utilitzat un petit conjunt de paraules clau, el mètode òbviament es pot escalar a milers (si no més).
Activació de les sortides per millorar la vostra cerca
Per descomptat, l’anterior es podria fer més enllà mitjançant xarxes neuronals que processen el contingut de la classificació per a clústers i denominacions de grups de clústers més precises, com ja ho fan alguns dels productes comercials que hi ha.
De moment, amb aquesta sortida podeu:
- Incorporeu-ho als vostres propis sistemes de taulers de SEO per crear les vostres tendències i Informes de SEO més significatiu.
- Construeix millor campanyes de cerca de pagament estructurant els vostres comptes de Google Ads segons la intenció de cerca per obtenir un nivell de qualitat més alt.
- Combina URL de cerca de comerç electrònic amb facetes redundants.
- Estructureu la taxonomia d’un lloc de compres segons la intenció de cerca en lloc d’un catàleg de productes típic.
Anunci
Continueu llegint a continuació
Estic segur que hi ha més aplicacions que no he esmentat; no dubteu a comentar-ne les importants que encara no he esmentat.
En qualsevol cas, la vostra recerca de paraules clau de SEO acaba de ser una mica més escalable, precisa i ràpida!
Compte enrere de Nadal SEJ 2021:
Imatge destacada: Astibuag/Shutterstock.com
Anunci
Continueu llegint a continuació
