Steven De Keninck

402 posts

Steven De Keninck

Steven De Keninck

@enkimute

Katılım Eylül 2017
240 Takip Edilen462 Takipçiler
Steven De Keninck retweetledi
Valeriy M., PhD, MBA, CQF
Valeriy M., PhD, MBA, CQF@predict_addict·
Solid mathematical ideas almost always outperform contrived engineering tricks. For years deep learning has been dominated by increasingly complex architectural hacks: CNN blocks, attention layers, channel mixers, residual pathways, normalization stacks. Every few years a new architecture is announced as if it were a revolution. One of the most famous examples was Kaiming He and Residual Networks (ResNet). At the time he was paraded around the AI world like a celebrity because residual connections supposedly “solved” deep learning. But these were largely engineering patches. Now something much more interesting appeared. A new architecture called CliffordNet returns to mathematics — specifically Clifford Algebra, developed in the 19th century by William Kingdon Clifford. Instead of stacking arbitrary modules, the model is built around the geometric product uv = u·v + u∧v A single algebraic operation that simultaneously captures inner product structure and geometric interactions. In other words: the math already contains the interaction mechanism. No attention blocks. No mixer layers. No architectural spaghetti. The result: • 77.82% accuracy on CIFAR-100 with only 1.4M parameters • roughly 8× fewer parameters than ResNet-18 And with strict O(N) complexity. The paper even suggests that once geometric interactions are modeled correctly, feed-forward networks become largely redundant. A good reminder for the AI community. Engineering tricks can dominate for years. But eventually mathematics shows up and deletes half the architecture. Paper: [arxiv.org/pdf/2601.06793…) 19th century geometry just walked into computer vision.
Valeriy M., PhD, MBA, CQF tweet media
English
13
120
905
47.5K
Steven De Keninck
Steven De Keninck@enkimute·
PGA turns out to be quite eloquent a language for dealing with k-simplices and k-complexes. We explore that in this writeup filled with general, elegant and dimension agnostic formulae. researchgate.net/publication/39…
Steven De Keninck tweet media
English
0
2
10
195
Steven De Keninck retweetledi
Max Zhdanov
Max Zhdanov@maxxxzdn·
Clifford Algebra Neural Networks are undeservedly dismissed for being too slow, but they don't have to be! 🚀Introducing **flash-clifford**: a hardware-efficient implementation of Clifford Algebra NNs in Triton, featuring the fastest equivariant primitives that scale.
Max Zhdanov tweet media
English
6
34
137
21.7K
Steven De Keninck
Steven De Keninck@enkimute·
@pickover It is called Mamikon's theorem. (size of tangent sweep equals size of tangent cluster)
English
1
1
22
2.6K
Cliff Pickover
Cliff Pickover@pickover·
Mathematics. Two "parallel" closed smooth curves. Is it true that Length (α) = Length (β) + 2πr? Source: tinyurl.com/4jecby4h
Cliff Pickover tweet media
English
36
64
619
43.5K
Steven De Keninck
Steven De Keninck@enkimute·
To understand rotations, you must first understand reflections. My CGI2025 talk on coordinate free circular splines. youtu.be/m317-cYs8q4
YouTube video
YouTube
English
0
6
20
1.2K
Steven De Keninck retweetledi
Nick Sharp
Nick Sharp@nmwsharp·
Logarithmic maps are incredibly useful for algorithms on surfaces--they're local 2D coordinates centered at a given source. @yousufmsoliman and I found a better way to compute log maps w/ fast short-time heat flow in "The Affine Heat Method" presented @ SGP2025 today! 🧵
English
2
65
432
34.2K
Steven De Keninck
Steven De Keninck@enkimute·
Hi Fidèle! The livestream is here : youtu.be/1AmeD0Vc8ow?t=… You can also still run through the exercises : #spider1" target="_blank" rel="nofollow noopener">enkimute.github.io/ganja.js/examp… #spider2" target="_blank" rel="nofollow noopener">enkimute.github.io/ganja.js/examp… #spider3" target="_blank" rel="nofollow noopener">enkimute.github.io/ganja.js/examp… #spider4" target="_blank" rel="nofollow noopener">enkimute.github.io/ganja.js/examp… #spider5" target="_blank" rel="nofollow noopener">enkimute.github.io/ganja.js/examp… #spider6" target="_blank" rel="nofollow noopener">enkimute.github.io/ganja.js/examp… This year, you have the ENGAGE workshop at CGI, next year we'll have GAME2026!
YouTube video
YouTube
English
2
2
3
233
Fidèle Palouki
Fidèle Palouki@opendiagrams·
@enkimute Hello Steven, I was trying to rewatch the live video of GAME2023 where you were implementing the awesome spider but cannot find it 😊. Is it available anywhere? Also is there an event this year on Geometric Algebra? Thanks
English
1
0
1
28
Keenan Crane
Keenan Crane@keenanisalive·
After trying several broken repos/scripts, I made a Python script for rendering #ShaderToy shaders to antialiased video (or rather, image sequences): github.com/keenancrane/Sh… (This one will surely be broken too someday, but for now it works nicely 😛)
Keenan Crane tweet media
English
3
4
66
6.8K
Steven De Keninck retweetledi
Eric Weinstein
Eric Weinstein@ericweinstein·
Ok. This is my life’s work as seen by C Jaimungal. Done in near isolation from community for reasons I do not grasp, Geometric Unity has never received this kind of treatment in 40 yrs. I’m sort of speechless and don’t know what to say. except “Thank you.” before I watch it. 🙏
Curt Jaimungal@TOEwithCurt

