Starte an der Grenze, denn dort ist die Idee am saubersten. Ein Paper zum ICML 2026 — VecMol, von Yuchen Hua, Xingang Peng, Jianzhu Ma und Muhan Zhang, zusammengefasst auf Lacuna — hört auf, ein Molekül als Sack von Atomen mit x-, y-, z-Koordinaten zu behandeln, und stellt es stattdessen als kontinuierliches Vektorfeld dar. Der Punkt, der für uns zählt, ist nicht die Chemie. Es ist, dass eine Gruppe von Forschern das härteste Darstellungsproblem ihres Fachs anschaute und es auf dieselbe Weise beantwortete wie jeder andere: Das Ding in Vektoren umwandeln, dann Mathe.

Das ist der ganze Trick des modernen Machine Learning, und es ist stillschweigend derselbe Trick, den deine BIM-Tools gleich mit deiner Detailbibliothek machen werden. Ein Vektor ist nicht exotisch. Wie das GeeksforGeeks-Primer zu Vektoren für ML schlicht sagt, ist es nur „eine geordnete Liste von Zahlen, wobei jede Zahl ein Merkmal darstellt.” Eine Person ist [170, 65]. Ein Wanddetail ist eine längere Liste. Eine ganze IFC-Elementbeschreibung ist, einmal eingebettet, eine Liste aus ein paar hundert Floats. Lerne, diese Listen zu bauen und zu vergleichen, und du hast die Primitive unter Embeddings, Retrieval, Ähnlichkeitssuche und jeder RAG-Pipeline, die dein Büro gleich kaufen wird, ohne die Anleitung zu lesen.

Das Werkzeug: NumPy

Das Werkzeug: NumPy, die Numerical-Array-Bibliothek, die Travis Oliphant 2006 zum ersten Mal auslieferte, indem er die älteren Numeric- und Numarray-Projekte fusionierte, jetzt von einer grossen Open-Source-Community gepflegt. Es lohnt sich für einen Computational Designer einen Nachmittag lang, weil es die Schicht ist, auf der alles andere aufbaut — PyTorch, scikit-learn, jeder Embedding-Aufruf, den du machst — und weil ein NumPy-Vektor klein genug ist, um ihn wirklich zu verstehen. Du kannst das ganze mentale Modell in deinem Kopf halten, was die meisten anderen Teile des Stacks nicht zulassen.

Setup

python -m venv .venv
.venvScriptsactivate      # Windows; on macOS/Linux: source .venv/bin/activate
pip install numpy
python -c "import numpy as np; print('person vector:', np.array([170, 65]))"
# person vector: [170  65]

Erste Schritte

Erste Schritte:

1. Speichere eine Datei vectors.py und baue zwei Merkmalsvektoren: a = np.array([2, 3]) und b = np.array([1, 4]). Gib a + b und np.dot(a, b) aus — Addition kombiniert Merkmale, das Skalarprodukt kollabiert sie zu einer Zahl, die Übereinstimmung misst.
2. Ändere eine Zahl in a und führe es erneut aus. Schau, wie sich das Skalarprodukt bewegt. Der einzelne Skalar ist das, was ein Linear-Regressions-Gewicht, eine SVM-Marge und eine neuronale Aktivierung alle stillschweigend berechnen.
3. Stapele Vektoren in eine Matrix (np.array([[1,2,3],[4,5,6]])) und du hast einen ganzen Datensatz — Reihen sind Datenpunkte, Spalten sind Merkmale. Das ist die Form, die jedes Modell frisst.

←HEUTE: 2026 sind ein Molekül, ein Satz und ein Fassadendetail alle als dasselbe gespeichert — eine Liste von Floats — und NumPy ist das Lineal, das den Abstand zwischen ihnen misst. →3012: Die Büros, deren Wissen überlebt, sind die, die den Rohtext behielten und die Vektoren neu berechnen konnten, wenn der Embedding-Anbieter verschwand. Drehpunkt: Ein Vektor ist portabel auf eine Weise, wie ein proprietäres Objekt es nie war — deshalb lohnt es sich, die Mathematik zu lernen und nicht nur den Knopf.

Warum Richtung Distanz schlägt

