1039 lines
40 KiB
Plaintext
1039 lines
40 KiB
Plaintext
{
|
|
"cells": [
|
|
{
|
|
"cell_type": "markdown",
|
|
"id": "intro",
|
|
"metadata": {},
|
|
"source": [
|
|
"# Comparativa: bases de datos de grafos embebidas + LLM retrieval\n",
|
|
"\n",
|
|
"## Objetivo\n",
|
|
"\n",
|
|
"1. Cargar el grafo de dependencias de fn_registry en 5 backends de grafos\n",
|
|
"2. Benchmark: insercion, traversal, persistencia\n",
|
|
"3. Evaluar como un LLM (`claude -p`) genera queries para recuperar datos de cada backend\n",
|
|
"\n",
|
|
"## Backends\n",
|
|
"\n",
|
|
"| Backend | Query Language | Tipo |\n",
|
|
"|---|---|---|\n",
|
|
"| **Kuzu** | Cypher | Graph DB embebida |\n",
|
|
"| **NetworkX** | API Python | Libreria in-memory |\n",
|
|
"| **SQLite + CTEs** | SQL recursivo | Relacional |\n",
|
|
"| **RDFLib** | SPARQL | Triple store |\n",
|
|
"| **igraph** | API Python | Libreria C/Python |\n",
|
|
"\n",
|
|
"## Grafo de prueba\n",
|
|
"\n",
|
|
"El propio fn_registry: ~354 funciones + 39 tipos como nodos, dependencias (uses_functions, uses_types, returns) como aristas."
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"id": "section-1",
|
|
"metadata": {},
|
|
"source": [
|
|
"## 1. Extraer grafo desde registry.db"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"id": "extract-graph",
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"import sqlite3\n",
|
|
"import json\n",
|
|
"import os\n",
|
|
"import time\n",
|
|
"import shutil\n",
|
|
"import pandas as pd\n",
|
|
"import matplotlib.pyplot as plt\n",
|
|
"\n",
|
|
"plt.style.use('seaborn-v0_8-whitegrid')\n",
|
|
"\n",
|
|
"FN_ROOT = os.environ.get('FN_REGISTRY_ROOT', os.path.expanduser('~/fn_registry'))\n",
|
|
"DB_PATH = os.path.join(FN_ROOT, 'registry.db')\n",
|
|
"\n",
|
|
"conn = sqlite3.connect(DB_PATH)\n",
|
|
"conn.row_factory = sqlite3.Row\n",
|
|
"\n",
|
|
"# Nodos: funciones\n",
|
|
"functions = [dict(r) for r in conn.execute(\n",
|
|
" 'SELECT id, name, kind, lang, domain, purity, signature, description, '\n",
|
|
" 'uses_functions, uses_types, returns, returns_optional, error_type, tags '\n",
|
|
" 'FROM functions ORDER BY name'\n",
|
|
").fetchall()]\n",
|
|
"\n",
|
|
"# Nodos: tipos\n",
|
|
"types = [dict(r) for r in conn.execute(\n",
|
|
" 'SELECT id, name, lang, domain, algebraic, description, uses_types, tags '\n",
|
|
" 'FROM types ORDER BY name'\n",
|
|
").fetchall()]\n",
|
|
"\n",
|
|
"conn.close()\n",
|
|
"\n",
|
|
"# Construir aristas\n",
|
|
"edges = [] # (source_id, target_id, relation_type)\n",
|
|
"\n",
|
|
"for f in functions:\n",
|
|
" fid = f['id']\n",
|
|
" # uses_functions\n",
|
|
" for dep in json.loads(f.get('uses_functions') or '[]'):\n",
|
|
" edges.append((fid, dep, 'uses_function'))\n",
|
|
" # uses_types\n",
|
|
" for dep in json.loads(f.get('uses_types') or '[]'):\n",
|
|
" edges.append((fid, dep, 'uses_type'))\n",
|
|
" # returns\n",
|
|
" ret = f.get('returns') or ''\n",
|
|
" if ret:\n",
|
|
" edges.append((fid, ret, 'returns'))\n",
|
|
" # error_type\n",
|
|
" err = f.get('error_type') or ''\n",
|
|
" if err:\n",
|
|
" edges.append((fid, err, 'error_type'))\n",
|
|
"\n",
|
|
"for t in types:\n",
|
|
" tid = t['id']\n",
|
|
" for dep in json.loads(t.get('uses_types') or '[]'):\n",
|
|
" edges.append((tid, dep, 'uses_type'))\n",
|
|
"\n",
|
|
"# Todos los IDs de nodos referenciados\n",
|
|
"all_node_ids = set(f['id'] for f in functions) | set(t['id'] for t in types)\n",
|
|
"# Nodos por ID para lookup rapido\n",
|
|
"node_map = {f['id']: {**f, 'node_type': 'function'} for f in functions}\n",
|
|
"node_map.update({t['id']: {**t, 'node_type': 'type'} for t in types})\n",
|
|
"\n",
|
|
"# Filtrar aristas a nodos que existen\n",
|
|
"valid_edges = [(s, t, r) for s, t, r in edges if s in all_node_ids and t in all_node_ids]\n",
|
|
"\n",
|
|
"print(f'Nodos: {len(all_node_ids)} ({len(functions)} funciones + {len(types)} tipos)')\n",
|
|
"print(f'Aristas: {len(valid_edges)} (de {len(edges)} totales, {len(edges) - len(valid_edges)} con target inexistente)')\n",
|
|
"print(f'Relaciones: {set(r for _, _, r in valid_edges)}')"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"id": "section-2",
|
|
"metadata": {},
|
|
"source": [
|
|
"## 2. Benchmark framework"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"id": "bench-framework",
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"DATA_DIR = 'data/graph_bench'\n",
|
|
"os.makedirs(DATA_DIR, exist_ok=True)\n",
|
|
"\n",
|
|
"# Queries de traversal para benchmark (respuestas verificables contra el grafo)\n",
|
|
"BENCH_QUERIES = [\n",
|
|
" ('direct_deps', 'Funciones que usa directamente filter_slice_go_core'),\n",
|
|
" ('reverse_deps', 'Funciones que dependen de error_go_core'),\n",
|
|
" ('two_hop', 'Dependencias a 2 saltos desde init_metabase_go_pipelines'),\n",
|
|
" ('domain_subgraph', 'Todas las aristas entre funciones del dominio finance'),\n",
|
|
" ('most_connected', 'Top 5 nodos con mas conexiones (in + out degree)'),\n",
|
|
" ('path_exists', 'Existe un camino entre cualquier funcion de finance y error_go_core?'),\n",
|
|
" ('isolated', 'Funciones sin ninguna dependencia (ni entrante ni saliente)'),\n",
|
|
" ('type_users', 'Funciones que usan el tipo SMA_go_finance'),\n",
|
|
"]\n",
|
|
"\n",
|
|
"def dir_size_mb(path):\n",
|
|
" total = 0\n",
|
|
" if os.path.isfile(path):\n",
|
|
" return os.path.getsize(path) / (1024*1024)\n",
|
|
" if not os.path.exists(path):\n",
|
|
" return 0\n",
|
|
" for dp, dn, fns in os.walk(path):\n",
|
|
" for f in fns:\n",
|
|
" fp = os.path.join(dp, f)\n",
|
|
" if os.path.exists(fp):\n",
|
|
" total += os.path.getsize(fp)\n",
|
|
" return total / (1024*1024)\n",
|
|
"\n",
|
|
"def cleanup_path(path):\n",
|
|
" if os.path.isfile(path):\n",
|
|
" os.remove(path)\n",
|
|
" elif os.path.isdir(path):\n",
|
|
" shutil.rmtree(path, ignore_errors=True)\n",
|
|
" for suffix in ['.db', '.pickle', '.graphml']:\n",
|
|
" p = path + suffix\n",
|
|
" if os.path.exists(p):\n",
|
|
" os.remove(p)\n",
|
|
"\n",
|
|
"print(f'Benchmark queries: {len(BENCH_QUERIES)}')\n",
|
|
"for qid, desc in BENCH_QUERIES:\n",
|
|
" print(f' {qid}: {desc}')"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"id": "section-3",
|
|
"metadata": {},
|
|
"source": [
|
|
"## 3. Backend: NetworkX (baseline)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"id": "networkx-impl",
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"import networkx as nx\n",
|
|
"import pickle\n",
|
|
"\n",
|
|
"def nx_insert(nodes, edges_list, path):\n",
|
|
" G = nx.DiGraph()\n",
|
|
" for nid, attrs in nodes.items():\n",
|
|
" G.add_node(nid, **{k: v for k, v in attrs.items() if isinstance(v, (str, int, float, bool))})\n",
|
|
" for src, tgt, rel in edges_list:\n",
|
|
" G.add_edge(src, tgt, relation=rel)\n",
|
|
" return G\n",
|
|
"\n",
|
|
"def nx_queries(G):\n",
|
|
" results = {}\n",
|
|
" \n",
|
|
" # direct_deps\n",
|
|
" if 'filter_slice_go_core' in G:\n",
|
|
" results['direct_deps'] = list(G.successors('filter_slice_go_core'))\n",
|
|
" else:\n",
|
|
" results['direct_deps'] = []\n",
|
|
" \n",
|
|
" # reverse_deps\n",
|
|
" if 'error_go_core' in G:\n",
|
|
" results['reverse_deps'] = list(G.predecessors('error_go_core'))\n",
|
|
" else:\n",
|
|
" results['reverse_deps'] = []\n",
|
|
" \n",
|
|
" # two_hop\n",
|
|
" two_hop = set()\n",
|
|
" if 'init_metabase_go_pipelines' in G:\n",
|
|
" for n1 in G.successors('init_metabase_go_pipelines'):\n",
|
|
" for n2 in G.successors(n1):\n",
|
|
" two_hop.add(n2)\n",
|
|
" results['two_hop'] = list(two_hop)\n",
|
|
" \n",
|
|
" # domain_subgraph\n",
|
|
" finance_nodes = [n for n, d in G.nodes(data=True) if d.get('domain') == 'finance']\n",
|
|
" finance_edges = [(u, v) for u, v in G.edges() if u in finance_nodes and v in finance_nodes]\n",
|
|
" results['domain_subgraph'] = finance_edges\n",
|
|
" \n",
|
|
" # most_connected\n",
|
|
" degree = sorted(((n, G.in_degree(n) + G.out_degree(n)) for n in G.nodes()), key=lambda x: -x[1])[:5]\n",
|
|
" results['most_connected'] = degree\n",
|
|
" \n",
|
|
" # path_exists\n",
|
|
" if 'error_go_core' in G:\n",
|
|
" has_path = any(\n",
|
|
" nx.has_path(G, n, 'error_go_core')\n",
|
|
" for n in finance_nodes if n != 'error_go_core'\n",
|
|
" )\n",
|
|
" results['path_exists'] = has_path\n",
|
|
" else:\n",
|
|
" results['path_exists'] = False\n",
|
|
" \n",
|
|
" # isolated\n",
|
|
" results['isolated'] = [n for n in G.nodes() if G.degree(n) == 0]\n",
|
|
" \n",
|
|
" # type_users\n",
|
|
" if 'SMA_go_finance' in G:\n",
|
|
" results['type_users'] = list(G.predecessors('SMA_go_finance'))\n",
|
|
" else:\n",
|
|
" results['type_users'] = []\n",
|
|
" \n",
|
|
" return results\n",
|
|
"\n",
|
|
"def nx_save(G, path):\n",
|
|
" with open(path + '.pickle', 'wb') as f:\n",
|
|
" pickle.dump(G, f)\n",
|
|
"\n",
|
|
"def nx_load(path):\n",
|
|
" with open(path + '.pickle', 'rb') as f:\n",
|
|
" return pickle.load(f)\n",
|
|
"\n",
|
|
"# Benchmark\n",
|
|
"path = os.path.join(DATA_DIR, 'networkx')\n",
|
|
"cleanup_path(path)\n",
|
|
"\n",
|
|
"t0 = time.perf_counter()\n",
|
|
"G_nx = nx_insert(node_map, valid_edges, path)\n",
|
|
"nx_insert_time = time.perf_counter() - t0\n",
|
|
"\n",
|
|
"t0 = time.perf_counter()\n",
|
|
"nx_results = nx_queries(G_nx)\n",
|
|
"nx_query_time = time.perf_counter() - t0\n",
|
|
"\n",
|
|
"t0 = time.perf_counter()\n",
|
|
"nx_save(G_nx, path)\n",
|
|
"nx_save_time = time.perf_counter() - t0\n",
|
|
"\n",
|
|
"t0 = time.perf_counter()\n",
|
|
"G_loaded = nx_load(path)\n",
|
|
"_ = list(G_loaded.successors(list(G_loaded.nodes())[0]))\n",
|
|
"nx_load_time = time.perf_counter() - t0\n",
|
|
"\n",
|
|
"nx_disk = dir_size_mb(path + '.pickle')\n",
|
|
"\n",
|
|
"print(f'NetworkX: {G_nx.number_of_nodes()} nodos, {G_nx.number_of_edges()} aristas')\n",
|
|
"print(f' Insert: {nx_insert_time*1000:.1f}ms')\n",
|
|
"print(f' Queries (8): {nx_query_time*1000:.1f}ms')\n",
|
|
"print(f' Save: {nx_save_time*1000:.1f}ms')\n",
|
|
"print(f' Load+query: {nx_load_time*1000:.1f}ms')\n",
|
|
"print(f' Disco: {nx_disk:.2f}MB')\n",
|
|
"print()\n",
|
|
"for k, v in nx_results.items():\n",
|
|
" if isinstance(v, list) and len(v) > 5:\n",
|
|
" print(f' {k}: {len(v)} resultados — {v[:3]}...')\n",
|
|
" else:\n",
|
|
" print(f' {k}: {v}')"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"id": "section-4",
|
|
"metadata": {},
|
|
"source": [
|
|
"## 4. Backend: Kuzu (Cypher embebido)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"id": "kuzu-impl",
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"import kuzu\n",
|
|
"\n",
|
|
"def kuzu_setup(nodes, edges_list, path):\n",
|
|
" cleanup_path(path)\n",
|
|
" os.makedirs(path, exist_ok=True)\n",
|
|
" db = kuzu.Database(path)\n",
|
|
" conn = kuzu.Connection(db)\n",
|
|
" \n",
|
|
" # Schema\n",
|
|
" conn.execute('CREATE NODE TABLE FnNode(id STRING, name STRING, node_type STRING, '\n",
|
|
" 'kind STRING, lang STRING, domain STRING, purity STRING, '\n",
|
|
" 'description STRING, PRIMARY KEY(id))')\n",
|
|
" conn.execute('CREATE REL TABLE DEPENDS_ON(FROM FnNode TO FnNode, relation STRING)')\n",
|
|
" \n",
|
|
" # Insert nodos\n",
|
|
" for nid, attrs in nodes.items():\n",
|
|
" conn.execute(\n",
|
|
" 'CREATE (n:FnNode {id: $id, name: $name, node_type: $node_type, '\n",
|
|
" 'kind: $kind, lang: $lang, domain: $domain, purity: $purity, '\n",
|
|
" 'description: $desc})',\n",
|
|
" parameters={\n",
|
|
" 'id': nid,\n",
|
|
" 'name': attrs.get('name', ''),\n",
|
|
" 'node_type': attrs.get('node_type', ''),\n",
|
|
" 'kind': attrs.get('kind', ''),\n",
|
|
" 'lang': attrs.get('lang', ''),\n",
|
|
" 'domain': attrs.get('domain', ''),\n",
|
|
" 'purity': attrs.get('purity', ''),\n",
|
|
" 'desc': attrs.get('description', ''),\n",
|
|
" }\n",
|
|
" )\n",
|
|
" \n",
|
|
" # Insert aristas\n",
|
|
" for src, tgt, rel in edges_list:\n",
|
|
" conn.execute(\n",
|
|
" 'MATCH (a:FnNode {id: $src}), (b:FnNode {id: $tgt}) '\n",
|
|
" 'CREATE (a)-[:DEPENDS_ON {relation: $rel}]->(b)',\n",
|
|
" parameters={'src': src, 'tgt': tgt, 'rel': rel}\n",
|
|
" )\n",
|
|
" \n",
|
|
" return db, conn\n",
|
|
"\n",
|
|
"def kuzu_queries(conn):\n",
|
|
" results = {}\n",
|
|
" \n",
|
|
" # direct_deps\n",
|
|
" r = conn.execute('MATCH (a:FnNode {id: \"filter_slice_go_core\"})-[:DEPENDS_ON]->(b) RETURN b.id')\n",
|
|
" results['direct_deps'] = [row[0] for row in r.get_as_df().values]\n",
|
|
" \n",
|
|
" # reverse_deps\n",
|
|
" r = conn.execute('MATCH (a)-[:DEPENDS_ON]->(b:FnNode {id: \"error_go_core\"}) RETURN a.id')\n",
|
|
" results['reverse_deps'] = [row[0] for row in r.get_as_df().values]\n",
|
|
" \n",
|
|
" # two_hop\n",
|
|
" r = conn.execute(\n",
|
|
" 'MATCH (a:FnNode {id: \"init_metabase_go_pipelines\"})-[:DEPENDS_ON]->()-[:DEPENDS_ON]->(c) '\n",
|
|
" 'RETURN DISTINCT c.id'\n",
|
|
" )\n",
|
|
" results['two_hop'] = [row[0] for row in r.get_as_df().values]\n",
|
|
" \n",
|
|
" # domain_subgraph\n",
|
|
" r = conn.execute(\n",
|
|
" 'MATCH (a:FnNode {domain: \"finance\"})-[e:DEPENDS_ON]->(b:FnNode {domain: \"finance\"}) '\n",
|
|
" 'RETURN a.id, b.id'\n",
|
|
" )\n",
|
|
" results['domain_subgraph'] = [(row[0], row[1]) for row in r.get_as_df().values]\n",
|
|
" \n",
|
|
" # most_connected (in+out degree via counting edges)\n",
|
|
" r = conn.execute(\n",
|
|
" 'MATCH (n:FnNode) '\n",
|
|
" 'OPTIONAL MATCH (n)-[e1:DEPENDS_ON]->() '\n",
|
|
" 'OPTIONAL MATCH ()-[e2:DEPENDS_ON]->(n) '\n",
|
|
" 'RETURN n.id, count(DISTINCT e1) + count(DISTINCT e2) AS deg '\n",
|
|
" 'ORDER BY deg DESC LIMIT 5'\n",
|
|
" )\n",
|
|
" results['most_connected'] = [(row[0], row[1]) for row in r.get_as_df().values]\n",
|
|
" \n",
|
|
" # path_exists\n",
|
|
" r = conn.execute(\n",
|
|
" 'MATCH (a:FnNode {domain: \"finance\"})-[:DEPENDS_ON* 1..5]->(b:FnNode {id: \"error_go_core\"}) '\n",
|
|
" 'RETURN a.id LIMIT 1'\n",
|
|
" )\n",
|
|
" results['path_exists'] = len(r.get_as_df()) > 0\n",
|
|
" \n",
|
|
" # isolated\n",
|
|
" r = conn.execute(\n",
|
|
" 'MATCH (n:FnNode) WHERE NOT EXISTS { MATCH (n)-[:DEPENDS_ON]->() } '\n",
|
|
" 'AND NOT EXISTS { MATCH ()-[:DEPENDS_ON]->(n) } RETURN n.id'\n",
|
|
" )\n",
|
|
" results['isolated'] = [row[0] for row in r.get_as_df().values]\n",
|
|
" \n",
|
|
" # type_users\n",
|
|
" r = conn.execute(\n",
|
|
" 'MATCH (a)-[:DEPENDS_ON {relation: \"uses_type\"}]->(b:FnNode {id: \"SMA_go_finance\"}) RETURN a.id'\n",
|
|
" )\n",
|
|
" results['type_users'] = [row[0] for row in r.get_as_df().values]\n",
|
|
" \n",
|
|
" return results\n",
|
|
"\n",
|
|
"# Benchmark\n",
|
|
"path = os.path.join(DATA_DIR, 'kuzu')\n",
|
|
"\n",
|
|
"t0 = time.perf_counter()\n",
|
|
"kuzu_db, kuzu_conn = kuzu_setup(node_map, valid_edges, path)\n",
|
|
"kuzu_insert_time = time.perf_counter() - t0\n",
|
|
"\n",
|
|
"t0 = time.perf_counter()\n",
|
|
"kuzu_results = kuzu_queries(kuzu_conn)\n",
|
|
"kuzu_query_time = time.perf_counter() - t0\n",
|
|
"\n",
|
|
"kuzu_disk = dir_size_mb(path)\n",
|
|
"\n",
|
|
"# Load from cold\n",
|
|
"del kuzu_conn, kuzu_db\n",
|
|
"t0 = time.perf_counter()\n",
|
|
"kuzu_db2 = kuzu.Database(path)\n",
|
|
"kuzu_conn2 = kuzu.Connection(kuzu_db2)\n",
|
|
"r = kuzu_conn2.execute('MATCH (a:FnNode {id: \"filter_slice_go_core\"})-[:DEPENDS_ON]->(b) RETURN b.id')\n",
|
|
"_ = r.get_as_df()\n",
|
|
"kuzu_load_time = time.perf_counter() - t0\n",
|
|
"del kuzu_conn2, kuzu_db2\n",
|
|
"\n",
|
|
"print(f'Kuzu:')\n",
|
|
"print(f' Insert: {kuzu_insert_time*1000:.1f}ms')\n",
|
|
"print(f' Queries (8): {kuzu_query_time*1000:.1f}ms')\n",
|
|
"print(f' Load+query: {kuzu_load_time*1000:.1f}ms')\n",
|
|
"print(f' Disco: {kuzu_disk:.2f}MB')\n",
|
|
"print()\n",
|
|
"for k, v in kuzu_results.items():\n",
|
|
" if isinstance(v, list) and len(v) > 5:\n",
|
|
" print(f' {k}: {len(v)} resultados — {v[:3]}...')\n",
|
|
" else:\n",
|
|
" print(f' {k}: {v}')"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"id": "section-5",
|
|
"metadata": {},
|
|
"source": [
|
|
"## 5. Backend: SQLite + CTEs recursivos"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"id": "sqlite-impl",
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"def sqlite_setup(nodes, edges_list, path):\n",
|
|
" dbpath = path + '.db'\n",
|
|
" cleanup_path(dbpath)\n",
|
|
" db = sqlite3.connect(dbpath)\n",
|
|
" db.execute('CREATE TABLE nodes (id TEXT PRIMARY KEY, name TEXT, node_type TEXT, '\n",
|
|
" 'kind TEXT, lang TEXT, domain TEXT, purity TEXT, description TEXT)')\n",
|
|
" db.execute('CREATE TABLE edges (src TEXT, tgt TEXT, relation TEXT, '\n",
|
|
" 'FOREIGN KEY(src) REFERENCES nodes(id), FOREIGN KEY(tgt) REFERENCES nodes(id))')\n",
|
|
" db.execute('CREATE INDEX idx_edges_src ON edges(src)')\n",
|
|
" db.execute('CREATE INDEX idx_edges_tgt ON edges(tgt)')\n",
|
|
" db.execute('CREATE INDEX idx_edges_rel ON edges(relation)')\n",
|
|
" db.execute('CREATE INDEX idx_nodes_domain ON nodes(domain)')\n",
|
|
" \n",
|
|
" db.executemany(\n",
|
|
" 'INSERT INTO nodes VALUES (?,?,?,?,?,?,?,?)',\n",
|
|
" [(nid, a.get('name',''), a.get('node_type',''), a.get('kind',''),\n",
|
|
" a.get('lang',''), a.get('domain',''), a.get('purity',''),\n",
|
|
" a.get('description','')) for nid, a in nodes.items()]\n",
|
|
" )\n",
|
|
" db.executemany('INSERT INTO edges VALUES (?,?,?)', edges_list)\n",
|
|
" db.commit()\n",
|
|
" return db\n",
|
|
"\n",
|
|
"def sqlite_queries(db):\n",
|
|
" results = {}\n",
|
|
" \n",
|
|
" # direct_deps\n",
|
|
" results['direct_deps'] = [r[0] for r in db.execute(\n",
|
|
" 'SELECT tgt FROM edges WHERE src = \"filter_slice_go_core\"'\n",
|
|
" ).fetchall()]\n",
|
|
" \n",
|
|
" # reverse_deps\n",
|
|
" results['reverse_deps'] = [r[0] for r in db.execute(\n",
|
|
" 'SELECT src FROM edges WHERE tgt = \"error_go_core\"'\n",
|
|
" ).fetchall()]\n",
|
|
" \n",
|
|
" # two_hop (CTE recursivo)\n",
|
|
" results['two_hop'] = [r[0] for r in db.execute(\n",
|
|
" 'WITH hop1 AS (SELECT tgt FROM edges WHERE src = \"init_metabase_go_pipelines\"), '\n",
|
|
" 'hop2 AS (SELECT DISTINCT e.tgt FROM edges e JOIN hop1 h ON e.src = h.tgt) '\n",
|
|
" 'SELECT tgt FROM hop2'\n",
|
|
" ).fetchall()]\n",
|
|
" \n",
|
|
" # domain_subgraph\n",
|
|
" results['domain_subgraph'] = db.execute(\n",
|
|
" 'SELECT e.src, e.tgt FROM edges e '\n",
|
|
" 'JOIN nodes n1 ON e.src = n1.id JOIN nodes n2 ON e.tgt = n2.id '\n",
|
|
" 'WHERE n1.domain = \"finance\" AND n2.domain = \"finance\"'\n",
|
|
" ).fetchall()\n",
|
|
" \n",
|
|
" # most_connected\n",
|
|
" results['most_connected'] = db.execute(\n",
|
|
" 'SELECT id, (SELECT COUNT(*) FROM edges WHERE src=id) + '\n",
|
|
" '(SELECT COUNT(*) FROM edges WHERE tgt=id) AS deg '\n",
|
|
" 'FROM nodes ORDER BY deg DESC LIMIT 5'\n",
|
|
" ).fetchall()\n",
|
|
" \n",
|
|
" # path_exists (CTE recursivo con limite de profundidad)\n",
|
|
" results['path_exists'] = len(db.execute(\n",
|
|
" 'WITH RECURSIVE reachable(id, depth) AS ('\n",
|
|
" ' SELECT src, 0 FROM edges e JOIN nodes n ON e.src = n.id WHERE n.domain = \"finance\" '\n",
|
|
" ' UNION '\n",
|
|
" ' SELECT e.tgt, r.depth + 1 FROM edges e JOIN reachable r ON e.src = r.id WHERE r.depth < 5'\n",
|
|
" ') SELECT 1 FROM reachable WHERE id = \"error_go_core\" LIMIT 1'\n",
|
|
" ).fetchall()) > 0\n",
|
|
" \n",
|
|
" # isolated\n",
|
|
" results['isolated'] = [r[0] for r in db.execute(\n",
|
|
" 'SELECT n.id FROM nodes n '\n",
|
|
" 'WHERE NOT EXISTS (SELECT 1 FROM edges WHERE src = n.id) '\n",
|
|
" 'AND NOT EXISTS (SELECT 1 FROM edges WHERE tgt = n.id)'\n",
|
|
" ).fetchall()]\n",
|
|
" \n",
|
|
" # type_users\n",
|
|
" results['type_users'] = [r[0] for r in db.execute(\n",
|
|
" 'SELECT src FROM edges WHERE tgt = \"SMA_go_finance\" AND relation = \"uses_type\"'\n",
|
|
" ).fetchall()]\n",
|
|
" \n",
|
|
" return results\n",
|
|
"\n",
|
|
"# Benchmark\n",
|
|
"path = os.path.join(DATA_DIR, 'sqlite_graph')\n",
|
|
"\n",
|
|
"t0 = time.perf_counter()\n",
|
|
"sqlite_db = sqlite_setup(node_map, valid_edges, path)\n",
|
|
"sqlite_insert_time = time.perf_counter() - t0\n",
|
|
"\n",
|
|
"t0 = time.perf_counter()\n",
|
|
"sqlite_results = sqlite_queries(sqlite_db)\n",
|
|
"sqlite_query_time = time.perf_counter() - t0\n",
|
|
"\n",
|
|
"sqlite_db.close()\n",
|
|
"sqlite_disk = dir_size_mb(path + '.db')\n",
|
|
"\n",
|
|
"t0 = time.perf_counter()\n",
|
|
"db2 = sqlite3.connect(path + '.db')\n",
|
|
"_ = db2.execute('SELECT tgt FROM edges WHERE src = \"filter_slice_go_core\"').fetchall()\n",
|
|
"db2.close()\n",
|
|
"sqlite_load_time = time.perf_counter() - t0\n",
|
|
"\n",
|
|
"print(f'SQLite + CTEs:')\n",
|
|
"print(f' Insert: {sqlite_insert_time*1000:.1f}ms')\n",
|
|
"print(f' Queries (8): {sqlite_query_time*1000:.1f}ms')\n",
|
|
"print(f' Load+query: {sqlite_load_time*1000:.1f}ms')\n",
|
|
"print(f' Disco: {sqlite_disk:.2f}MB')\n",
|
|
"print()\n",
|
|
"for k, v in sqlite_results.items():\n",
|
|
" if isinstance(v, list) and len(v) > 5:\n",
|
|
" print(f' {k}: {len(v)} resultados — {v[:3]}...')\n",
|
|
" else:\n",
|
|
" print(f' {k}: {v}')"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"id": "section-6",
|
|
"metadata": {},
|
|
"source": [
|
|
"## 6. Backend: RDFLib (SPARQL)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"id": "rdflib-impl",
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"from rdflib import Graph as RDFGraph, Namespace, Literal, URIRef\n",
|
|
"from rdflib.namespace import RDF, RDFS\n",
|
|
"\n",
|
|
"FN = Namespace('http://fn-registry.local/')\n",
|
|
"FNREL = Namespace('http://fn-registry.local/rel/')\n",
|
|
"FNPROP = Namespace('http://fn-registry.local/prop/')\n",
|
|
"\n",
|
|
"def rdf_setup(nodes, edges_list, path):\n",
|
|
" g = RDFGraph()\n",
|
|
" g.bind('fn', FN)\n",
|
|
" g.bind('fnrel', FNREL)\n",
|
|
" g.bind('fnprop', FNPROP)\n",
|
|
" \n",
|
|
" for nid, attrs in nodes.items():\n",
|
|
" uri = FN[nid]\n",
|
|
" g.add((uri, RDF.type, FN['Function'] if attrs.get('node_type') == 'function' else FN['Type']))\n",
|
|
" for prop in ['name', 'kind', 'lang', 'domain', 'purity', 'description']:\n",
|
|
" val = attrs.get(prop, '')\n",
|
|
" if val:\n",
|
|
" g.add((uri, FNPROP[prop], Literal(val)))\n",
|
|
" \n",
|
|
" for src, tgt, rel in edges_list:\n",
|
|
" g.add((FN[src], FNREL[rel], FN[tgt]))\n",
|
|
" \n",
|
|
" return g\n",
|
|
"\n",
|
|
"def rdf_queries(g):\n",
|
|
" results = {}\n",
|
|
" \n",
|
|
" # direct_deps\n",
|
|
" r = g.query('SELECT ?b WHERE { fn:filter_slice_go_core ?rel ?b . FILTER(STRSTARTS(STR(?rel), STR(fnrel:))) }',\n",
|
|
" initNs={'fn': FN, 'fnrel': FNREL})\n",
|
|
" results['direct_deps'] = [str(row[0]).replace(str(FN), '') for row in r]\n",
|
|
" \n",
|
|
" # reverse_deps\n",
|
|
" r = g.query('SELECT ?a WHERE { ?a ?rel fn:error_go_core . FILTER(STRSTARTS(STR(?rel), STR(fnrel:))) }',\n",
|
|
" initNs={'fn': FN, 'fnrel': FNREL})\n",
|
|
" results['reverse_deps'] = [str(row[0]).replace(str(FN), '') for row in r]\n",
|
|
" \n",
|
|
" # two_hop\n",
|
|
" r = g.query(\n",
|
|
" 'SELECT DISTINCT ?c WHERE { fn:init_metabase_go_pipelines ?r1 ?b . ?b ?r2 ?c . '\n",
|
|
" 'FILTER(STRSTARTS(STR(?r1), STR(fnrel:))) FILTER(STRSTARTS(STR(?r2), STR(fnrel:))) }',\n",
|
|
" initNs={'fn': FN, 'fnrel': FNREL}\n",
|
|
" )\n",
|
|
" results['two_hop'] = [str(row[0]).replace(str(FN), '') for row in r]\n",
|
|
" \n",
|
|
" # domain_subgraph\n",
|
|
" r = g.query(\n",
|
|
" 'SELECT ?a ?b WHERE { ?a fnprop:domain \"finance\" . ?b fnprop:domain \"finance\" . '\n",
|
|
" '?a ?rel ?b . FILTER(STRSTARTS(STR(?rel), STR(fnrel:))) }',\n",
|
|
" initNs={'fn': FN, 'fnrel': FNREL, 'fnprop': FNPROP}\n",
|
|
" )\n",
|
|
" results['domain_subgraph'] = [(str(row[0]).replace(str(FN), ''), str(row[1]).replace(str(FN), '')) for row in r]\n",
|
|
" \n",
|
|
" # most_connected (SPARQL no tiene degree nativo, contamos)\n",
|
|
" r = g.query(\n",
|
|
" 'SELECT ?n (COUNT(DISTINCT ?e) AS ?deg) WHERE { '\n",
|
|
" '{ ?n ?rel ?o . FILTER(STRSTARTS(STR(?rel), STR(fnrel:))) BIND(?o AS ?e) } '\n",
|
|
" 'UNION '\n",
|
|
" '{ ?s ?rel ?n . FILTER(STRSTARTS(STR(?rel), STR(fnrel:))) BIND(?s AS ?e) } '\n",
|
|
" '} GROUP BY ?n ORDER BY DESC(?deg) LIMIT 5',\n",
|
|
" initNs={'fn': FN, 'fnrel': FNREL}\n",
|
|
" )\n",
|
|
" results['most_connected'] = [(str(row[0]).replace(str(FN), ''), int(row[1])) for row in r]\n",
|
|
" \n",
|
|
" # path_exists (SPARQL 1.1 property paths, max 5 hops)\n",
|
|
" r = g.query(\n",
|
|
" 'ASK WHERE { ?a fnprop:domain \"finance\" . '\n",
|
|
" '?a (fnrel:uses_function|fnrel:uses_type|fnrel:returns|fnrel:error_type){1,5} fn:error_go_core }',\n",
|
|
" initNs={'fn': FN, 'fnrel': FNREL, 'fnprop': FNPROP}\n",
|
|
" )\n",
|
|
" results['path_exists'] = bool(r)\n",
|
|
" \n",
|
|
" # isolated\n",
|
|
" r = g.query(\n",
|
|
" 'SELECT ?n WHERE { ?n a ?type . FILTER(?type IN (fn:Function, fn:Type)) '\n",
|
|
" 'FILTER NOT EXISTS { ?n ?rel ?o . FILTER(STRSTARTS(STR(?rel), STR(fnrel:))) } '\n",
|
|
" 'FILTER NOT EXISTS { ?s ?rel2 ?n . FILTER(STRSTARTS(STR(?rel2), STR(fnrel:))) } }',\n",
|
|
" initNs={'fn': FN, 'fnrel': FNREL}\n",
|
|
" )\n",
|
|
" results['isolated'] = [str(row[0]).replace(str(FN), '') for row in r]\n",
|
|
" \n",
|
|
" # type_users\n",
|
|
" r = g.query('SELECT ?a WHERE { ?a fnrel:uses_type fn:SMA_go_finance }',\n",
|
|
" initNs={'fn': FN, 'fnrel': FNREL})\n",
|
|
" results['type_users'] = [str(row[0]).replace(str(FN), '') for row in r]\n",
|
|
" \n",
|
|
" return results\n",
|
|
"\n",
|
|
"# Benchmark\n",
|
|
"path = os.path.join(DATA_DIR, 'rdflib')\n",
|
|
"\n",
|
|
"t0 = time.perf_counter()\n",
|
|
"g_rdf = rdf_setup(node_map, valid_edges, path)\n",
|
|
"rdf_insert_time = time.perf_counter() - t0\n",
|
|
"\n",
|
|
"t0 = time.perf_counter()\n",
|
|
"rdf_results = rdf_queries(g_rdf)\n",
|
|
"rdf_query_time = time.perf_counter() - t0\n",
|
|
"\n",
|
|
"t0 = time.perf_counter()\n",
|
|
"g_rdf.serialize(destination=path + '.ttl', format='turtle')\n",
|
|
"rdf_save_time = time.perf_counter() - t0\n",
|
|
"\n",
|
|
"rdf_disk = dir_size_mb(path + '.ttl')\n",
|
|
"\n",
|
|
"t0 = time.perf_counter()\n",
|
|
"g2 = RDFGraph()\n",
|
|
"g2.parse(path + '.ttl', format='turtle')\n",
|
|
"_ = list(g2.query('SELECT ?b WHERE { fn:filter_slice_go_core ?r ?b . FILTER(STRSTARTS(STR(?r), STR(fnrel:))) }',\n",
|
|
" initNs={'fn': FN, 'fnrel': FNREL}))\n",
|
|
"rdf_load_time = time.perf_counter() - t0\n",
|
|
"\n",
|
|
"print(f'RDFLib: {len(g_rdf)} triples')\n",
|
|
"print(f' Insert: {rdf_insert_time*1000:.1f}ms')\n",
|
|
"print(f' Queries (8): {rdf_query_time*1000:.1f}ms')\n",
|
|
"print(f' Save (turtle): {rdf_save_time*1000:.1f}ms')\n",
|
|
"print(f' Load+query: {rdf_load_time*1000:.1f}ms')\n",
|
|
"print(f' Disco: {rdf_disk:.2f}MB')\n",
|
|
"print()\n",
|
|
"for k, v in rdf_results.items():\n",
|
|
" if isinstance(v, list) and len(v) > 5:\n",
|
|
" print(f' {k}: {len(v)} resultados — {v[:3]}...')\n",
|
|
" else:\n",
|
|
" print(f' {k}: {v}')"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"id": "section-7",
|
|
"metadata": {},
|
|
"source": [
|
|
"## 7. Backend: igraph"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"id": "igraph-impl",
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"import igraph as ig\n",
|
|
"\n",
|
|
"def igraph_setup(nodes, edges_list, path):\n",
|
|
" node_ids = list(nodes.keys())\n",
|
|
" id_to_idx = {nid: i for i, nid in enumerate(node_ids)}\n",
|
|
" \n",
|
|
" g = ig.Graph(directed=True)\n",
|
|
" g.add_vertices(len(node_ids))\n",
|
|
" g.vs['node_id'] = node_ids\n",
|
|
" g.vs['name'] = [nodes[nid].get('name', '') for nid in node_ids]\n",
|
|
" g.vs['node_type'] = [nodes[nid].get('node_type', '') for nid in node_ids]\n",
|
|
" g.vs['domain'] = [nodes[nid].get('domain', '') for nid in node_ids]\n",
|
|
" g.vs['purity'] = [nodes[nid].get('purity', '') for nid in node_ids]\n",
|
|
" g.vs['kind'] = [nodes[nid].get('kind', '') for nid in node_ids]\n",
|
|
" g.vs['lang'] = [nodes[nid].get('lang', '') for nid in node_ids]\n",
|
|
" \n",
|
|
" edge_tuples = [(id_to_idx[s], id_to_idx[t]) for s, t, _ in edges_list]\n",
|
|
" edge_rels = [r for _, _, r in edges_list]\n",
|
|
" g.add_edges(edge_tuples)\n",
|
|
" g.es['relation'] = edge_rels\n",
|
|
" \n",
|
|
" return g, id_to_idx\n",
|
|
"\n",
|
|
"def igraph_queries(g, id_to_idx):\n",
|
|
" results = {}\n",
|
|
" idx_to_id = {v: k for k, v in id_to_idx.items()}\n",
|
|
" \n",
|
|
" # direct_deps\n",
|
|
" if 'filter_slice_go_core' in id_to_idx:\n",
|
|
" idx = id_to_idx['filter_slice_go_core']\n",
|
|
" results['direct_deps'] = [idx_to_id[n] for n in g.neighbors(idx, mode='out')]\n",
|
|
" else:\n",
|
|
" results['direct_deps'] = []\n",
|
|
" \n",
|
|
" # reverse_deps\n",
|
|
" if 'error_go_core' in id_to_idx:\n",
|
|
" idx = id_to_idx['error_go_core']\n",
|
|
" results['reverse_deps'] = [idx_to_id[n] for n in g.neighbors(idx, mode='in')]\n",
|
|
" else:\n",
|
|
" results['reverse_deps'] = []\n",
|
|
" \n",
|
|
" # two_hop\n",
|
|
" if 'init_metabase_go_pipelines' in id_to_idx:\n",
|
|
" idx = id_to_idx['init_metabase_go_pipelines']\n",
|
|
" hop1 = g.neighbors(idx, mode='out')\n",
|
|
" hop2 = set()\n",
|
|
" for n in hop1:\n",
|
|
" hop2.update(g.neighbors(n, mode='out'))\n",
|
|
" results['two_hop'] = [idx_to_id[n] for n in hop2]\n",
|
|
" else:\n",
|
|
" results['two_hop'] = []\n",
|
|
" \n",
|
|
" # domain_subgraph\n",
|
|
" finance_idxs = set(v.index for v in g.vs.select(domain='finance'))\n",
|
|
" finance_edges = [(idx_to_id[e.source], idx_to_id[e.target])\n",
|
|
" for e in g.es if e.source in finance_idxs and e.target in finance_idxs]\n",
|
|
" results['domain_subgraph'] = finance_edges\n",
|
|
" \n",
|
|
" # most_connected\n",
|
|
" degrees = [(idx_to_id[i], g.degree(i, mode='all')) for i in range(g.vcount())]\n",
|
|
" degrees.sort(key=lambda x: -x[1])\n",
|
|
" results['most_connected'] = degrees[:5]\n",
|
|
" \n",
|
|
" # path_exists\n",
|
|
" if 'error_go_core' in id_to_idx:\n",
|
|
" target = id_to_idx['error_go_core']\n",
|
|
" finance_idxs_list = list(finance_idxs)\n",
|
|
" has_path = any(\n",
|
|
" len(g.get_shortest_paths(src, to=target, mode='out')[0]) > 0\n",
|
|
" for src in finance_idxs_list if src != target\n",
|
|
" )\n",
|
|
" results['path_exists'] = has_path\n",
|
|
" else:\n",
|
|
" results['path_exists'] = False\n",
|
|
" \n",
|
|
" # isolated\n",
|
|
" results['isolated'] = [idx_to_id[v.index] for v in g.vs if g.degree(v.index, mode='all') == 0]\n",
|
|
" \n",
|
|
" # type_users\n",
|
|
" if 'SMA_go_finance' in id_to_idx:\n",
|
|
" idx = id_to_idx['SMA_go_finance']\n",
|
|
" preds = g.neighbors(idx, mode='in')\n",
|
|
" # Filtrar por relacion uses_type\n",
|
|
" type_user_idxs = []\n",
|
|
" for p in preds:\n",
|
|
" eid = g.get_eid(p, idx)\n",
|
|
" if g.es[eid]['relation'] == 'uses_type':\n",
|
|
" type_user_idxs.append(p)\n",
|
|
" results['type_users'] = [idx_to_id[n] for n in type_user_idxs]\n",
|
|
" else:\n",
|
|
" results['type_users'] = []\n",
|
|
" \n",
|
|
" return results\n",
|
|
"\n",
|
|
"# Benchmark\n",
|
|
"path = os.path.join(DATA_DIR, 'igraph')\n",
|
|
"\n",
|
|
"t0 = time.perf_counter()\n",
|
|
"g_ig, ig_id_map = igraph_setup(node_map, valid_edges, path)\n",
|
|
"ig_insert_time = time.perf_counter() - t0\n",
|
|
"\n",
|
|
"t0 = time.perf_counter()\n",
|
|
"ig_results = igraph_queries(g_ig, ig_id_map)\n",
|
|
"ig_query_time = time.perf_counter() - t0\n",
|
|
"\n",
|
|
"t0 = time.perf_counter()\n",
|
|
"g_ig.write_pickle(path + '.pickle')\n",
|
|
"ig_save_time = time.perf_counter() - t0\n",
|
|
"\n",
|
|
"ig_disk = dir_size_mb(path + '.pickle')\n",
|
|
"\n",
|
|
"t0 = time.perf_counter()\n",
|
|
"g_loaded = ig.Graph.Read_Pickle(path + '.pickle')\n",
|
|
"_ = g_loaded.neighbors(0, mode='out')\n",
|
|
"ig_load_time = time.perf_counter() - t0\n",
|
|
"\n",
|
|
"print(f'igraph: {g_ig.vcount()} vertices, {g_ig.ecount()} aristas')\n",
|
|
"print(f' Insert: {ig_insert_time*1000:.1f}ms')\n",
|
|
"print(f' Queries (8): {ig_query_time*1000:.1f}ms')\n",
|
|
"print(f' Save: {ig_save_time*1000:.1f}ms')\n",
|
|
"print(f' Load+query: {ig_load_time*1000:.1f}ms')\n",
|
|
"print(f' Disco: {ig_disk:.2f}MB')\n",
|
|
"print()\n",
|
|
"for k, v in ig_results.items():\n",
|
|
" if isinstance(v, list) and len(v) > 5:\n",
|
|
" print(f' {k}: {len(v)} resultados — {v[:3]}...')\n",
|
|
" else:\n",
|
|
" print(f' {k}: {v}')"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"id": "section-8",
|
|
"metadata": {},
|
|
"source": [
|
|
"## 8. Tabla resumen y visualizaciones"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"id": "summary",
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"summary_data = [\n",
|
|
" {'Backend': 'NetworkX', 'Insert (ms)': round(nx_insert_time*1000, 1),\n",
|
|
" 'Queries 8x (ms)': round(nx_query_time*1000, 1),\n",
|
|
" 'Save (ms)': round(nx_save_time*1000, 1),\n",
|
|
" 'Load+query (ms)': round(nx_load_time*1000, 1),\n",
|
|
" 'Disk (MB)': round(nx_disk, 2),\n",
|
|
" 'Query Language': 'Python API'},\n",
|
|
" {'Backend': 'Kuzu', 'Insert (ms)': round(kuzu_insert_time*1000, 1),\n",
|
|
" 'Queries 8x (ms)': round(kuzu_query_time*1000, 1),\n",
|
|
" 'Save (ms)': 0, # auto-persist\n",
|
|
" 'Load+query (ms)': round(kuzu_load_time*1000, 1),\n",
|
|
" 'Disk (MB)': round(kuzu_disk, 2),\n",
|
|
" 'Query Language': 'Cypher'},\n",
|
|
" {'Backend': 'SQLite+CTE', 'Insert (ms)': round(sqlite_insert_time*1000, 1),\n",
|
|
" 'Queries 8x (ms)': round(sqlite_query_time*1000, 1),\n",
|
|
" 'Save (ms)': 0, # auto-persist\n",
|
|
" 'Load+query (ms)': round(sqlite_load_time*1000, 1),\n",
|
|
" 'Disk (MB)': round(sqlite_disk, 2),\n",
|
|
" 'Query Language': 'SQL + CTEs'},\n",
|
|
" {'Backend': 'RDFLib', 'Insert (ms)': round(rdf_insert_time*1000, 1),\n",
|
|
" 'Queries 8x (ms)': round(rdf_query_time*1000, 1),\n",
|
|
" 'Save (ms)': round(rdf_save_time*1000, 1),\n",
|
|
" 'Load+query (ms)': round(rdf_load_time*1000, 1),\n",
|
|
" 'Disk (MB)': round(rdf_disk, 2),\n",
|
|
" 'Query Language': 'SPARQL'},\n",
|
|
" {'Backend': 'igraph', 'Insert (ms)': round(ig_insert_time*1000, 1),\n",
|
|
" 'Queries 8x (ms)': round(ig_query_time*1000, 1),\n",
|
|
" 'Save (ms)': round(ig_save_time*1000, 1),\n",
|
|
" 'Load+query (ms)': round(ig_load_time*1000, 1),\n",
|
|
" 'Disk (MB)': round(ig_disk, 2),\n",
|
|
" 'Query Language': 'Python API'},\n",
|
|
"]\n",
|
|
"\n",
|
|
"df_summary = pd.DataFrame(summary_data)\n",
|
|
"print(df_summary.to_string(index=False))\n",
|
|
"print()\n",
|
|
"\n",
|
|
"# Grafico comparativo\n",
|
|
"fig, axes = plt.subplots(1, 3, figsize=(18, 6))\n",
|
|
"colors = {'NetworkX': '#e74c3c', 'Kuzu': '#3498db', 'SQLite+CTE': '#2ecc71', 'RDFLib': '#f39c12', 'igraph': '#9b59b6'}\n",
|
|
"\n",
|
|
"# Insert\n",
|
|
"ax = axes[0]\n",
|
|
"ax.barh(df_summary['Backend'], df_summary['Insert (ms)'], color=[colors[b] for b in df_summary['Backend']])\n",
|
|
"ax.set_xlabel('ms')\n",
|
|
"ax.set_title('Insert (nodos + aristas)')\n",
|
|
"\n",
|
|
"# Queries\n",
|
|
"ax = axes[1]\n",
|
|
"ax.barh(df_summary['Backend'], df_summary['Queries 8x (ms)'], color=[colors[b] for b in df_summary['Backend']])\n",
|
|
"ax.set_xlabel('ms')\n",
|
|
"ax.set_title('8 queries de traversal')\n",
|
|
"\n",
|
|
"# Load + query\n",
|
|
"ax = axes[2]\n",
|
|
"ax.barh(df_summary['Backend'], df_summary['Load+query (ms)'], color=[colors[b] for b in df_summary['Backend']])\n",
|
|
"ax.set_xlabel('ms')\n",
|
|
"ax.set_title('Cold start: load + 1 query')\n",
|
|
"\n",
|
|
"plt.suptitle(f'Comparativa de graph backends ({len(all_node_ids)} nodos, {len(valid_edges)} aristas)', fontsize=14)\n",
|
|
"plt.tight_layout()\n",
|
|
"plt.show()"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"id": "section-9",
|
|
"metadata": {},
|
|
"source": [
|
|
"## 9. Validacion cruzada de resultados\n",
|
|
"\n",
|
|
"Verificamos que todos los backends devuelven los mismos resultados para cada query."
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"id": "cross-validate",
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"all_backend_results = {\n",
|
|
" 'NetworkX': nx_results,\n",
|
|
" 'Kuzu': kuzu_results,\n",
|
|
" 'SQLite+CTE': sqlite_results,\n",
|
|
" 'RDFLib': rdf_results,\n",
|
|
" 'igraph': ig_results,\n",
|
|
"}\n",
|
|
"\n",
|
|
"print('Validacion cruzada de resultados:')\n",
|
|
"print('=' * 60)\n",
|
|
"\n",
|
|
"for query_name in ['direct_deps', 'reverse_deps', 'two_hop', 'isolated', 'type_users', 'path_exists']:\n",
|
|
" print(f'\\n{query_name}:')\n",
|
|
" values = {}\n",
|
|
" for backend, results in all_backend_results.items():\n",
|
|
" val = results.get(query_name)\n",
|
|
" if isinstance(val, list):\n",
|
|
" values[backend] = sorted(str(v) for v in val)\n",
|
|
" else:\n",
|
|
" values[backend] = val\n",
|
|
" \n",
|
|
" # Comparar\n",
|
|
" ref_backend = 'NetworkX'\n",
|
|
" ref_val = values[ref_backend]\n",
|
|
" all_match = True\n",
|
|
" for backend, val in values.items():\n",
|
|
" match = val == ref_val\n",
|
|
" status = 'OK' if match else 'DIFF'\n",
|
|
" if isinstance(val, list):\n",
|
|
" print(f' {backend:12s}: {len(val)} items [{status}]')\n",
|
|
" else:\n",
|
|
" print(f' {backend:12s}: {val} [{status}]')\n",
|
|
" if not match:\n",
|
|
" all_match = False\n",
|
|
" if isinstance(val, list) and isinstance(ref_val, list):\n",
|
|
" extra = set(val) - set(ref_val)\n",
|
|
" missing = set(ref_val) - set(val)\n",
|
|
" if extra: print(f' extra: {list(extra)[:5]}')\n",
|
|
" if missing: print(f' missing: {list(missing)[:5]}')"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"id": "section-10",
|
|
"metadata": {},
|
|
"source": [
|
|
"## 10. Conclusiones notebook 01\n",
|
|
"\n",
|
|
"Este notebook establece:\n",
|
|
"- El grafo de dependencias del fn_registry cargado en 5 backends\n",
|
|
"- Benchmark de rendimiento (insert, queries, persistencia)\n",
|
|
"- Validacion cruzada de correctitud\n",
|
|
"\n",
|
|
"**Siguiente notebook (02):** LLM retrieval — usar `claude -p` para generar queries en cada lenguaje (Cypher, SQL, SPARQL, Python API) y evaluar correctitud vs las respuestas verificadas."
|
|
]
|
|
}
|
|
],
|
|
"metadata": {
|
|
"kernelspec": {
|
|
"display_name": "Python 3 (ipykernel)",
|
|
"language": "python",
|
|
"name": "python3"
|
|
},
|
|
"language_info": {
|
|
"codemirror_mode": {
|
|
"name": "ipython",
|
|
"version": 3
|
|
},
|
|
"file_extension": ".py",
|
|
"mimetype": "text/x-python",
|
|
"name": "python",
|
|
"nbconvert_exporter": "python",
|
|
"pygments_lexer": "ipython3",
|
|
"version": "3.13.7"
|
|
}
|
|
},
|
|
"nbformat": 4,
|
|
"nbformat_minor": 5
|
|
}
|