Huge news... I've been working on something assiduously and secretly since last year. It's been several months in the making, with several rewrites and several re-edits. It's finally ready to be released, thus shadow dropping it now. It's a 3-hour iceberg on @ericweinstein's Geometric Unity. I work on understanding and explaining different Theories of Everything for a living, and this one is unlike any other you've seen. This iceberg covers the graduate-level math, but it also constantly provides explainers aimed at different levels for those who are uninitiated with physics and differential geometry. Enjoy.

English
152
302
3.7K
337.9K
Steven De Keninck retweetledi
Alberto Maria Pepe
Alberto Maria Pepe@albertomariape·
🚨 If you're interested in interpretable Neural Operators and AI4Science, I'll see you at #ICLR2025, Poster #32, Poster Session 3, Hall 3 + Hall 2B, Singapore EXPO, April 25th!🇸🇬 📜 read it here: lnkd.in/dvi_S6Dm
Alberto Maria Pepe tweet media
Singapore 🇸🇬 English
0
2
6
359
Steven De Keninck retweetledi
Nicole Feng
Nicole Feng@nicolefeng_·
I've updated my blog post to walk through the remaining technical details of our Surface Winding Numbers algorithm: now the calculus of the algorithm is explained a bit more in detail. The post, paper, code, etc. is all here: nzfeng.github.io/research/WNoDS…
Nicole Feng@nicolefeng_

My SIGGRAPH 2023 presentation of "Winding Numbers on Discrete Surfaces", authored with @MarkGillespie64 and @keenanisalive , is now on YouTube: youtu.be/QnMx3s4_4WY

English
7
62
421
36.8K
Steven De Keninck retweetledi
ENGAGE2025 GA workshop
ENGAGE2025 GA workshop@ENGAGEworkshop·
ENGAGE workshop is back! This workshop focusing on Geometric Algebra, has deadlines approaching: Abstract submission: April 31, 2025. Paper submission: May 2, 2025. Check it out! engage-workshop.org #GeometricAlgebra
English
0
3
2
239
Steven De Keninck retweetledi
Pim de Haan
Pim de Haan@pimdehaan·
Our paper got a prize :) Cheers to lead author @johannbrehmer, and fellow co-authors Sönke Behrends, and @TacoCohen. Our results hint that yes, also at large scale of data and compute, if your data has symmetries, you might be better off building these into your network.
Symmetry and Geometry in Neural Representations@neur_reps

The best paper award for the Algebra and Geometry track goes to "Does Equivariance Matter at Scale?" presented by Johann Brehmer.

