He hecho un experimento un poco absurdo y muy divertido. He cogido el grafo de enlaces de este blog, traduje el PageRank a su versión cuántica y lo ejecuté en una de las máquinas cuánticas que IBM tiene en la nube, algo que nunca nadie ha hecho hasta el momento 🙂
¡Y funcionó! Hay un identificador de trabajo (d8e52hhvjngc73ant800, por si alguien quiere comprobarlo) que demuestra que el circuito corrió en un chip de IBM y no en una simulación.
Antes que pierdas el tiempo aquí te aviso ya... para SEO no sirve de nada. Pero si eres un nerd, seguro que querrás seguir leyendo.
A continuación explico de dónde sale la idea, qué hice exactamente y por qué Google no haría esto ni queriendo.
No hace falta saber física porque voy a explicarlo todo para que se entienda.
La definición original de PageRank (Brin y Page, 1998) es recursiva y un poco circular, es decir, que una página es importante si la enlazan páginas importantes, que a su vez lo son si las enlazan otras importantes, y así hasta el infinito. Lo cual tiene un problema gordo, ya que eso es imposible de calcular.
Para que eso fuera calculable, Brin y Page lo explicaron con un modelo que acabó siendo hasta más famoso que la propia fórmula: el del random surfer (el navegante aleatorio).
Imagina a alguien navegando sin rumbo que entra en una página, pincha un enlace al azar, llega a otra, pincha otro, y así durante horas. De vez en cuando se aburre y, en lugar de seguir un enlace, salta a una página cualquiera del sitio (ese es el famoso damping factor de 0,85, es decir, el 85% de las veces sigue un enlace, el 15% salta). El PageRank de una página es la fracción de tiempo que el navegante pasa ahí.
Lo que mola de esto es que los dos caminos dan exactamente el mismo resultado. La definición recursiva y el tiempo que pasa el navegante coinciden hasta el último decimal.
Quédate con lo del navegante aleatorio porque esto con la versión cuántica del PageRank va a cambiar. En matemáticas el navegante es una cadena de Markov y lo único que decide el siguiente paso es dónde estás ahora y no cómo llegaste. Un ordenador normal esto se resuelve en un momento, incluso para la web entera es trivial y eficiente. Yo lo implementé en 2011, después de una discusión en Twitter, y el código me cabía en media pantalla.
En 2012, dos físicos (Giuseppe Paparo y Miguel Ángel Martín-Delgado) publicaron en Scientific Reports un artículo titulado Google in a Quantum Network. Se preguntaron: ¿y si en vez de un navegante que tira un dado en cada paso, pones uno que se comporta como una onda?
El navegante clásico está siempre en una página concreta, pero el navegante cuántico está repartido por muchas páginas a la vez, en lo que se llama una superposición. Y los distintos caminos que podría tomar interfieren entre sí, como las olas en el agua, que en unos puntos se suman y en otros se cancelan. Esa interferencia hace que la "probabilidad" de acabar en cada página se reparta de una forma distinta a la clásica.
Y esto se vuelve SUPER pesado de calcular porque el estado del navegante cuántico es de qué página vengo y a cuál voy. Es decir, si tu sitio tiene N páginas, los pares posibles son N por N, o sea N². Para las 123 páginas de mi blog eso son unos 15.000 estados posibles.
El motor de todo este invento se llama walk de Szegedy. Vamos, que el algoritmo no es mío, lo único que hago yo es aplicarlo a mi blog. Lo que sí es nuevo, es haberlo ejecutado en un ordenador cuántico de verdad, porque Paparo y compañía lo simularon en ordenadores normales. Nadie, hasta donde he podido ver, había metido el quantum walk de una web real en un chip cuántico físico.
Antes de empezar, repliqué el ejemplo que ellos publican en el paper, un arbolito de 7 nodos en 3 niveles, con unos valores concretos en una tabla y el código tenía que devolver esos mismos números y los devolvió, con cuatro decimales de acuerdo. A partir de ahí supe que íbamos por el buen camino.
Sobre mis datos también reaparecen los hallazgos que ellos describen en su paper: el ranking se reordena, emergen "hubs secundarios" que el clásico no destacaba, la cola de páginas poco enlazadas se redistribuye. Hay una afirmación suya que no logré reproducir bien, la mayor estabilidad frente al damping, pero es que esa propiedad necesita promediar sobre muchos grafos distintos y yo tengo uno solo. Lo digo para no venderte algo que no vi.
Cogí un trozo pequeño del blog (luego entenderás la razón), solo 4 páginas que se enlazan entre sí (la home, el índice de artículos y dos posts), y mandé el circuito al ibm_marrakesh, con un procesador de 156 qubits.
El resultado es curioso, el PageRank clásico de ese grupito corona el índice de artículos por encima de la home. La versión cuántica le da la vuelta y pone la home primero. Y he comprobado que no se trata de un error, porque el cálculo ideal simulado lo predice y el chip, con su ruido y todo, lo respeta. Así que la home gana.
La barra de la home en el chip sale más alta de lo que debería. Resulta que un qubit, si lo dejas quieto, pierde energía y cae a su estado de reposo, el que etiquetamos como |0⟩ (se lee "ket cero" y es un qubit a cero). Es como una peonza que, según se va frenando, tiende a pararse siempre en la misma posición. A eso se le llama relajación, y como estos circuitos son largos, a muchos qubits les da tiempo a dormirse hacia el 0 antes de que midamos. El resultado se sesga hacia la cadena de todo ceros, el |00⟩ ("ket cero cero" = dos qubits en cero).
¿Y por qué le toca justo a la home? Porque por cómo numeré las páginas, la home es la número 0, que en binario es justo |00⟩. La tendencia natural del chip a caer en |00⟩ se confunde entonces con que el navegante terminó en la home. Parte de esa barra alta es lícita, porque el cálculo ideal también pone la home primera, pero otra parte es este artefacto ya que el chip mezcla haberse relajado al |00⟩ con que haya ganado la home.
Para limpiarlo usé dos técnicas estándar. La primera, dynamical decoupling, mete pulsos rápidos en los ratos en que un qubit está esperando sin hacer nada, para que no se duerma (es como ir dando toquecitos a la peonza para que no se pare). La segunda, twirling, repite el experimento muchas veces cambiando al azar pequeños detalles de cómo se aplican las puertas, de modo que un error que siempre tira hacia el mismo lado se vuelve ruido aleatorio que se cancela al promediar. En vez de equivocarte igual siempre, te equivocas distinto cada vez y la media sale más limpia.
Con las dos, la diferencia entre lo que da el chip y el cálculo ideal se redujo a la mitad, y la barra de la home bajó hacia donde tenía que estar. Aun así, que quede claro... sigue siendo un experimento de juguete de 4 nodos.
Por el muro. Para ejecutar el walk de Szegedy en un chip cuántico hay que traducirlo a "puertas" que son las operaciones elementales del procesador. Las que fastidian son las de 2 qubits, porque cada una añade un poco de ruido. Y el número de puertas crece de forma brutal con el tamaño del grafo:
Con 4 páginas son unas 180 puertas de 2 qubits sobre el chip y aún se distingue algo. Pero con 8 páginas saltas a unas 3.700 puertas, y a esa profundidad la probabilidad de que el circuito sobreviva sin un error es de aproximadamente 0,99 elevado a 3.700, que es prácticamente cero. El resultado es pura basura uniforme. Podéis ver que el cálculo ideal de esas 8 páginas tiene una estructura clara, pero lo que escupe el chip es indistinguible de tirar un dado.
Para el blog completo, 123 páginas, harían falta del orden de 270 millones de puertas, o lo que es lo mismo, ciencia ficción. Y ojo porque aquí yo creía que es por un problema de qubits pero no. Para 123 páginas bastarían unos 14 qubits y los chips de hoy tienen cientos. El problema es la profundidad del circuito y el ruido que acumula el mismo. Así que ahora entiendo porqué los propios inventores de la fórmula nunca lo han acabado metiendo en hardware, ahora incluso que es posible, y se limitaron a simularlo en una CPU, donde todo esto es trivial.
Para curiosos, este es el circuito que ha habido que montar para 4 urls:
Desplázate en horizontal para recorrer el circuito completo.
Así que he hecho lo mismo que realizaron los inventores, hacer una simulación de PR cuántico usando el blog entero. Así podremos ver si computo el PageRank cuántico de las 123 páginas me dice algo que el clásico no.
Por un lado, veo que los dos rankings se parecen bastante en conjunto. La correlación de Spearman entre ambos es de 0,85, lo cual es alto. Pero por otro lado, lo que veo que cambia es el "head" de mi blog, es decir las 10 primeras páginas del ranking clásico, solo 4 siguen en el top 10 cuántico, y la 1 cambia. Más de la mitad de las páginas se mueven 10 puestos o más.
¿Y qué hago con eso como SEO? Nada. Es otra medida de centralidad, distinta y matemáticamente legítima. Pero no hay ninguna razón para pensar que su orden sea el "bueno", el que importa para posicionar. Es simplemente diferente, no mejor.
No. Y vale la pena entender por qué y así entendemos para qué sirve de verdad un ordenador cuántico:
Un ordenador cuántico es una herramienta para problemas muy concretos donde se ha demostrado que gana como factorizar números enormes (lo que rompería parte de la criptografía actual), simular el comportamiento de moléculas y materiales, ciertos tipos de búsqueda y optimización.
PageRank no es uno de esos. Es barato computacionalmente y meterlo en una máquina cuántica es traer un instrumento carísimo y frágil a una tarea que un portátil ya hacía en un momento.
Llevo años leyendo mucho sobre cuántica, y la lección que he sacado es que la mayoría de los problemas que tenemos actualmente no son del tipo que un cuántico resuelve mejor. A continuación os cuento la razón.
En 2018, una estudiante de grado de 17 años, Ewin Tang, hacía su tesis con Scott Aaronson (super fan de este señor) en la Universidad de Texas en Austin. Le pusieron demostrar que cierto algoritmo cuántico de moda, uno de sistemas de recomendación (el de Kerenidis y Prakash, el tipo de motor que hay detrás de "productos que también te pueden gustar"), no se podía igualar con un ordenador normal. Se pasó meses intentando probar esa imposibilidad, hasta que empezó a sospechar justo lo contrario. Acabó construyendo un algoritmo clásico que igualaba al cuántico y que era exponencialmente más rápido que cualquier intento clásico anterior. Así que el supuesto superpoder cuántico no estaba donde se pensaba.
A esa maniobra ahora se la llama ahora descuantizar. Consiste en coger un algoritmo cuántico que presume de ir exponencialmente más rápido y encontrar uno clásico que hace lo mismo. Desde el trabajo de Tang han caído unos cuantos, entre ellos versiones cuánticas de recomendación, de análisis de componentes principales, de resolución de sistemas lineales o de máquinas de vectores soporte. Vamos, que la "ventaja cuántica" salía de compararse contra un método clásico mediocre, no contra el mejor que había. En cuanto alguien se molestaba en buscar el mejor clásico, la ventaja se evaporaba.
El Quantum PageRank es lo mismo, un invento caro.
Como experimento está muy bien. Es investigación de verdad, ejecutada por primera vez en hardware cuántico, y sobre el grafo de mi web. He visto cómo se traduce un algoritmo a "puertas", el problema del muro del ruido y por qué los qubits no son el cuello de botella.
Como herramienta SEO no vale nada, aviso por si algún GEO bro le da por venderte un "Prompt Tracker Cuántico", aunque bueno... devolviendo visibility scores de Schrödinger, algo cuánticos sí que lo son.
Consejo: Si quieres trastear con un ordenador cúantico, IMB te da 10 minutos gratis de cómputo al mes. Aprende a factorizar números enormes o simula una molécula. Para rankear páginas, sigue bastando el navegante que va dando tumbos de forma random.
En la primera pasada, el cálculo cuántico me rescató del fondo del ranking a 2 páginas que el clásico tenía enterradas. Me emocioné un segundo pensando que había encontrado algo. Fui a mirar qué páginas eran y resultó que una era una redirección 301 y la otra un enlace interno roto, un 404, que se me habían colado como nodos del grafo. El "hallazgo cuántico" eran mis propios fallos de enlazado...
O sea que lo más accionable de todo el experimento fue que me obligó a limpiar dos enlaces rotos. Usar un ordenador cuántico para esto no tiene precio 😅
El grafo sale de un rastreo con Screaming Frog (el informe All Inlinks). Los nodos son las URLs internas y las aristas son los enlaces internos. Filtré a enlaces de tipo Hyperlink, con atributo follow y respuesta 200, sin duplicados, y de ahí salen 1.091 aristas. Para el análisis del post me quedo solo con los enlaces que viven en el contenido (503 aristas), no en el menú, la cabecera o el pie, porque el sitewide reparte autoridad de una forma que no dice nada sobre la importancia editorial de cada página. Damping de 0,85 y teletransporte uniforme, tal y como lo plantea Paparo.
Dejo las dos piezas de código listas para copiar. La primera es el motor del Quantum PageRank y solo necesita NumPy. Ya trae de ejemplo el árbol de Paparo, así que al ejecutarla deberías ver sus números de la Tabla 1. La segunda ejecuta el walk en un ordenador cuántico de IBM con Qiskit (necesitas una cuenta gratuita y haber guardado tus credenciales con QiskitRuntimeService.save_account(...)).
import numpy as np
def quantum_pagerank(G, steps=2000):
"""Quantum PageRank de Paparo (walk de Szegedy, 2012).
G = matriz de Google column-stochastic (sus columnas suman 1).
Devuelve (media, desviacion) de I_q por nodo."""
N = G.shape[0]
A = np.zeros((N*N, N)); sq = np.sqrt(G) # columnas |psi_j> = |j> x sum_i sqrt(G_ij)|i>
for j in range(N):
A[j*N:(j+1)*N, j] = sq[:, j]
def U(x): # paso del walk: U = S (2 A A^T - I)
Rx = 2*(A @ (A.T @ x)) - x # reflexion
return Rx.reshape(N, N).T.reshape(-1) # swap
psi = A @ (np.ones(N)/np.sqrt(N)) # estado inicial
serie = np.empty((steps, N))
for m in range(steps):
serie[m] = (np.abs(psi.reshape(N, N))**2).sum(axis=0) # marginal del 2do registro
psi = U(U(psi)) # avanza U^2 (se mide en pasos pares)
return serie.mean(0), serie.std(0)
def google_matrix(edges, N, alpha=0.85):
"""G column-stochastic desde aristas (origen, destino). Dangling -> teletransporte uniforme."""
S = np.zeros((N, N))
for src, dst in edges:
S[dst, src] += 1 # la columna es el nodo de origen
out = S.sum(axis=0)
for j in range(N):
S[:, j] = S[:, j]/out[j] if out[j] else 1.0/N
return alpha*S + (1-alpha)/N
# Ejemplo: el arbol binario de Paparo (7 nodos, aristas hijo->padre).
# Reproduce su Tabla 1 -> cuantico por nivel ~ [0.356, 0.151, 0.085].
edges = [(1,0),(2,0),(3,1),(4,1),(5,2),(6,2)]
media, desv = quantum_pagerank(google_matrix(edges, N=7))
print(media.round(3))
import numpy as np
from qiskit import QuantumCircuit, ClassicalRegister, transpile
from qiskit.circuit.library import UnitaryGate
from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2
def walk_operator(G):
"""U = S (2 A A^T - I) como matriz densa N^2 x N^2 (solo N pequeno: 4-8 nodos)."""
N = G.shape[0]
A = np.zeros((N*N, N)); sq = np.sqrt(G)
for j in range(N): A[j*N:(j+1)*N, j] = sq[:, j]
R = 2*(A @ A.T) - np.eye(N*N)
idx = np.arange(N*N); a, b = idx//N, idx % N
S = np.zeros((N*N, N*N)); S[b*N + a, idx] = 1.0
return S @ R
def run_on_ibm(G, t=1, shots=8192, mitigate=True):
"""Ejecuta U^t en el QPU menos ocupado. Devuelve la distribucion del 2do registro y las puertas.
Requisito: guardar antes la cuenta con
QiskitRuntimeService.save_account(channel='ibm_quantum_platform', token=..., instance=...)."""
N = G.shape[0]; k = int(round(np.log2(N))) # qubits por registro
Ut = np.linalg.matrix_power(walk_operator(G), t)
qc = QuantumCircuit(2*k)
qc.append(UnitaryGate(Ut), range(2*k)) # el walk entero como una sola puerta
creg = ClassicalRegister(k, "meas")
qc.add_register(creg); qc.measure(range(k), creg) # medimos solo el 2do registro (qubits bajos)
backend = QiskitRuntimeService().least_busy(operational=True, simulator=False)
tqc = transpile(qc, backend=backend, optimization_level=3)
sampler = SamplerV2(mode=backend)
if mitigate: # supresion de ruido
sampler.options.dynamical_decoupling.enable = True
sampler.options.dynamical_decoupling.sequence_type = "XY4"
sampler.options.twirling.enable_gates = True
sampler.options.twirling.enable_measure = True
counts = sampler.run([tqc], shots=shots).result()[0].data.meas.get_counts()
m = np.zeros(N)
for bits, c in counts.items(): m[int(bits, 2)] += c
return m/m.sum(), tqc.count_ops()
# G es la misma matriz de Google del bloque anterior (usa 4 u 8 nodos para que quepa).
# dist, puertas = run_on_ibm(G, t=1)
Escribo este post porque estoy cansado de leer cada vez más estupideces sobre el SEO y el HTTPS (Hypertext Transfer Protocol Secure) a raíz del anuncio de Google en su blog, «HTTPS como señal de ranking». Pero todo esto no empieza aquí, este revuelo empieza a coger más fuerza en el mundo del SEO en marzo de […]
Leer másAntes de empezar un proyecto SEO es importante conocer la tecnología en la que está desarrollado un sitio web. ¿Es SalesForce? ¿Cuándo cambiaron de CMS? ¿Es un portal hecho a medida? ¿Está usando un Framework Javascript? ¿Qué sistemas de caché usa? ¿Tiene Cloudflare o similares para poder usar los workers y resolver las limitaciones de […]
Leer más