A proliferação de modelos de linguagem em massa produziu um efeito colateral visível na primeira página do Google, a homogeneização da SERP. Quando dez sites concorrentes utilizam as mesmas bases de dados, prompts semelhantes e ferramentas de redação que apenas sintetizam os dez primeiros colocados, o resultado é uma cópia semântica generalizada. Todos os artigos respondem às mesmas perguntas com as mesmas entidades, a mesma ordem lógica e o mesmo nível de profundidade.
Para o usuário, essa experiência gera atrito. Ao clicar no primeiro resultado e encontrar uma resposta genérica, ele retorna à busca e abre o segundo e o terceiro links. Se esses links subsequentes repetem exatamente o que o primeiro já explicou, a utilidade marginal da navegação cai para zero.
O Google antecipou esse problema na patente US 10,698,964 B2, intitulada “Contextual estimation of information gain and ranking of documents based thereon”. O mecanismo descreve como o sistema de busca atribui uma pontuação de ganho de informação a cada documento candidato com base no que o usuário já consumiu em sua jornada de pesquisa.
Neste guia técnico, você entenderá a fundamentação matemática dessa patente, como a teoria da informação de Claude Shannon explica a novidade de conteúdo e como construir um pipeline em Python para auditar páginas concorrentes da SERP, calculando entropia de texto e distância vetorial residual.
A patente de Information Gain do Google: mecanismo e reclassificação dinâmica
A patente US 10,698,964 B2, concedida em junho de 2020 aos pesquisadores do Google, introduz uma mudança estrutural na forma como documentos são ordenados. Tradicionalmente, algoritmos de recuperação da informação avaliam a relevância de um documento de forma estática em relação a uma consulta isolada. O modelo clássico assume que a melhor página para a consulta $Q$ deve ser exibida na posição 1, a segunda melhor na posição 2, e assim sucessivamente.
O modelo de Information Gain quebra essa premissa estática ao modelar o estado de conhecimento do usuário durante a sessão.
[Consulta do Usuário]
│
▼
[Documento D1 Lido pelo Usuário] ──► Estado de Conhecimento: S = {Fatos de D1}
│
├──────────────────────────────────────────────┐
▼ ▼
[Candidato D2: Repete fatos de D1] [Candidato D3: Novos fatos, dados e ângulos]
│ │
Information Gain ≈ 0 Information Gain > 0
(Rebaixado na reclassificação) (Promovido na SERP da sessão)O fluxo patenteado funciona em quatro etapas operacionais:
- O usuário submete uma consulta e o motor retorna um conjunto de páginas ranqueadas por relevância inicial.
- O usuário clica e consome o primeiro resultado $D_1$. O sistema registra o conjunto de informações, entidades e afirmações contidas em $D_1$.
- Para os resultados restantes da lista ($D_2, D_3, \dots, D_n$), o algoritmo calcula uma pontuação de ganho de informação marginal. A pontuação quantifica quanto conteúdo adicional, não redundante e factual aquele documento oferece em relação ao que já foi visualizado em $D_1$.
- A lista de classificação é reordenada dinamicamente para o usuário. Páginas que apenas repetem os dados de $D_1$ recebem pontuação próxima de zero e caem de posição. Páginas com novos dados, abordagens divergentes ou dados primários sobem.
Essa mecânica atua em conjunto com sinais de engajamento do usuário. Conforme demonstrado nos dados de vazamento do sistema de classificação e discutido na análise sobre Google NavBoost e SEO, o comportamento de navegação pós-clique valida se o usuário encontrou satisfação ou se precisou retornar à SERP para encontrar a informação que faltava no primeiro clique. Se um artigo subsequente encerra a sessão com sucesso, esse documento acumula sinais de ganho de informação positivo.
Teoria da informação aplicada ao SEO: entropia de Shannon e novidade semântica
Para mensurar o ganho de informação de forma programática, é necessário recorrer aos fundamentos da teoria matemática da comunicação formulada por Claude Shannon em 1948.
Entropia de Shannon
A entropia mede o grau de incerteza ou a quantidade média de informação contida em uma variável aleatória. No processamento de linguagem natural, podemos tratar um documento como uma sequência de termos ou símbolos retirados de um vocabulário.
A fórmula da entropia de Shannon para uma distribuição de probabilidade de palavras é:
$$H(X) = -\sum_{i=1}^{n} P(x_i) \log_2 P(x_i)$$
Em que:
- $n$ representa o número de palavras únicas no vocabulário do texto.
- $P(x_i)$ é a probabilidade empírica da ocorrência da palavra $x_i$, calculada pela sua frequência relativa no documento.
- $\log_2 P(x_i)$ calcula a quantidade de informação associada ao termo.
Textos pobres, com alta densidade de palavras-chave repetidas e estruturas sintáticas engessadas, apresentam baixa entropia de Shannon. As palavras são altamente previsíveis. Textos ricos, que empregam vocabulário técnico variado, entidades correlacionadas e dados numéricos específicos, apresentam maior entropia.
Contudo, a entropia isolada não garante qualidade. Uma sequência aleatória de palavras sem sentido possui entropia altíssima, mas nenhuma utilidade semântica. O ganho de informação real reside na interseção entre relevância contextual e novidade condicional.
Ganho de informação condicional
Na recuperação de informação, o ganho de informação de um novo documento $D$ em relação a um conjunto já conhecido de documentos da SERP $S$ pode ser modelado formalmente pela redução de incerteza sobre o tópico $T$:
$$IG(D | S) = H(T | S) - H(T | S \cup {D})$$
Se o documento $D$ não introduz nenhuma entidade, atributo ou afirmação ausente em $S$, $H(T | S \cup {D}) = H(T | S)$, resultando em $IG(D | S) = 0$.
Para operacionalizar esse conceito em código sem exigir modelos proprietários do Google, dividimos a métrica em duas camadas complementares:
- Divergência lexical e de n-gramas: a proporção de termos e entidades substantivas presentes no documento que não aparecem no consenso da SERP.
- Resíduo vetorial semântico: a projeção ortogonal do embedding do artigo em relação ao subespaço vetorial ocupado pelos concorrentes ranqueados.
Essa abordagem se alinha às necessidades de rastreamento de citações no Google AI Overviews, em que sistemas generativos priorizam fontes que oferecem dados complementares para sintetizar respostas multifacetadas.
Arquitetura do pipeline em Python para auditoria de SERP
O pipeline de análise deve receber uma palavra-chave, extrair o texto limpo das principais URLs ranqueadas, consolidar o corpus da SERP e calcular métricas comparativas contra o artigo que você planeja publicar ou atualizar.
┌──────────────────────────────┐
│ URLs dos Concorrentes (SERP) │
└──────────────┬───────────────┘
│
▼
┌──────────────────────────────┐
│ Extração de Texto Limpo │
│ (Remoção de Boilerplate) │
└──────────────┬───────────────┘
│
▼
┌──────────────────────────────┐
│ Corpus de Consenso da SERP │
└──────────────┬───────────────┘
│
┌───────────────────────┴───────────────────────┐
▼ ▼
┌─────────────────────────────┐ ┌─────────────────────────────┐
│ Análise Léxica & Entropia │ │ Embeddings de Sentenças │
│ - Shannon Entropy │ │ - Similaridade de Cosseno │
│ - Jaccard Novelty (N-grams) │ │ - Resíduo Vetorial │
└──────────────┬──────────────┘ └──────────────┬──────────────┘
│ │
└───────────────────────┬───────────────┘
▼
┌──────────────────────────────┐
│ Information Gain Score Final │
└──────────────────────────────┘O pipeline opera em quatro módulos:
- Extração do conteúdo principal das páginas, descartando menus, cabeçalhos, rodapés e caixas de comentários.
- Pré-processamento e normalização linguística em português, aplicando remoção de stopwords e tokenização estruturada.
- Cálculo de distribuição de frequência, entropia de Shannon e cobertura de termos exclusivos.
- Vetorização densa com cálculo de similaridade e resíduo semântico para quantificar o ângulo de novidade do conteúdo.
Código completo em Python: calculando entropia e ganho de informação
O script a seguir foi estruturado para execução limpa com bibliotecas consagradas de análise de dados e machine learning. Instale os requisitos prévios no terminal antes da execução:
pip install requests beautifulsoup4 numpy scikit-learnAbaixo está o script completo para mensurar a entropia individual e o Information Gain relativo do seu texto contra os concorrentes:
import math
import re
from collections import Counter
from typing import Dict, List, Set, Tuple
import numpy as np
from bs4 import BeautifulSoup
import requests
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
class InformationGainAuditor:
def __init__(self, stopwords_pt: Set[str] = None):
if stopwords_pt is None:
self.stopwords = {
"de", "a", "o", "que", "e", "do", "da", "em", "um", "para",
"e", "com", "nao", "uma", "os", "no", "se", "na", "por",
"mais", "as", "dos", "como", "mas", "ao", "ele", "das",
"seu", "sua", "ou", "quando", "muito", "nos", "ja", "eu",
"tambem", "so", "pelo", "pela", "ate", "isso", "ela", "entre",
"depois", "sem", "mesmo", "aos", "seus", "quem", "nas", "me",
"esse", "eles", "voce", "essa", "num", "nem", "suas", "meu",
"as", "minha", "numa", "pelos", "elas", "qual", "nos", "lhe",
"deles", "essas", "esses", "pelas", "este", "dele", "tu",
"te", "voces", "vos", "lhes", "meus", "minhas", "teu", "tua"
}
else:
self.stopwords = stopwords_pt
def clean_html(self, html_content: str) -> str:
soup = BeautifulSoup(html_content, "html.parser")
for tag in soup(["script", "style", "nav", "footer", "header", "aside", "noscript"]):
tag.decompose()
text = soup.get_text(separator=" ")
return self._normalize_text(text)
def _normalize_text(self, text: str) -> str:
text = text.lower()
text = re.sub(r"[^\w\s]", " ", text, flags=re.UNICODE)
text = re.sub(r"\s+", " ", text).strip()
return text
def tokenize(self, text: str) -> List[str]:
tokens = text.split()
return [t for t in tokens if t not in self.stopwords and len(t) > 2]
def extract_ngrams(self, tokens: List[str], n: int = 2) -> List[str]:
return [" ".join(tokens[i:i + n]) for i in range(len(tokens) - n + 1)]
def calculate_shannon_entropy(self, tokens: List[str]) -> float:
if not tokens:
return 0.0
total_tokens = len(tokens)
counts = Counter(tokens)
entropy = 0.0
for count in counts.values():
prob = count / total_tokens
entropy -= prob * math.log2(prob)
return float(entropy)
def calculate_lexical_novelty(
self,
target_tokens: List[str],
competitor_corpus_tokens: List[str],
ngram_size: int = 2
) -> Dict[str, float]:
target_unigrams = set(target_tokens)
comp_unigrams = set(competitor_corpus_tokens)
unique_unigrams = target_unigrams - comp_unigrams
unigram_novelty = len(unique_unigrams) / max(len(target_unigrams), 1)
target_bigrams = set(self.extract_ngrams(target_tokens, ngram_size))
comp_bigrams = set(self.extract_ngrams(competitor_corpus_tokens, ngram_size))
unique_bigrams = target_bigrams - comp_bigrams
bigram_novelty = len(unique_bigrams) / max(len(target_bigrams), 1)
return {
"unigram_novelty_rate": float(unigram_novelty),
"bigram_novelty_rate": float(bigram_novelty),
"total_unique_unigrams": len(unique_unigrams),
"total_unique_bigrams": len(unique_bigrams),
}
def calculate_semantic_residual(
self,
target_text: str,
competitor_texts: List[str]
) -> Tuple[float, float]:
all_docs = competitor_texts + [target_text]
vectorizer = TfidfVectorizer(
stop_words=list(self.stopwords),
max_features=2500,
ngram_range=(1, 2)
)
tfidf_matrix = vectorizer.fit_transform(all_docs).toarray()
competitor_vectors = tfidf_matrix[:-1]
target_vector = tfidf_matrix[-1].reshape(1, -1)
centroid = np.mean(competitor_vectors, axis=0).reshape(1, -1)
similarity_to_consensus = float(cosine_similarity(target_vector, centroid)[0][0])
norm_target = np.linalg.norm(target_vector)
norm_centroid = np.linalg.norm(centroid)
if norm_centroid > 0 and norm_target > 0:
projection = (np.dot(target_vector, centroid.T) / (norm_centroid ** 2)) * centroid
residual_vector = target_vector - projection
residual_magnitude = float(np.linalg.norm(residual_vector) / norm_target)
else:
residual_magnitude = 0.0
return similarity_to_consensus, residual_magnitude
def evaluate_information_gain(
self,
target_text: str,
competitor_texts: List[str]
) -> Dict[str, float]:
target_clean = self._normalize_text(target_text)
comp_clean = [self._normalize_text(t) for t in competitor_texts]
target_tokens = self.tokenize(target_clean)
comp_tokens = []
for doc in comp_clean:
comp_tokens.extend(self.tokenize(doc))
target_entropy = self.calculate_shannon_entropy(target_tokens)
comp_entropies = [
self.calculate_shannon_entropy(self.tokenize(doc))
for doc in comp_clean
]
avg_comp_entropy = float(np.mean(comp_entropies)) if comp_entropies else 0.0
lexical_metrics = self.calculate_lexical_novelty(target_tokens, comp_tokens)
similarity, residual = self.calculate_semantic_residual(target_clean, comp_clean)
entropy_advantage = max(0.0, target_entropy - avg_comp_entropy)
information_gain_score = (
(0.35 * lexical_metrics["bigram_novelty_rate"]) +
(0.40 * residual) +
(0.25 * min(1.0, entropy_advantage / 2.0))
) * 100.0
return {
"target_entropy": round(target_entropy, 3),
"avg_competitor_entropy": round(avg_comp_entropy, 3),
"unigram_novelty_rate": round(lexical_metrics["unigram_novelty_rate"], 3),
"bigram_novelty_rate": round(lexical_metrics["bigram_novelty_rate"], 3),
"similarity_to_consensus": round(similarity, 3),
"semantic_residual_novelty": round(residual, 3),
"information_gain_score": round(information_gain_score, 2),
}Simulação prática com dados de teste
O código a seguir simula a comparação entre três concorrentes típicos que repetem o senso comum da SERP e dois cenários para o seu artigo, um genérico e outro baseado em dados primários e metodologia prática:
if __name__ == "__main__":
competitor_1 = (
"O que e SEO tecnico. SEO tecnico e a otimizacao de sites para os motores de busca. "
"Voce deve melhorar a velocidade do site, usar tags canonicas corretas e criar um sitemap XML. "
"A velocidade e importante para o Google e melhora a experiencia do usuario no mobile."
)
competitor_2 = (
"Guia basico de SEO tecnico. Para ranquear no Google voce precisa de sitemap XML, robots txt "
"e velocidade de carregamento. As tags canonicas evitam conteudo duplicado e organizam a indexacao. "
"Monitore seus erros no Google Search Console sempre."
)
competitor_3 = (
"SEO tecnico para iniciantes. Melhore a velocidade das paginas, configure o arquivo robots txt "
"e envie seu sitemap XML para o Search Console. Assegure que as tags canonicas estejam apontando "
"para as URLs corretas para evitar problemas de duplicidade."
)
artigo_generico = (
"Aprenda SEO tecnico agora. O SEO tecnico otimiza sitemap XML, robots txt e velocidade. "
"Configure tags canonicas para nao ter duplicidade e acompanhe tudo pelo Search Console."
)
artigo_diferenciado = (
"Auditoria de entropia e ganho de informacao no SEO tecnico. Alem de sitemaps XML e canonical tags, "
"analisamos o log do servidor para verificar status 304 Not Modified e a taxa de renderizacao do "
"Googlebot via Puppeteer. Demonstramos testes A B de templates usando causalimpact com controle sintetico, "
"reduzindo o desperdicio de crawl budget em arquiteturas headless e e commerces facetados."
)
auditor = InformationGainAuditor()
concorrentes = [competitor_1, competitor_2, competitor_3]
print("--- Cenário 1: Artigo Genérico (Repete a Média da SERP) ---")
resultado_generico = auditor.evaluate_information_gain(artigo_generico, concorrentes)
for chave, valor in resultado_generico.items():
print(f"{chave}: {valor}")
print("\n--- Cenário 2: Artigo com Alto Information Gain ---")
resultado_diferenciado = auditor.evaluate_information_gain(artigo_diferenciado, concorrentes)
for chave, valor in resultado_diferenciado.items():
print(f"{chave}: {valor}")Ao rodar esse bloco, observe as diferenças de saída:
- No artigo genérico, a taxa de novidade de bigramas fica próxima de zero e o resíduo semântico é baixo, produzindo um
information_gain_scoreinferior a 25. - No artigo diferenciado, a introdução de conceitos avançados, termos específicos e metodologia empírica eleva tanto a entropia quanto a distância residual, levando o
information_gain_scorepara acima de 70.
Como interpretar as métricas de novidade contra a SERP
A análise numérica fornece um diagnóstico objetivo para decidir se uma página está pronta para publicação ou se necessita de reformulação editorial.
| Métrica | Faixa Alerta | Faixa Ideal | Ação Corretiva |
|---|---|---|---|
| Entropia de Shannon | < 4.5 bits/token | > 6.0 bits/token | Diversificar vocabulário, incluir terminologia técnica precisa e dados empíricos. |
| Similaridade com Consenso | > 0.92 | 0.65 a 0.82 | O texto está replicando o formato padrão dos concorrentes sem acrescentar novos tópicos. |
| Resíduo Semântico | < 0.25 | > 0.45 | Adicionar seções com ângulos não abordados, dados primários e exemplos concretos. |
| Novidade de Bigramas | < 0.15 | > 0.35 | Romper com os clichês sintáticos e sequências de frases que todos repetem na SERP. |
| Information Gain Score | < 35.0 | > 65.0 | Conteúdo com baixa novidade tem risco elevado de desvalorização em atualizações centrais. |
Uma pontuação de similaridade muito baixa, abaixo de 0.40, também representa um alerta. Se o conteúdo afasta-se demais do consenso semântico da SERP, ele corre o risco de perder a relevância para a intenção de busca central, sendo interpretado como um desvio temático. O objetivo não é falar sobre outro assunto, mas sim responder à intenção principal cobrindo os aspectos fundamentais e acrescentando a camada de novidade que nenhum concorrente forneceu.
Isso se conecta diretamente à disciplina de Generative Engine Optimization (GEO). Mecanismos baseados em LLMs e RAG avaliam fragmentos textuais por densidade informativa. Fragmentos com alto ganho de informação são selecionados como âncoras de citação com maior frequência do que parágrafos que apenas parafraseiam a Wikipédia ou documentações genéricas.
Estratégias práticas para elevar o Information Gain na produção de conteúdo
Aumentar o Information Gain de uma página não exige inventar teses sem fundamento. Trata-se de enriquecer o texto com elementos de prova, detalhamento técnico e utilidade prática que ferramentas automatizadas de resumo não conseguem sintetizar por inferência estatística.
1. Inclusão de dados primários e amostragens empíricas
Se todos os artigos sobre um tema dizem que determinada prática melhora o desempenho, sua página ganha valor imediato ao apresentar números concretos de um teste real.
Exemplo de abordagem padrão na SERP:
A compactação de imagens reduz o tempo de carregamento e melhora a experiência.
Abordagem com Information Gain:
Em um teste com 1.200 URLs de catálogo, a conversão para WebP em 85% de qualidade reduziu o peso médio do DOM em 410 KB. O LCP medido no percentil 75 caiu de 3,4s para 1,9s em conexões móveis 4G.
A segunda frase adiciona dados quantitativos, reduz a redundância e entrega uma resposta que não existia nos competidores.
2. Tratamento de exceções e casos extremos
Os concorrentes que ranqueiam na média costumam cobrir o “caminho feliz” dos processos. Quando algo dá errado ou quando a arquitetura sai do padrão, os artigos genéricos falham.
Adicione seções dedicadas a:
- Erros de configuração reais observados em produção.
- Limitações de ferramentas e quando uma solução popular não se aplica.
- Trade-offs técnicos entre abordagens concorrentes.
3. Eliminação de introduções vazias e poda de redundâncias
Aumentar o ganho de informação envolve tanto adicionar dados novos quanto remover conteúdo irrelevante. Textos inflados com conceitos óbvios reduzem a densidade informacional global da página. Aplicar uma revisão orientada a content pruning em parágrafos de preenchimento eleva a entropia média do artigo.
Corte frases que não respondem à busca:
- “Desde os primórdios da internet…”
- “No mundo digital atual, o marketing é indispensável…”
- “Como todos sabemos, ter um site rápido faz a diferença…”
Inicie a seção diretamente com a definição técnica, a causa do problema ou a solução prática.
Validação estatística e monitoramento contínuo
Implementar otimizações de ganho de informação em grande escala exige validação metódica. Não basta publicar alterações e observar o tráfego global, pois sazonalidade e atualizações amplas de algoritmo afetam a medição.
O método recomendado para grandes sites e portais é isolar grupos de teste e controle, utilizando metodologias como SEO split testing com Python e CausalImpact. Ao selecionar cinquenta páginas para receberem auditoria de Information Gain enquanto cinquenta páginas similares permanecem inalteradas, você isola o efeito causal das melhorias sobre cliques orgânicos e impressões.
Adicionalmente, você pode conectar o extrator de dados à Search Console API com Python e BigQuery. Isso permite cruzar páginas com alto declínio de cliques com a pontuação de novidade semântica da SERP atualizada. Se concorrentes novos entraram no top 3 trazendo estudos ou ferramentas inéditas, o script de auditoria detectará a queda no seu diferencial de entropia, acionando uma revisão orientada por dados antes que a perda de posições se consolide.
O algoritmo do Google caminha para penalizar o conteúdo que apenas recombina o que já existe. Mensurar a entropia, calcular a distância vetorial e auditar o ganho de informação transformam a redação técnica em um processo previsível, escalável e resistente à homogeneização da busca orgânica.