La minería de reglas de asociación busca descubrir regularidades en bases de datos transaccionales: productos que suelen comprarse juntos, páginas que suelen visitarse en una misma sesión, palabras que coaparecen en documentos o eventos que tienden a registrarse en conjunto. En este contexto, una transacción representa una observación compuesta por varios ítems; por ejemplo, una compra de supermercado puede contener {Pan, Leche, Pañales}. El objetivo no es predecir una etiqueta, sino identificar estructuras de coocurrencia que permitan extraer conocimiento interpretable a partir de datos discretos (Agrawal y Srikant 1994; Han et al. 2012).
El algoritmo FP-Growth (Frequent Pattern Growth) fue propuesto como una alternativa eficiente a Apriori para encontrar conjuntos frecuentes de ítems. Su idea central es evitar la generación explícita de candidatos y comprimir la base de transacciones en una estructura llamada FP-tree (Frequent Pattern Tree). A partir de ese árbol, el algoritmo explora patrones frecuentes mediante bases condicionales y árboles condicionales (Han et al. 2000; Borgelt 2005).
Este capítulo desarrolla FP-Growth de manera progresiva. Primero se revisan las nociones de transacción, itemset, soporte y frecuencia. Después se muestra cómo construir un FP-tree usando un ejemplo pequeño de cesta de compra. Finalmente, se explica cómo extraer patrones frecuentes mediante caminos prefijo condicionales, se compara FP-Growth con Apriori y se implementa un flujo práctico en Python.
En minería de asociaciones, trabajamos con una colección de transacciones. Cada transacción contiene un subconjunto de ítems tomado de un universo finito de productos, términos o eventos posibles. Esta representación es natural en problemas donde los datos son conjuntos: una compra contiene productos, un documento contiene palabras, una sesión web contiene páginas visitadas.
El concepto clave para decidir si un patrón es relevante es el soporte. Existen dos formas comunes de reportarlo: como conteo absoluto o como proporción. El conteo absoluto indica cuántas transacciones contienen el patrón; el soporte relativo divide ese conteo entre el número total de transacciones.
El umbral \(\text{min\_sup}\) controla la granularidad del análisis. Un valor demasiado bajo puede producir demasiados patrones, muchos de ellos triviales o difíciles de interpretar. Un valor demasiado alto puede eliminar patrones interesantes pero menos comunes. Por ello, en aplicaciones reales suele elegirse mediante exploración, conocimiento del dominio y restricciones computacionales.
El algoritmo Apriori explota una propiedad fundamental: si un conjunto de ítems es frecuente, entonces todos sus subconjuntos también son frecuentes. De manera equivalente, si un itemset no es frecuente, ningún superconjunto suyo puede ser frecuente (Agrawal y Srikant 1994). Esta propiedad permite podar el espacio de búsqueda, pero Apriori todavía necesita generar muchos candidatos y escanear la base varias veces.
FP-Growth sigue otra estrategia. En lugar de construir y evaluar candidatos explícitamente, realiza dos recorridos principales sobre la base de datos: uno para calcular los soportes de los ítems individuales y otro para construir un árbol compacto. Después extrae patrones frecuentes desde la estructura comprimida (Han et al. 2000).
La ventaja aparece especialmente cuando muchas transacciones comparten prefijos. Si los ítems se ordenan globalmente por frecuencia decreciente, transacciones parecidas tienden a compartir las primeras ramas del árbol. Así, el FP-tree almacena información agregada en lugar de repetir cada transacción completa.
Considérese la siguiente base de transacciones y un soporte mínimo absoluto \(\text{min\_sup}=3\):
| Transacción | Ítems |
|---|---|
| \(T_1\) | {Pan, Leche} |
| \(T_2\) | {Pan, Leche, Pañales, Cerveza} |
| \(T_3\) | {Leche, Pañales, Cerveza} |
| \(T_4\) | {Pan, Leche, Pañales, Cerveza} |
| \(T_5\) | {Pan, Leche, Pañales} |
Los soportes absolutos de los ítems individuales son:
| Ítem | Transacciones donde aparece | Soporte absoluto |
|---|---|---|
| Pan | \(T_1,T_2,T_4,T_5\) | 4 |
| Leche | \(T_1,T_2,T_3,T_4,T_5\) | 5 |
| Pañales | \(T_2,T_3,T_4,T_5\) | 4 |
| Cerveza | \(T_2,T_3,T_4\) | 3 |
Como todos los ítems tienen soporte absoluto mayor o igual que \(3\), ninguno se elimina en esta etapa. Si hubiera ítems con soporte menor que \(\text{min\_sup}\), se descartarían antes de construir el árbol.
# Ejemplo base de transacciones
transactions = [
{"Pan", "Leche"},
{"Pan", "Leche", "Pañales", "Cerveza"},
{"Leche", "Pañales", "Cerveza"},
{"Pan", "Leche", "Pañales", "Cerveza"},
{"Pan", "Leche", "Pañales"},
]
min_sup = 3
from collections import Counter
item_counts = Counter()
for transaction in transactions:
item_counts.update(transaction)
item_countsCounter({'Leche': 5, 'Pan': 4, 'Pañales': 4, 'Cerveza': 3})El FP-tree depende de un orden global de ítems. La regla usual consiste en ordenar los ítems de mayor a menor frecuencia. En caso de empates, conviene fijar un criterio determinista, por ejemplo orden alfabético. Este ordenamiento hace que transacciones con ítems frecuentes compartan prefijos y que el árbol sea más compacto.
En el ejemplo, el orden global puede tomarse como:
\[ \text{Leche} \succ \text{Pan} \succ \text{Pañales} \succ \text{Cerveza}. \]
Con ese orden, las transacciones se transforman en:
| Transacción original | Transacción ordenada |
|---|---|
{Pan, Leche} |
[Leche, Pan] |
{Pan, Leche, Pañales, Cerveza} |
[Leche, Pan, Pañales, Cerveza] |
{Leche, Pañales, Cerveza} |
[Leche, Pañales, Cerveza] |
{Pan, Leche, Pañales, Cerveza} |
[Leche, Pan, Pañales, Cerveza] |
{Pan, Leche, Pañales} |
[Leche, Pan, Pañales] |
# Orden global por frecuencia descendente y desempate alfabético
frequent_items = {item for item, count in item_counts.items() if count >= min_sup}
order = sorted(frequent_items, key=lambda item: (-item_counts[item], item))
rank = {item: position for position, item in enumerate(order)}
ordered_transactions = []
for transaction in transactions:
filtered = [item for item in transaction if item in frequent_items]
ordered = sorted(filtered, key=lambda item: rank[item])
ordered_transactions.append(ordered)
order, ordered_transactions(['Leche', 'Pan', 'Pañales', 'Cerveza'],
[['Leche', 'Pan'],
['Leche', 'Pan', 'Pañales', 'Cerveza'],
['Leche', 'Pañales', 'Cerveza'],
['Leche', 'Pan', 'Pañales', 'Cerveza'],
['Leche', 'Pan', 'Pañales']])Un FP-tree es un árbol con raíz nula. Cada nodo almacena un ítem, un contador y enlaces hacia sus hijos. Para insertar una transacción ordenada, se recorre la transacción de izquierda a derecha. Si el siguiente ítem ya existe como hijo del nodo actual, se incrementa su contador. Si no existe, se crea un nuevo nodo con contador inicial igual a uno.
El procedimiento de construcción puede resumirse así:
null.class FPNode:
def __init__(self, item=None, count=0, parent=None):
self.item = item
self.count = count
self.parent = parent
self.children = {}
def add_child(self, item):
child = FPNode(item=item, count=0, parent=self)
self.children[item] = child
return child
def insert_transaction(root, transaction):
current = root
for item in transaction:
if item not in current.children:
current.add_child(item)
current = current.children[item]
current.count += 1
def build_fp_tree(ordered_transactions):
root = FPNode(item="null", count=0)
for transaction in ordered_transactions:
insert_transaction(root, transaction)
return root
def print_tree(node, indent=0):
label = f"{node.item}: {node.count}" if node.item != "null" else "null"
print(" " * indent + label)
for child in node.children.values():
print_tree(child, indent + 1)
root = build_fp_tree(ordered_transactions)
print_tree(root)null
Leche: 5
Pan: 4
Pañales: 3
Cerveza: 2
Pañales: 1
Cerveza: 1En este ejemplo, la rama más importante inicia con Leche, porque aparece en todas las transacciones. Desde Leche, varias transacciones continúan con Pan; otras continúan directamente con Pañales. La compresión proviene de sumar contadores en prefijos compartidos en lugar de almacenar cada transacción de forma independiente.
Una vez construido el FP-tree, FP-Growth extrae patrones frecuentes considerando los ítems desde los menos frecuentes hacia los más frecuentes. Para cada ítem objetivo, se buscan todos los caminos que terminan en ese ítem. Al quitar el ítem objetivo de esos caminos se obtiene su base de patrones condicional.
Para el ítem Cerveza, los caminos relevantes son:
| Camino en el árbol | Conteo |
|---|---|
[Leche, Pan, Pañales, Cerveza] |
2 |
[Leche, Pañales, Cerveza] |
1 |
Al eliminar Cerveza, se obtiene:
| Camino prefijo | Conteo |
|---|---|
[Leche, Pan, Pañales] |
2 |
[Leche, Pañales] |
1 |
En esta base condicional, los conteos acumulados son:
| Ítem | Conteo condicional |
|---|---|
| Leche | 3 |
| Pan | 2 |
| Pañales | 3 |
Con \(\text{min\_sup}=3\), Pan se elimina de la base condicional de Cerveza, mientras que Leche y Pañales permanecen. Por tanto, los patrones frecuentes que incluyen Cerveza son:
\[ \{\text{Cerveza}\}, \quad \{\text{Leche},\text{Cerveza}\}, \quad \{\text{Pañales},\text{Cerveza}\}, \quad \{\text{Leche},\text{Pañales},\text{Cerveza}\}. \]
def collect_prefix_paths(node, target_item):
"""Devuelve caminos prefijo hacia target_item dentro de un FP-tree simple."""
paths = []
def traverse(current):
for child in current.children.values():
if child.item == target_item:
path = []
parent = child.parent
while parent is not None and parent.item != "null":
path.append(parent.item)
parent = parent.parent
path.reverse()
if path:
paths.append((path, child.count))
traverse(child)
traverse(node)
return paths
prefix_paths_cerveza = collect_prefix_paths(root, "Cerveza")
prefix_paths_cerveza[(['Leche', 'Pan', 'Pañales'], 2), (['Leche', 'Pañales'], 1)]def conditional_counts(prefix_paths):
counts = Counter()
for path, weight in prefix_paths:
for item in path:
counts[item] += weight
return counts
conditional_counts(prefix_paths_cerveza)Counter({'Leche': 3, 'Pañales': 3, 'Pan': 2})Después de obtener la base condicional de un ítem, se eliminan los ítems que no alcanzan el soporte mínimo y se construye un nuevo FP-tree restringido a esa base. Ese árbol se llama árbol condicional. En el caso de Cerveza, el árbol condicional conserva la estructura:
\[ \text{Leche}:3 \rightarrow \text{Pañales}:3. \]
Esto significa que, entre las transacciones que contienen Cerveza, existen tres ocurrencias donde Leche aparece junto con Cerveza y tres ocurrencias donde Pañales aparece junto con Cerveza. Además, el camino conjunto indica que {Leche, Pañales, Cerveza} también es frecuente.
def expand_weighted_paths(prefix_paths):
expanded = []
for path, weight in prefix_paths:
expanded.extend([path] * weight)
return expanded
conditional_item_counts = conditional_counts(prefix_paths_cerveza)
conditional_frequent = {
item for item, count in conditional_item_counts.items()
if count >= min_sup
}
conditional_order = sorted(
conditional_frequent,
key=lambda item: (-conditional_item_counts[item], item)
)
conditional_rank = {item: pos for pos, item in enumerate(conditional_order)}
conditional_transactions = []
for path in expand_weighted_paths(prefix_paths_cerveza):
filtered_path = [item for item in path if item in conditional_frequent]
ordered_path = sorted(filtered_path, key=lambda item: conditional_rank[item])
if ordered_path:
conditional_transactions.append(ordered_path)
conditional_root = build_fp_tree(conditional_transactions)
print_tree(conditional_root)null
Leche: 3
Pañales: 3El laboratorio inserta las transacciones de una en una. En cada paso verás qué prefijo se comparte (los contadores suben) y qué nodos nuevos se crean. Después elige un ítem para obtener su base de patrones condicional y los patrones frecuentes que terminan en él. Las líneas discontinuas son los enlaces de nodo de la tabla de encabezados: conectan todas las apariciones de un mismo ítem en el árbol.
Laboratorio · FP-Growth
Mueve el número de transacciones insertadas, cambia el soporte mínimo y elige el ítem cuya base condicional quieres ver.
Guía del laboratorio.
Repitiendo el procedimiento para los ítems restantes en orden ascendente de frecuencia, se obtienen los conjuntos frecuentes:
| Ítem base | Patrones frecuentes asociados |
|---|---|
| Cerveza | {Cerveza}, {Leche, Cerveza}, {Pañales, Cerveza}, {Leche, Pañales, Cerveza} |
| Pañales | {Pañales}, {Leche, Pañales}, {Pan, Pañales}, {Leche, Pan, Pañales} |
| Pan | {Pan}, {Leche, Pan} |
| Leche | {Leche} |
Agrupando y eliminando duplicados, los itemsets frecuentes con \(\text{min\_sup}=3\) son:
\[ \begin{aligned} &\{\text{Leche}\},\{\text{Pan}\},\{\text{Pañales}\},\{\text{Cerveza}\},\\ &\{\text{Leche},\text{Pan}\},\{\text{Leche},\text{Pañales}\},\{\text{Leche},\text{Cerveza}\},\\ &\{\text{Pan},\text{Pañales}\},\{\text{Pañales},\text{Cerveza}\},\\ &\{\text{Leche},\text{Pan},\text{Pañales}\},\{\text{Leche},\text{Pañales},\text{Cerveza}\}. \end{aligned} \]
Es importante notar que FP-Growth no produce directamente reglas de asociación; primero produce itemsets frecuentes. Las reglas se construyen después a partir de esos itemsets, evaluando métricas como confianza, lift o convicción (Tan et al. 2019; Han et al. 2012).
mlxtendEn Python, una forma sencilla de aplicar FP-Growth es utilizar mlxtend, que implementa tanto Apriori como FP-Growth para matrices transaccionales codificadas en formato one-hot (Raschka 2018).
# Si es necesario, instalar previamente:
# pip install mlxtend pandas
import pandas as pd
from mlxtend.preprocessing import TransactionEncoder
from mlxtend.frequent_patterns import fpgrowth, association_rules
transactions_list = [list(t) for t in transactions]
encoder = TransactionEncoder()
one_hot = encoder.fit(transactions_list).transform(transactions_list)
df = pd.DataFrame(one_hot, columns=encoder.columns_)
df| Cerveza | Leche | Pan | Pañales | |
|---|---|---|---|---|
| 0 | False | True | True | False |
| 1 | True | True | True | True |
| 2 | True | True | False | True |
| 3 | True | True | True | True |
| 4 | False | True | True | True |
Como mlxtend usa soporte relativo, el umbral absoluto \(\text{min\_sup}=3\) debe transformarse dividiendo entre el número de transacciones:
\[ \text{min\_sup}_{rel}=\frac{3}{5}=0.6. \]
min_support_relative = min_sup / len(transactions)
frequent_itemsets = fpgrowth(
df,
min_support=min_support_relative,
use_colnames=True
)
frequent_itemsets.sort_values(
by=["support", "itemsets"],
ascending=[False, True]
)| support | itemsets | |
|---|---|---|
| 0 | 1.0 | (Leche) |
| 1 | 0.8 | (Pan) |
| 2 | 0.8 | (Pañales) |
| 4 | 0.8 | (Pan, Leche) |
| 7 | 0.8 | (Pañales, Leche) |
| 3 | 0.6 | (Cerveza) |
| 5 | 0.6 | (Pan, Pañales) |
| 6 | 0.6 | (Pan, Pañales, Leche) |
| 8 | 0.6 | (Pañales, Cerveza) |
| 9 | 0.6 | (Leche, Cerveza) |
| 10 | 0.6 | (Pañales, Leche, Cerveza) |
A partir de los itemsets frecuentes se pueden generar reglas. Por ejemplo, una regla \(X \Rightarrow Y\) se interpreta como: “cuando aparece \(X\), también tiende a aparecer \(Y\)”.
rules = association_rules(
frequent_itemsets,
metric="confidence",
min_threshold=0.7
)
selected_columns = [
"antecedents", "consequents", "support", "confidence", "lift"
]
rules[selected_columns].sort_values(
by=["lift", "confidence"],
ascending=False
)| antecedents | consequents | support | confidence | lift | |
|---|---|---|---|---|---|
| 12 | (Cerveza) | (Pañales) | 0.6 | 1.00 | 1.2500 |
| 16 | (Leche, Cerveza) | (Pañales) | 0.6 | 1.00 | 1.2500 |
| 18 | (Cerveza) | (Pañales, Leche) | 0.6 | 1.00 | 1.2500 |
| 11 | (Pañales) | (Cerveza) | 0.6 | 0.75 | 1.2500 |
| 14 | (Pañales, Leche) | (Cerveza) | 0.6 | 0.75 | 1.2500 |
| 17 | (Pañales) | (Leche, Cerveza) | 0.6 | 0.75 | 1.2500 |
| 0 | (Pan) | (Leche) | 0.8 | 1.00 | 1.0000 |
| 4 | (Pan, Pañales) | (Leche) | 0.6 | 1.00 | 1.0000 |
| 9 | (Pañales) | (Leche) | 0.8 | 1.00 | 1.0000 |
| 13 | (Cerveza) | (Leche) | 0.6 | 1.00 | 1.0000 |
| 15 | (Pañales, Cerveza) | (Leche) | 0.6 | 1.00 | 1.0000 |
| 1 | (Leche) | (Pan) | 0.8 | 0.80 | 1.0000 |
| 10 | (Leche) | (Pañales) | 0.8 | 0.80 | 1.0000 |
| 2 | (Pan) | (Pañales) | 0.6 | 0.75 | 0.9375 |
| 3 | (Pañales) | (Pan) | 0.6 | 0.75 | 0.9375 |
| 5 | (Pan, Leche) | (Pañales) | 0.6 | 0.75 | 0.9375 |
| 6 | (Pañales, Leche) | (Pan) | 0.6 | 0.75 | 0.9375 |
| 7 | (Pan) | (Pañales, Leche) | 0.6 | 0.75 | 0.9375 |
| 8 | (Pañales) | (Pan, Leche) | 0.6 | 0.75 | 0.9375 |
La confianza puede ser alta aun cuando el consecuente sea muy frecuente. Por ello, conviene interpretarla junto con el lift. Un lift mayor que uno sugiere asociación positiva; un lift cercano a uno sugiere que la regla no mejora sustancialmente lo esperado por independencia; un lift menor que uno sugiere asociación negativa.
Volvamos a la muestra de 50 canastas del capítulo de Apriori. Construimos el FP-tree con las funciones de este capítulo para medir cuánto comprime y comprobamos que fpgrowth y apriori devuelven exactamente los mismos itemsets frecuentes.
import plotly.graph_objects as go
from mlxtend.frequent_patterns import apriori
canastas = [
["whole milk", "yogurt", "bread"], ["whole milk", "butter", "eggs"], ["whole milk", "yogurt", "vegetables"],
["bread", "butter", "eggs"], ["whole milk", "soda", "chips"], ["yogurt", "fruit", "bread"],
["whole milk", "coffee", "bread"], ["eggs", "butter", "cheese"], ["whole milk", "vegetables", "fruit"],
["soda", "chips", "candy"], ["whole milk", "bread", "eggs"], ["yogurt", "fruit", "granola"],
["whole milk", "coffee", "sugar"], ["bread", "eggs", "cheese"], ["whole milk", "yogurt", "coffee"],
["butter", "eggs", "bread"], ["chips", "soda", "beer"], ["whole milk", "vegetables", "butter"],
["yogurt", "granola", "fruit"], ["whole milk", "bread", "sugar"], ["eggs", "cheese", "vegetables"],
["whole milk", "soda", "bread"], ["coffee", "sugar", "bread"], ["yogurt", "whole milk", "fruit"],
["butter", "whole milk", "eggs"], ["bread", "chips", "soda"], ["whole milk", "granola", "yogurt"],
["vegetables", "fruit", "bread"], ["whole milk", "butter", "cheese"], ["eggs", "bread", "coffee"],
["whole milk", "yogurt", "butter"], ["chips", "candy", "soda"], ["whole milk", "coffee", "eggs"],
["bread", "vegetables", "fruit"], ["yogurt", "cheese", "eggs"], ["whole milk", "bread", "coffee"],
["soda", "beer", "chips"], ["whole milk", "vegetables", "eggs"], ["yogurt", "granola", "whole milk"],
["bread", "butter", "sugar"], ["whole milk", "fruit", "cheese"], ["eggs", "vegetables", "butter"],
["whole milk", "chips", "soda"], ["coffee", "bread", "butter"], ["yogurt", "whole milk", "bread"],
["eggs", "cheese", "bread"], ["whole milk", "sugar", "butter"], ["vegetables", "fruit", "yogurt"],
["whole milk", "bread", "butter"], ["granola", "yogurt", "fruit"],
]
min_conteo_g = 5
conteos_g = Counter(i for t in canastas for i in t)
orden_g = sorted([i for i, c in conteos_g.items() if c >= min_conteo_g], key=lambda i: (-conteos_g[i], i))
rango_g = {i: r for r, i in enumerate(orden_g)}
def contar_nodos(nodo):
return sum(1 + contar_nodos(h) for h in nodo.children.values())
raiz_g, apariciones, nodos = FPNode(item="null"), [], []
for t in canastas:
t_ord = sorted([i for i in t if i in rango_g], key=rango_g.get)
insert_transaction(raiz_g, t_ord)
apariciones.append((apariciones[-1] if apariciones else 0) + len(t_ord))
nodos.append(contar_nodos(raiz_g))
fig = go.Figure()
fig.add_scatter(y=apariciones, mode="lines", name="apariciones de ítems", line=dict(color="#2563eb", width=2))
fig.add_scatter(y=nodos, mode="lines", name="nodos del FP-tree", line=dict(color="#ea580c", width=2))
fig.update_layout(xaxis_title="Canastas insertadas", yaxis_title="Total acumulado", height=360)
fig.show()
print(f"{apariciones[-1]} apariciones de ítems -> {nodos[-1]} nodos ({nodos[-1] / apariciones[-1]:.0%})")Crecimiento del FP-tree al insertar las 50 canastas (soporte mínimo de 5 canastas). La línea azul cuenta las apariciones de ítems frecuentes acumuladas en las transacciones; la naranja, los nodos del árbol. La distancia entre ambas es la compresión.
146 apariciones de ítems -> 59 nodos (40%)te_g = TransactionEncoder()
df_g = pd.DataFrame(te_g.fit_transform(canastas), columns=te_g.columns_)
fp_items = fpgrowth(df_g, min_support=0.10, use_colnames=True)
ap_items = apriori(df_g, min_support=0.10, use_colnames=True)
mismos = set(map(frozenset, fp_items["itemsets"])) == set(map(frozenset, ap_items["itemsets"]))
print(f"FP-Growth: {len(fp_items)} itemsets | Apriori: {len(ap_items)} itemsets | ¿idénticos? {mismos}")FP-Growth: 26 itemsets | Apriori: 26 itemsets | ¿idénticos? TrueCon canastas tan cortas y heterogéneas la compresión es moderada: muchas canastas no comparten prefijo. El árbol comprime más cuando las transacciones se parecen entre sí, que es justamente el caso de datos densos donde Apriori genera más candidatos. Ambos algoritmos son exactos: cambian el camino, no la respuesta.
| Característica | FP-Growth | Apriori |
|---|---|---|
| Generación de candidatos | No requerida | Necesaria |
| Recorridos de los datos | Usualmente dos recorridos principales | Varios recorridos |
| Velocidad | Eficiente en bases grandes y densas | Puede ser lento por generación repetida de candidatos |
| Uso de memoria | Puede ser alto por el FP-tree | Generalmente menor, basado en listas y conteos |
| Implementación | Más compleja | Más sencilla de explicar e implementar |
FP-Growth suele ser preferible cuando la base es grande y contiene muchos patrones frecuentes. Apriori puede ser útil con fines didácticos o cuando se desea una implementación directa basada en candidatos. En la práctica, la elección también depende de la densidad de las transacciones, el umbral de soporte, la memoria disponible y la necesidad de interpretar pasos intermedios.
FP-Growth es aplicable a distintos dominios donde los datos pueden representarse como conjuntos de eventos o ítems:
En todos estos casos, los patrones frecuentes deben interpretarse con cuidado. La coocurrencia no implica causalidad. Una regla puede ser estadísticamente fuerte y, aun así, carecer de utilidad práctica si representa un patrón obvio, redundante o inducido por sesgos de captura de datos.
Entre las principales ventajas de FP-Growth se encuentran:
Sus limitaciones principales son:
Estas limitaciones no invalidan el método, pero sí obligan a seleccionar adecuadamente el umbral de soporte, revisar la calidad de los datos y evaluar la interpretabilidad de los patrones resultantes.
Al aplicar FP-Growth en un proyecto real, conviene seguir una estrategia reproducible:
La etapa más importante no es ejecutar el algoritmo, sino construir una representación transaccional coherente. Por ejemplo, en minería de texto, decidir si los ítems serán palabras, lemas, n-gramas o entidades cambia completamente el significado de los patrones. En comercio electrónico, decidir si una transacción corresponde a una compra, una sesión o un usuario también modifica la interpretación del soporte.
FP-Growth es un algoritmo fundamental para la minería de patrones frecuentes. Su principal contribución es reemplazar la generación explícita de candidatos por una estructura compacta, el FP-tree, que permite almacenar prefijos compartidos y extraer patrones mediante bases condicionales. Esta estrategia reduce recorridos sobre la base de datos y suele mejorar el rendimiento frente a Apriori en escenarios grandes o densos.
Desde el punto de vista conceptual, FP-Growth muestra una idea central en ciencia de datos: la eficiencia no depende solo del algoritmo, sino también de la representación. Al transformar transacciones en un árbol comprimido, el problema se vuelve más manejable sin perder la información necesaria para recuperar los itemsets frecuentes.
En aplicaciones reales, el algoritmo debe acompañarse de una interpretación cuidadosa. Los patrones frecuentes son puntos de partida para formular hipótesis, diseñar recomendaciones o comprender comportamientos, pero no constituyen por sí solos evidencia causal. Por ello, la minería de asociaciones debe integrarse con análisis exploratorio, conocimiento del dominio y criterios claros de utilidad práctica.