Usuarios con Markov

01 · Punto de partida

Cada click es un paso, cada fuga una absorción

Visita → explora → carrito → compra… o abandono en cualquier punto. El funnel es una cadena con dos trampas rivales (Tema 32): compra y abandono.

La pregunta es la conversión: qué fracción de visitas termina en compra según las chances por etapa.

• ¿Qué etapas: visita, explora, carrito?
• ¿Qué chance de avanzar vs fugar en cada una?
• ¿Qué conversión total resulta?
• ¿Qué etapa pierde más y conviene arreglar?

02 · Definición

Etapas, avances y fugas

Tres números por etapa:

Con explora 0,6, carrito 0,4 y compra 0,5 (fugas 0,2/0,3/0,5): conversión ≈ 12 %.

03 · Anatomía

Cuello, fuga y reingreso

Cuatro lecturas del funnel:

Cuello

La etapa con menor avance×llegada: donde más se pierde en absoluto. Ahí rinde optimizar.

Fuga por etapa

P(abandono | etapa): el diagnóstico local. Alta = fricción (precio, formulario).

Conversión total

De visita a compra: el KPI. Sube mejorando cuellos, no todo parejo.

Reingreso

Volver atrás (carrito→explora) alarga el camino: modelarlo evita sobrestimar.

04 · Ejemplos

Funnels que se modelan igual

Cambia el negocio, no la matriz:

1. 1
   E-commerce.

   Visita→carrito→compra con abandono en cada click.

2. 2
   SaaS trial.

   Registro→uso→pago vs churn: conversión a pago.

3. 3
   App móvil.

   Instalación→onboarding→activo vs desinstala.

4. 4
   Contenido.

   Portada→nota→suscripción vs rebote.

5. 5
   Soporte.

   Ticket→resolución vs abandono del canal.

05 · Representación en Python

Funnel como P 5×5 absorbente

En Python, el funnel es P con dos trampas (compra 3, abandono 4). Simular hasta absorber da conversión y fugas por etapa.

import random

# 0 visita, 1 explora, 2 carrito, 3 compra, 4 abandona.
P = [[0.2, 0.6, 0.0, 0.0, 0.2],
     [0.0, 0.3, 0.4, 0.0, 0.3],
     [0.0, 0.0, 0.0, 0.5, 0.5],
     [0.0, 0.0, 0.0, 1.0, 0.0],
     [0.0, 0.0, 0.0, 0.0, 1.0]]

def comprar(semilla=7):
    random.seed(semilla)
    x = 0
    while x not in (3, 4):
        u, ac = random.random(), 0.0
        for j, p in enumerate(P[x]):
            ac += p
            if u < ac:
                x = j
                break
    return x == 3

print([comprar(s) for s in range(10)])

Unos compran (True), la mayoría abandona: conversión de un dígito, típica.

Conversión simulada

2000 visitas hasta absorber:

import random

P = [[0.2, 0.6, 0.0, 0.0, 0.2],
     [0.0, 0.3, 0.4, 0.0, 0.3],
     [0.0, 0.0, 0.0, 0.5, 0.5],
     [0.0, 0.0, 0.0, 1.0, 0.0],
     [0.0, 0.0, 0.0, 0.0, 1.0]]

def destino():
    x = 0
    while x not in (3, 4):
        u, ac = random.random(), 0.0
        for j, p in enumerate(P[x]):
            ac += p
            if u < ac:
                x = j
                break
    return x

random.seed(5)
N = 2000
print("conversión:", round(sum(destino() == 3 for _ in range(N)) / N, 3))

06 · Exploración

Laboratorio: encontrar el cuello

Movete carrito (1→2) y compra (2→3): las barras son llega-a-carrito, compra y abandono (300 visitas). La conversión responde más al cuello que al resto: probá qué slider la mueve más.

Verde = compra, gris = abandono; la intermedia marca cuántos pisan carrito. Sin carrito no hay compra.

Preguntas para explorar

1. Subí carrito de 0,4 a 0,8. ¿La conversión se duplica? ¿Y al revés con compra?
2. ¿Qué slider es el cuello con valores base? (El que más mueve al moverlo 0,1.)
3. ¿Conversión + abandono suman 100 %? ¿Por qué (trampas rivales)?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: conversión por producto

Con avances 0,6 – 0,4 – 0,5 sin reingresos, ¿conversión teórica? Verificá el producto.

print(0.6 * 0.4 * 0.5)

Ejercicio 2: cuello comparados

Sin ejecutar primero: ¿rinde más +0,1 en carrito (0,4→0,5) o en compra (0,5→0,6)? Calculalo.

base = 0.6 * 0.4 * 0.5
print("carrito:", 0.6 * 0.5 * 0.5, "| compra:", 0.6 * 0.4 * 0.6, "| base:", base)

Ejercicio 3: fugas por etapa

De 2000 rutas, contá abandonos por última etapa visitada. ¿Dónde está el cuello?

import random

P = [[0.2, 0.6, 0.0, 0.0, 0.2],
     [0.0, 0.3, 0.4, 0.0, 0.3],
     [0.0, 0.0, 0.0, 0.5, 0.5],
     [0.0, 0.0, 0.0, 1.0, 0.0],
     [0.0, 0.0, 0.0, 0.0, 1.0]]
random.seed(8)
fuga = {0: 0, 1: 0, 2: 0}
for _ in range(2000):
    x, ult = 0, 0
    while x not in (3, 4):
        ult = x
        u, ac = random.random(), 0.0
        for j, p in enumerate(P[x]):
            ac += p
            if u < ac:
                x = j
                break
    if x == 4:
        fuga[ult] += 1
print(fuga)

09 · Síntesis

Ideas para recordar

En el próximo tema optimizaremos máquinas: sistemas informáticos.