English
5
12
99
20.7K
Steven De Keninck retweetledi
Keenan Crane
Keenan Crane@keenanisalive·
Entropy is one of those formulas that many of us learn, swallow whole, and even use regularly without really understanding. (E.g., where does that “log” come from? Are there other possible formulas?) Yet there's an intuitive & almost inevitable way to arrive at this expression.
English
72
691
4.4K
493.7K
Steven De Keninck retweetledi
John Carmack
John Carmack@ID_AA_Carmack·
I have always been disappointed that more instruction sets don’t have peak-efficiency block move and fill operations. REP MOVS/STOS in x86/x64 is still pretty great, although not optimal in all cases. news.ycombinator.com/item?id=120479… There is certainly a bias against it due to not being RISCy, but even a tiny SoC today would barely notice the addition of a little move engine grafted onto the CPU. In fact, many already do have various DMA engines available, but they aren’t accessible to user mode programs, or properly integrated into the cache hierarchy. CPU architectures target doing the easy things in hardware and letting software work out all the messy edge cases, which was evolutionarily adaptive for a long time, but while RISC instructions handily beat out microcode, actual hardware gates in parallel handle picky edge cases better than software, as shown with a lot of compression acceleration. Game machines often had DMA and blitters that were easily programmable and could completely saturate memory bandwidth. coranac.com/tonc/text/dma.… GPUs have dedicated memory move engines, but at the high level you sometimes wind up using shaders to block copy memory, which is terrible. The benefit for CPU architectures would be that an instruction could automatically tailor itself to the exact memory configuration it is running on, which even the most specialized hand-coded routines can’t do in a forward compatible way. There are dozens of different cache and memory controller configurations in the wild right now. It can be argued that it just isn’t worth it – the last statistics I saw had memset/memcpy operations only consuming a few percent of most program mixes, but that may have changed, and probably doesn’t include all the inlined small operations. Also, most truly high performance programming arranges to completely avoid copies and fills altogether. However, much of Moore’s Law’s million-fold progress is a compounding of small improvements, and any improvement on existing code is the minimum speedup, which may be exceeded as programming styles adapt to the new capabilities. While we are at it, integrate better cache control, which can wind up being much more significant. I miss DCBZ and friends on non-PPC architectures. ibm.com/docs/vi/aix/7.… And maybe even allow it to be fully asynchronous, with different priorities relative to conventional instructions. Again, hardware like that exists, it just isn’t user mode accessible on most systems. Of course, it has to actually be great, not just exist. I remember early rumors in the 80s that the Apple IIGS’s 65816 CPU would have a 2 cycle/byte block move instruction, but MVN / MVP wound up being 7 cycles/byte. Disappointing. snes.nesdev.org/wiki/MVN_and_M…
English
28
29
540
71.6K
Steven De Keninck
Steven De Keninck@enkimute·
Nice work, @TacoCohen, @pimdehaan, @johannbrehmer and co!
Taco Cohen@TacoCohen

Does equivariance matter at scale? ... When the twitter discourse gets so tiring that you actually go out and collect EVIDENCE :D There has been a lot of discussion over the years about whether one should build symmetries into your architecture to get better data efficiency, or if it's better to just do data augmentation and learn the symmetries. In my own experiments (and in other papers that have looked at this), equivariance always outperformed data augmentation by a large margin (in problems with exact symmetries), and data augmentation never managed to accurately learn the symmetries. That is perhaps not surprising, given that in typical setups the number of epochs is limited and so each data point is only augmented a few times. Still, many "scale is all you need" folks believe that one should prefer data augmentation (or no bias at all) because eventually, with enough compute / data scale, the more general and scalable method will win (The Bitter Lesson). However, is data augmentation really more scalable? Scalability: how fast the method improves with data and compute scale, and for how long it keeps improving. This is exactly what equivariant nets are good at! We use transformers not N-grams for language, because they are more data efficient / scalable / better adapted to that problem domain. Paraphrasing Ilya Sutskever: scale is not all you need; it matters what you scale. In this latest work we decided to study the scaling behavior of equivariant networks empirically. As Johann explains in the thread below, we confirmed that equivariant networks are more data efficient. Interestingly, we were also able to confirm the intuition that in principle, the network should be able to learn the symmetry as well! When data augmentation is applied at sufficient scale, you get the same sample efficiency benefits as equivariance. HOWEVER: you need to do a huge number of epochs (which people don't do in practice), making equivariant networks more efficient / scalable in terms of training compute. So equivariant networks allow you to get the statistical benefits without paying the computational cost. The takeaway for me is that if you are working on a problem with exact symmetries, and are working on it because it is intrinsically important (climate, materials science / chemistry, molecular biology, etc.) rather than as a stepping stone to a more general problem (where the inductive bias could fail), then equivariant nets are still a good candidate in the age of scaling laws. Awesome work @johannbrehmer @pimdehaan Sönke Behrends!

English
0
0
2
228