Documentación técnica para datasets BIM sintéticos.

Qué es un dataset BIM sintético.

Un dataset BIM sintético es un conjunto de datos generado artificialmente a partir de reglas de modelación, semántica IFC y patrones constructivos controlados. No corresponde a un proyecto real anonimizado: se crea desde cero para producir volumen, variación y trazabilidad sin exponer propiedad intelectual ni información sensible.

Primer recorrido técnico.

El objetivo del quickstart es pasar desde la descarga del ZIP a una primera lectura programática, una carga en Neo4j y una revisión de las capas ML y LLM.

# 1) Descomprimir el paquete
unzip buildata-residential-batch-v1.zip -d buildata-sample
cd buildata-sample/buildata-residential-batch

# 2) Revisar metadatos globales
cat metadata/dataset.json
cat metadata/statistics.json

# 3) Ver una muestra de nodos y relaciones con Python
python - <<'PY'
import json
from pathlib import Path
nodes = json.loads(Path('buildata/nodes.json').read_text())
edges = json.loads(Path('buildata/edges.json').read_text())
print('nodes:', len(nodes))
print('edges:', len(edges))
print('first node:', nodes[0])
PY

Capas organizadas por uso técnico.

Los paquetes Buildata mantienen una raíz común y carpetas por capa. La estructura exacta puede variar según el plan, pero el principio es el mismo: separar datos fuente, representación semántica, exportaciones de IA y documentación de auditoría.

buildata-residential-batch/
  metadata/                 # manifiesto, estadísticas y ficha global
  buildata/                 # grafo BIM base: nodes, edges, tasks y métricas
  buildings/                # carpetas por edificio sintético
    building_000001/
      metadata.json
      nodes.json
      edges.json
      tasks.json
      quality.json
      llm_tasks.jsonl
      graph.json
  ifc/                      # modelos IFC sintéticos exportables
  graph/                    # dataset de grafo e índice global
  gnn/                      # representación preparada para graph learning
  ml/                       # tablas, features y splits de entrenamiento
  llm/                      # instrucciones, razonamiento y QA en JSONL
  neo4j/                    # scripts Cypher y metadatos para property graph
  docs/                     # documentación técnica incluida en el paquete
  vision/                   # capa opcional: RGB, COCO, ImageNet y PASCAL VOC

Diccionario técnico de archivos.

Cada archivo cumple un rol dentro del pipeline. Algunos sirven como fuente semántica, otros como artefactos de entrenamiento y otros como evidencia de calidad o trazabilidad.

Del modelo IFC a una red semántica entrenable.

En Buildata, un nodo representa una entidad BIM o semántica —por ejemplo un muro, espacio, nivel, material o propiedad— y una relación representa una conexión explícita entre esas entidades. Esta abstracción permite consultar, razonar y entrenar modelos sobre la estructura del edificio.

{
  "id": "wall_000142",
  "ifc_class": "IfcWall",
  "global_id": "synthetic-guid",
  "name": "Exterior Wall 142",
  "psets": { "Pset_WallCommon": { "IsExternal": true } },
  "features": { "area": 24.8, "level_index": 2 }
}

{
  "source": "building_storey_02",
  "target": "wall_000142",
  "type": "CONTAINS",
  "ifc_relation": "IfcRelContainedInSpatialStructure"
}

// Ejemplo Cypher: muros exteriores por nivel
MATCH (s:IfcBuildingStorey)-[:CONTAINS]->(w:IfcWall)
WHERE w.IsExternal = true
RETURN s.Name AS nivel, count(w) AS muros_exteriores
ORDER BY nivel;

Features, labels y splits reproducibles.

La capa ML transforma información BIM en registros tabulares o tareas estructuradas. Esto permite entrenar modelos clásicos, AutoML o redes simples sin tener que parsear IFC directamente.

# Ejemplo: leer una tabla ML y separar features/label
import pandas as pd

 df = pd.read_csv('ml/ml_tabular.csv')
label = 'target_class'
X = df.drop(columns=[label])
y = df[label]
print(X.shape, y.value_counts().head())

Instrucciones, razonamiento y QA técnico.

La capa LLM empaqueta conocimiento BIM en JSONL para entrenamiento, evaluación o recuperación aumentada. No reemplaza al IFC ni al grafo: los convierte en ejemplos legibles por modelos de lenguaje.

{"instruction":"Identifica la clase IFC más probable para el elemento descrito.","input":{"name":"Exterior Wall 142","properties":{"IsExternal":true}},"output":"IfcWall"}
{"question":"¿Qué elementos contiene el segundo nivel?","context_ids":["building_storey_02"],"answer":"Contiene muros, losas, puertas, ventanas y espacios asociados al nivel."}

Dataset de imagen desde IFC sintético.

La capa visual convierte modelos IFC sintéticos en renders RGB y anotaciones listas para entrenamiento. Puede entregarse como paquete separado para no mezclar archivos pesados con las capas estructurales.

Datos sintéticos para probar interoperabilidad.

Un dataset Buildata puede usarse para probar herramientas openBIM sin depender de proyectos reales. La clave es comparar la misma semántica en IFC, JSON, grafo y reportes de calidad.

Patrones mínimos de uso.

Estos ejemplos son intencionalmente simples: sirven como punto de partida para conectar el dataset con bases de grafos, notebooks, validadores o pipelines de entrenamiento.

Cargar en Neo4j

# Con Neo4j activo localmente
cypher-shell -u neo4j -p password -f neo4j/cypher_import.cypher

# Consulta de verificación
MATCH (n) RETURN labels(n) AS labels, count(*) AS total ORDER BY total DESC LIMIT 10;

Leer nodos con Python

import json
from pathlib import Path

nodes = json.loads(Path('buildata/nodes.json').read_text())
walls = [n for n in nodes if n.get('ifc_class') == 'IfcWall']
print(f'Muros encontrados: {len(walls)}')

Entrenar un clasificador simple

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report

df = pd.read_csv('ml/ml_tabular.csv')
label = 'target_class'
X = pd.get_dummies(df.drop(columns=[label]))
y = df[label]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
model = RandomForestClassifier(random_state=42)
model.fit(X_train, y_train)
print(classification_report(y_test, model.predict(X_test)))

Preparar un dataset LLM

import json
from pathlib import Path

path = Path('llm/instruction_dataset.jsonl')
examples = [json.loads(line) for line in path.read_text().splitlines() if line.strip()]
print('ejemplos:', len(examples))
print(examples[0].keys())

Validar estructura IFC básica

# Ejemplo conceptual con IfcOpenShell
import ifcopenshell

model = ifcopenshell.open('ifc/building_000001.ifc')
print('Muros:', len(model.by_type('IfcWall')))
print('Espacios:', len(model.by_type('IfcSpace')))
print('Relaciones espaciales:', len(model.by_type('IfcRelContainedInSpatialStructure')))