The word pattern does two jobs in our trade, and they pull in opposite directions. Christopher Alexander’s A Pattern Language (1977) — still the most-cited design book we own, and the direct ancestor of “design patterns” in software — used the word to mean a tested solution a human should reach for on purpose. The Wikipedia entry on pattern recognition, the one that landed in the PAZ inbox this week, uses it to mean a regularity a machine finds by itself and then acts on. Same word, two civilisations. Your model lives at the seam between them.

Here is the part the Wikipedia page states plainly and most tool marketing skips: this is not new mathematics. “In statistics, discriminant analysis was introduced for this same purpose in 1936” — that is Fisher’s linear discriminant, ninety years old this year, the thing that draws a straight line between two clouds of points and calls one side “A” and the other “B.” Everything downstream — spam filters, LiDAR classifiers, the transformer that reads your drawings — is that same move with more parameters and a bigger electricity bill.

←TODAY: 2026, Fisher’s 1936 discriminant still labels your walls in one line of Python.
→3012: the IFC file classifies itself on export; “external wall” is a property the model earned, not one you typed.
Fulcrum: a building is a labelled dataset that took three years and forty consultants to hand-annotate — which is exactly why the labels are worth keeping open.

The System. An IFC element is already a feature vector; nobody told the site team. Open the file in Notepad and you will find a line like #42=IFCWALLSTANDARDCASE('3vB2...',#5,'Ext Wall:300',$,...);. Split it by parts: #42 is the row id, '3vB2...' is the 22-character GlobalId, #5 points at the owner history, and the string is the type name. Attach a Pset and you also carry length, height, thickness, fire rating. Stack those numbers and you have exactly what the Wikipedia definition calls an instance described by a vector of features — a point in a multidimensional space where the dot product and the angle between two walls actually mean something. Your model already does pattern recognition; it just calls it “clash detection.”

The Tool. scikit-learn is the open-source Python library that turns that 1936 idea into two lines you can run tonight. It is maintained by a large volunteer community around Inria and the broader scientific-Python world, it is BSD-licensed, and it ships every classifier the Wikipedia article names — discriminant analysis, SVMs, the probabilistic ones that return a confidence so they can abstain when the data is too thin — plus the feature-extraction step the same page singles out, principal components analysis (PCA), and the Branch-and-Bound feature-selection the article itself admits is intractable for large feature counts. (The field even named its flagship venue after the idea: the Conference on Computer Vision and Pattern Recognition, CVPR.) For an architect or computational designer it is worth an afternoon because it is the smallest honest way to learn what a classifier can and cannot promise before a vendor sells you the same thing as a black box.

Setup:

python -m venv .venv && source .venv/bin/activate   # Windows: .venv\Scripts\activate
pip install scikit-learn numpy

python - <<'PY'
from sklearn.datasets import load_iris
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA
X, y = load_iris(return_X_y=True)
clf = LDA().fit(X, y)          # Fisher, 1936, in one line
print(round(clf.score(X, y), 3))   # ~0.98 -> it separated the classes
PY

First steps:

1. Run the block above. The 0.98 is the fraction it labelled correctly on data it has already seen — the “zero-one loss” the article describes. Trust it exactly as far as that caveat.
2. Replace the flower measurements with three columns you can pull from any IFC export: length, height, thickness per wall. Hand-label thirty walls ext / int once — that hand-labelling is the whole cost, and the whole point.
3. Swap score(X, y) for a real train_test_split so you score on walls the model has not seen. The number will drop. That drop is the only honest number in the room.

Atelier: For a Swiss studio the payoff is not “AI” — it is triage. A mid-size Büro living with a 12-consultant federated model burns hours re-classifying elements that arrived from Revit, Archicad and a structural tool with three different naming conventions. A discriminant classifier trained on your own already-correct elements can flag the strays for a human, not replace the human. The Monday move: export one clean model to IFC, pull length/height/thickness plus the type name into a CSV, and train the four-line LDA above on it — then run it against next week’s dirty import and read only the disagreements. One afternoon buys you a reusable filter; skip the temptation to let it auto-rename anything.

Hack: Separate external from internal walls using nothing but geometry, so a mislabelled import can’t hide. This is the classifier from the article’s spam example, pointed at your walls instead of your inbox — a linear SVM drawing Fisher’s line through a thickness-vs-height cloud.

from sklearn.svm import SVC
X = [[6.0,2.7,0.30],[3.1,2.7,0.12],[8.4,3.0,0.36],[2.2,2.7,0.10]]  # [len,ht,thick] per wall
clf = SVC(kernel="linear").fit(X, ["ext","int","ext","int"])
print(clf.predict([[7.0,2.8,0.34]]))   # -> ['ext']  thick + long reads external

PAZ has explored the grown-up version of this: our concept panel on attention in transformers shows the same operator scaled to IFC element graphs for clash detection and to Graph Attention Networks over finite-element meshes — a node listening to its mechanically-relevant neighbours instead of only its topological ones. Start with the four-line SVM; you will read the attention paper very differently afterwards.

One warning from further down the road. The buildings that aged worst were never the ugly ones — they were the ones whose labels lived only inside a format that went dark. A classifier is only as durable as the dataset that trained it, and your dataset is the IFC file. Nobody labels training data for fun; it is the afternoon nobody budgets. So when you pick the stack this quarter, ask the one question that outlasts the vendor: can a 25-year-old still open the file and re-read the labels? Keep the IFC readable, keep the Psets honest, and the pattern recognition stays yours. Clone scikit-learn’s examples tonight, train one classifier on your own clean model, and run it against your next dirty import before Friday.

Sources & Further Reading

• Primary: Wikipedia — Pattern recognition
• Reinforcing: IfcOpenShell — open IFC toolkit
• PAZ context: Skizze + KI!