Der Moment, in dem Vektoren ihren Lohn auf einem echten Schreibtisch verdienen, ist die Suche. Du hast ein Detail auf dem Bildschirm und 4.000 andere in einem gemeinsamen Ordner, den niemand seit der letzten Büro-Fusion aufgeräumt hat. Du willst nicht die mit der gleichen Grösse; du willst die, die in die gleiche Richtung zeigt. Das ist Cosinus-Ähnlichkeit — der Cosinus des Winkels zwischen zwei Vektoren — und der GeeksforGeeks-Artikel listet sie neben der euklidischen Distanz auf, aus gutem Grund: sie beantworten unterschiedliche Fragen. Euklidisch fragt „wie weit auseinander”, Cosinus fragt „wie ausgerichtet”. Bei Text und Embeddings gewinnt meist die Ausrichtung.

Hier ist der ehrliche Kompromiss, schlicht ausgesprochen: Cosinus-Ähnlichkeit wirft die Grösse absichtlich weg. Zwei Details können ein perfektes 1.0 erreichen und auf unterschiedlichen Skalen gebaut sein, weil die Metrik nur die Richtung sieht. Die Metrik, die du wählst, entscheidet, was „ähnlich” bedeutet, und sie schlecht zu wählen ist, wie eine Suche, die sich schlau anfühlt, vertrauensvoll falsche Nachbarn zurückbringt.

Dieses Versagen hat einen Namen in PAZ’s eigenen Referenzmaterialien. Unsere Konzeptnote zu Context Window Scaling sagt es deutlich: Das Skalierungsgesetz für Retrieval „geht um Kuration, nicht um Vollstopfung” — übergib zehn nützliche Chunks, nicht zwei hundert bloss ähnliche. Gleiche Warnung, eine Abstraktion höher. Ein guter Ähnlichkeitsscore ist eine Nominierung, keine Entscheidung.

Atelier: Für ein Schweizer Büro, das auf Rhino und Grasshopper standardisiert — die PAZ Academy unterrichtet Grasshopper 2 seit Alpha und verkauft die Rhino-8- und WIP-Lizenzen weiter, auf denen das Büro läuft — ist die Erreichung von Vektoren nicht abstrakt. Deine Grasshopper-Leinwand spricht diese Sprache nativ bereits als Vector3d in C# und RhinoCommon; Embeddings erweitern nur die gleiche Idee von Geometrie zu Text und IFC-Metadaten. Der Move am Montag: Wähle deine zehn meistgenutzten Wand- oder Plattendetails, bette ihre kurzen Textbeschreibungen mit irgendeinem lokalen Modell ein, und baue ein 30-Zeilen-NumPy-Cosinus-Such-Skript, das dein Team abfragen kann, statt den Ordner zu scrollen. Ship es hässlich; miss nach, ob es die vier Stunden Einsparung bringt, die es sollte.

Hack: Stufe eine chaotische Detailbibliothek danach auf, wie genau jeder Eintrag mit dem auf deinem Bildschirm ausgerichtet ist. Cosinus-Ähnlichkeit ist das Ganze — Skalarprodukt über das Produkt der Grössen — und es sind die gleichen drei Zeilen, egal ob die Vektoren Moleküle, Sätze oder Plattenkanten beschreiben. Tausche die Spiel-Arrays darunter gegen echte Embeddings, und es skaliert unverändert.

import numpy as np
def cosine(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
target  = np.array([0.8, 0.1, 0.3])                       # das Detail, das du hast
library = np.array([[0.7, 0.2, 0.4], [0.1, 0.9, 0.0]])   # der Ordner
print([round(cosine(target, row), 3) for row in library])
# [0.973, 0.257]  -> row 0 ist dein Match

Das Schreiben der Generation von der anderen Seite erinnert sich an eine Lektion, die es wert ist zu packen: ein Vektor ist nur so langlebig, wie deine Fähigkeit, ihn neu zu berechnen. Speichere den Rohtext und den Modellnamen neben den Floats. Wenn der Embedding-Anbieter verschwindet — und einer tut es immer — regenerierst du die Bibliothek, statt sie zu verlieren. Das ist Momos Format-Langlebigkeitsregel in einem neuen Gewand: Frag dich, ob ein 25-Jähriger dies aus dem, was du behieltest, wieder aufbauen könnte.

Lern-es

• Tutorial (die Quelle, auf die wir aufbauten): GeeksforGeeks — Vectors for ML
• Grenzenlektüre: VecMol — Vector-Field Representations for 3D Molecule Generation (ICML 2026)
• Wurzelkonzept: What is a foundation model? — wo diese Vektoren gross genug werden, um zu halluzinieren.
• PAZ-Note: Bring deine zehn wiederverwendeten Details zu einer Grasshopper-Sitzung — Vector3d in C# und ein NumPy-Cosinus-Skript sind die gleiche Idee; die PAZ Grasshopper↔Archicad Library ist, wo wir es in die Praxis umsetzen.