The "Final Boss" of Deep Learning

What is discussed, and when

1. 0:00 – 5:00: geometric deep learning, Taco Cohen
2. 5:00 – 10:00: category theory, geometric deep learning
3. 10:00 – 15:00: category theory, geometric deep learning
4. 15:00 – 20:00: geometric deep learning, category theory, DeepMind, AlphaCode
5. 20:00 – 25:00: category theory
6. 25:00 – 30:00: category theory, geometric deep learning
7. 30:00 – 35:00: category theory
8. 35:00 – 40:00: geometric deep learning
9. 40:00 – 43:58: geometric deep learning

Notable quotes from "The "Final Boss" of Deep Learning"

• Chance to be a lot more stable. The relationship between neural nets and tools is somewhat complicated. I think you can do a lot with it. You can do a lot of interesting search…

  about geometric deep learning · at 3:23

• Clever. You just have to follow the rules and be very systematic and outcome these very natural definitions and a kind of mathematics that just works very nicely. everything…

  about category theory · at 13:28

• Time. It was very much work in progress and just kind of trapped in my head as a collection of possible ideas, but not something I remotely knew how to execute on. Right? But…

  about DeepMind · at 15:47

• Which all have very nice correctness guarantees which then you know if you can run this model for sufficiently many times to kind of correct itself using the algorithm you can…

  about Bellman Ford · at 17:09

Who and what is mentioned in this episode?

People

• Taco Cohen — Person · Referenced expert / co-author · 1 mention · first at 4:53
  Cited as a co-author who thought more deeply about limitations of group-based geometric deep learning and the need to broaden the framework toward computation-alignment.
  Along the way you had to do a series of little additions. You just had to sort of okay so then this and then this and then oh how many of these are there? Okay. And then how…
• Bellman Ford — Person · Referenced computer scientists (algorithm eponym) · 1 mention · first at 18:01
  Referenced via the Bellman–Ford shortest-path algorithm (eponymous to Bellman and Ford) as another example of computation that is not a symmetry (non-invertible), supporting the argument for categorical approaches beyond groups.

Companies & orgs

• DeepMind — Company · Business focus · 1 mention · first at 19:21
  Mentioned as the affiliation of the speaker and in the context of developing advanced AI models like AlphaCode and AlphaGeometry.

Products & tech

• AlphaCode — Product · Case study · 1 mention · first at 16:40
  Highlighted as an example of combining language models with algorithmic procedures for robust problem-solving.
  Time. It was very much work in progress and just kind of trapped in my head as a collection of possible ideas, but not something I remotely knew how to execute on. Right? But…
• AlphaGeometry — Product · Case study · 1 mention · first at 16:40
  Mentioned alongside AlphaCode as a system that combines language models with algorithmic procedures for solving geometry problems.
  Time. It was very much work in progress and just kind of trapped in my head as a collection of possible ideas, but not something I remotely knew how to execute on. Right? But…

Concepts & topics

• category theory — Concept · Core topic · 15 mentions · first at 7:35
  Central to the discussion on generalizing geometric deep learning and understanding neural networks' computational structures.
• geometric deep learning — Concept · Core topic · 10 mentions · first at 4:25
  Discussed as a foundation for building neural networks that respect symmetry transformations, with limitations leading to category theory.

Full transcript with timestamps

0:00 language models cannot do addition. Um, not really. I keep seeing claims that they can and every time I see this claim, I go again to chat GPT and so on and check and they can't. And uh, what they can do is learn patterns which work a lot of the time, but you can always trip them up by doing something like okay, so if you ask chat GPT, what is a bunch of eights plus a bunch of ones with a two at the end? it will get the correct answer because it will recognize the trick. It'll say, "Ah, that's just one and a bunch of zeros." It'll know that you're trying to trick it. But if now you change one of the eights to a seven, now it has to actually know what it's doing. It has to actually sort of walk up, hit the seven, and stop sort of propagating zeros. And it simply fails. It uh it either chokes and makes up some nonsense or it says it's one with a bunch of zeros anyway. like it definitely can't add in the in the the basic way that that we know how to do

1:00 algorithmically that humans learn. And so like really teasing apart on a very basic uh level like Newton's three laws of motion has it encapsulated it um whether that's VO or Genie have these models encapsulated the physics of that 100% accurately and right now they're not they're kind of approximations and they look um realistic when you just casually look at them they're not accurate enough yet to rely on for say robotics

1:00 just because we can achieve some level of moving the needle by hooking up a really potent tool to a language model doesn't mean that we shouldn't think about what would the next generation of these models look like and how can we make them intrinsically better because even if you have the best tool in the world that is not going to save you if you cannot predict the right inputs for that tool. Even some of the current frontier models uh they will as you probably know perform hundreds of billions of multiplications just to produce a single token of output. Yet they cannot reliably multiply even relatively small numbers together without failing. Right? So this is something that to me hints at a great misalignment between what we are training these systems to do and how we're building them and what we might want to use them for downstream. especially if we're doing reasoning or if we're doing science. But it seems like let's say an LLM if you teach it properly you can just teach it to do

2:24 let's say addition up to some failure of its memory just like with humans we might forget a digit or we forget to carry over or so you know we do the algorithm wrong sometimes with some uh probability up to that it can learn this this procedure of adding longdigit uh numbers you know it's is it neural is it symbolic uh it's doing something some algorithm something symbolic perhaps uh but it's doing that with its neural machinery and the neural machinery also allows it to well first of all absorb tons and tons of world knowledge and deal with the vagueness of concepts right the fact that that things don't exactly want to fit your good old fashioned AI symbolic theory most of the time

2:55 we've all played with MCP servers we know that we can hook tools up to these things why not just call a calculator Andrew argues that tool use isn't enough right we still need to be thinking about the actual architecture underneath it still matters.

2:55 Internalizing things I think has a chance to be a lot more stable. The relationship between neural nets and tools is somewhat complicated. I think you can do a lot with it. You can do a lot of interesting search but there are a few disadvantages. One is you may have to call the model a bunch of times because it may get an answer but it may not be the answer it was expecting. So it might have to rethink things and go back. Like imagine a situation where you had some complex reasoning problem where along the way you had to do a series of little additions. You just had to sort of okay so then this and then this and then oh how many of these are there? Okay. And then how many of these and so on. And you it could be quite complicated to kind of keep calling out to a tool and then going back and then calling out to a tool and then going back and you know it seems like there are big efficiency gains if you're able to equip the model itself to just do certain kinds of basic computation or

4:25 reasoning internally. So yeah, geometric deep learning was a pretty interesting episode uh and certainly a very exciting period in my own research and uh and what I've done together with the team. Already in that very first episodes that we did together with geometric deep learning, there was a hint of discussion about how geometric deep learning might not necessarily be enough. It will require us potentially to broaden our lens on what we mean by geometric deep learning. And this is something we're already very actively thinking about. I think one of our co-authors, Taco Cohen, actually thought much more deeply about this. Like I hinted at the fact that groups which are the bread and butter of geometric deep learning might not be enough for uh fitting the concept of aligning to computation which is my personal motivation. Right? So for those who are not familiar, geometric deep learning uh fundamentally builds itself

5:20 on the concept of constructing neural networks in a way that is what we call equivariant to symmetry transformations. So what this means in a nutshell is if I transform my input in some way, I should get predictable outputs with my neural network if that transformation is something that I find to be irrelevant. One standard example is translations of images. So if I have a picture of a cat and I decide to shift it by a certain number of pixels, it is still a picture of a cat. That hasn't changed. I've just changed the way I'm looking at that cat. So I would like to build my model to be what we call translation equivariant such that when I do apply such a shift, I will still get the same output that this is indeed a cat. uh in a similar manner graph machine learning which is an area that I'm personally really passionate about deals with extracting useful representations of graph structure data like molecules but uh graphs have this inherent property that

6:15 uh there's many different ways you can show them to the model and typically you have to present them using some kind of say adjacency matrix of nodes by nodes but what happens if I decide to permute the order in which I show you those nodes so I permute the matrixes rows rows and columns accordingly this is still the same graph I would still want to get exactly the same outputs on that graph. Right? So I can build into my models this notion of permutation equivariance which guarantees that even if I permute my nodes, I'm still going to get predictable outputs and basically identical outputs up to permutation for those permuted graphs. And this is a really important property because it reduces almost exponentially basically the amount of data you need to fit a system like that to a satisfactory amount of behavior. And it should come as no surprise that transformers at their heart are permutation equariant models. Once you've put token embeddings, position embeddings into

7:09 tokens, you can permute them all you want. You'll get exactly the same response. If you wanted to learn that kind of symmetry with a simple MLP of tokens that would have taken you exponentially more data than the trillions that we currently use to train these models. So likely a data you wouldn't be able to find. We looked at geometric deep learning from a group symmetry point of view which is a very nice way to describe spatial regularities and spatial symmetries but it's not necessarily the best way to talk about say invariance of generic computation which you would find in algorithms right it's like I have input that satisfies certain preconditions I want to say something about once I push it through this function it should satisfy certain post conditions this is not the kind of thing we can very easily express using the language of group theory However, it is something that perhaps we could express more nicely using the language of category theory.

8:00 I do think that some very high level priors uh are probably a good idea and perhaps even necessary. In my PhD, I worked a lot on building uh knowledge about symmetries into neural networks. And I think uh for for many problems, you know, knowledge about symmetries is something that uh first of all gives you a lot of bang for the buck. You we know from from physics already and now from empirical results in in machine learning that building these things into neural networks or putting a constraint on your physical theory based on symmetries gives you a lot of information or it really restricts the space of of hypothesis and at the same time it doesn't bias uh your model if indeed your problem has this symmetry. So I think that that that kind of that's the kind of thing we should be be looking for this kind of very high level abstract prior not trying to encode you know going back to the example I gave just now the fact that light switches

8:58 make lights go on that we can figure out from data from reading text on the internet at scale uh from trial and error uh learning in an interactive environment perhaps the fact that there is space like 3D space uh and that your 2D images are a projection of that maybe that that a useful prior

8:58 category theory is very much in the eye of the beholder. Uh I think in the first instance for me category theory uh categories are a very mundane thing from pure mathematics where I come from. Uh and category theory means you know when you study categories for their own sake but everybody uses categories. The question is what exactly are they? And I really come from algebra and a lot of my motivation comes from studying algebra. And one way you can think about categories is algebra with colors. So uh you know we can imagine sort of typical algebra. So for example, let's say we're multiplying square matrices. I can sort of think of each square matrix as a little magnet and I just sort of hook them up together and they just stick and you kind of you know you get a bigger and bigger magnet and and everything makes sense. But now suppose I had special magnets that had colors on each side and I could only connect them if the colors were the same. Uh and that sounds a bit weird but it's exactly what happens with non-square matrices. uh when we uh multiply two matrices we we have to follow a rule that they are not allowed to be multiplied unless the

10:32 numbers match up. If I have an M byN matrix and I want to multiply on the left with an L byM matrix, I can do that because the M's are the same, but otherwise I I can't. There's a kind of color violation. So, uh, the point is a situation where we want to be able to compose things, um, to to hook them up together, uh, but we can't always do it. That's basically what categories are designed to cover. And, uh, I think the the matrix example illustrates they're not so mysterious. It's just when you want to be talking about for example many different sized vector spaces at once as you often do in neural networks because you have uh sort of hybrid shapes of with uh you know uh dimensions of of different sizes and so on. You end up you end up wanting something where you take this sort of partial compositionality into account.

11:04 I think this the this um geometric deep learning blueprint that we described there can be generalized. Yeah. category theory made a lot of things click for me it or I'm hoping let's say that it will allow us to generalize this methodology of geometric deep learning and equivariance to not just reason about symmetries but far more general kinds of structures and structure preserving maps could it help there in the sense that you know um we we imbue the models with these geometrical prior and we think these high resolution prior describe the physical world that that we're in could this category thinking allow us to somehow bring all of those together in some new way.

12:04 Well, you can certainly see how they're all instances of the same thing. Uh so those those things once you learn them uh you they start coming back everywhere. And what's very nice about the category theoretic way of thinking is that it's extremely systematic and it tends to guide you in the right direction because uh well the examples I've given you already uh show that right this this notion of equivariance that's something that someone thinking about groups and group representation and so on will come up with and find to be a very useful concept for mathematical reasoning. uh but it it falls out automatically if you if you already know category theory and you just define the categories of relevance here this define your group as a as a as a category for example then you just follow the definitions you say well okay so what is a funtor from my category to the category of sets for example okay it's it's mapping like this

12:59 that that gives you the definition of a group representation and then you look at what is a natural transformation between such funtors you write out the definition you find oh okay it's an equarian app in this case. And so it tends to produce meaningful definitions that domain experts like in a mathematical domain will have independently come up with very often. And so it uh it's uh it's for lazy people who don't want to or uncreative people. You know, you don't have to be clever. You you just have to follow the rules and be very systematic and outcome these very natural definitions and a kind of mathematics that just works very nicely. everything fits together just like with Lego pieces or something, right? They always fit exactly. Uh yeah, that allows you to build these elaborate uh mathematical structures that that have nice properties.

13:28 There's a historical analogy worth keeping in mind. Before the periodic table, before we understood protons and electrons, practitioners of alchemy made real advances, but without a principled foundation. Deep learning today may be in a similar position. We have powerful empirical results, but we lack the fundamental theory that would let us derive new architectures rather than just stumbling upon them. Categorical deep learning is an attempt to find that periodic table for neural networks. Deep learning, despite its remarkable success, is a field permeated by ad hoc design choices. Neural network architectures have all these knobs and tweaks that we can't formally justify just yet. There is no unifying framework for deep learning. Um there is no unifying framework that that would explain the probabilistic perspective, the neuroscience perspective and merely just the gradient-based iterative updating perspective. In fact, in the future, we might look at deep learning very differently. And our claim is that category theory will become the unifying deep learning framework.

14:55 But you seem to be making the argument that the interpolative function space of neural networks can model algorithms more closely to real world problems. potentially finding more efficient and pragmatic solutions than those classically proposed by computer scientists. We are working in this highdimensional space which is not necessarily easily interpretable or composable because you have no easy way of saying for example in in theoretical computer science if you want to compose two algorithms you're working with them in a very abstract space which means that you know you can easily reason about stitching the output of one to the input of another whereas you cannot make that easy of a claim about latent spaces of two neural networks. Right? Geometric deep learning is powerful, but it assumes all transformations are invertible. What happens when computation destroys information? Strictly speaking, I wasn't planning to talk about any of that stuff at the

15:47 time. It was very much work in progress and just kind of trapped in my head as a collection of possible ideas, but not something I remotely knew how to execute on. Right? But, uh, I was very passionate about algorithmic reasoning at the time as well. I still am and I still believe that like building machine learning models that are capable to align to classical computation is going to be really really important to address the shortcomings that are not so easily plugged by just gathering a better data set. Like fundamentally some of these things are likely to be restricted to not be able to easily generalize outside of the distribution you've trained them on. and especially for reasoning problems that is the case. When you think about all of the big scientific advances that were done with large language models, for example, up to this date, I would argue most of the ones I'm personally familiar with are a result of a careful combination of a large

16:40 language model and an algorithmic procedure in the background which actually makes sure to give it robustness properties. So think about things like fun search uh like alpha code, like alpha geometry. All of these systems have discovered new knowledge in computer science uh in competitive programming in uh uh in even you know geometry problems at the IMO but in all cases you've hooked up a language model to either a genetic algorithm or some clustering mechanism or a tier prover which all have very nice correctness guarantees which then you know if you can run this uh model for sufficiently many times to kind of correct itself using the algorithm you can end up with really nice solutions. The problem with geometric deep learning is that as I said it talks about symmetries. So permutations or circular shifts those are generally things that have very specific and rigid behaviors in typically one of the things we assume about symmetries is that they are

17:35 invertible. So basically that uh whenever I permute nodes I can always permute them back. I haven't lost any information. And usually with images when we do shifts we actually pad the image with zeros to make sure that no image data is lost and things like that. So basically it always assumes that it's still the same input. We haven't lost any information. Now why is this a problem for me who is really interested in aligning models to classical algorithmic computation? Well, as any computer scientist will know, many programs you write will delete some of the data or destroy some of the data. So that is no longer a symmetry. You cannot invert it. Maybe one simple example is other than just the you know naive example of I'm going to take a list and delete half of its elements for no reason. Uh let's start with you know path finding. So we talk a lot about algorithms like Dystra or Bellman Ford inside a computer science curriculum. In short those are algorithms that starting

18:28 with a directed weighted graph predict what are the shortest paths uh lengths inside that graph. All right. Now, the thing is there are many, many different graphs with different weights that are going to have exactly the same shortest paths and potentially even the same shortest path lengths. However, those graphs are different. And once you've applied the transformations of Dystra's algorithm or Bman Ford algorithm, you'll have lost the information that is contained about the graph in the final output of that algorithm. Right? Because many different graphs will be compressed to exactly the same output. Right? So this is not an operation I can describe using a symmetry and then this journey gradually like it took me a while to realize how we can be formal about this how can we try to put some theory on this and even now down the line how can we build some practical models using this and I was fortunate enough to uh to start chatting

19:21 with Andrew who is my colleague at deep mind uh who uh has a category theory background and he's been thinking himself about some of these problems in the past. So uh it it was a great match because together with him it it was a long way but we managed to gradually relax the constraints of what a group is giving us. We first uh looked at removing the invertability part which led us to monoids and then we derived some interesting theory and asynchrony invariance in models using monoids and uh now we're also looking into uh removing the second constraint of groups which is the requirement that every single computation must compose with every other piece of computation. As you might also know in computer science you cannot always do that. you must make the output of your first function match the input type of the second one otherwise they can't compose. So this now leads us to categories and uh well that's what led us now to categorical deep learning

20:15 things like intentionality and planning and system two and reasoning and stuff like that. I think you're placing the assumption that there's something standard about that.

20:15 Yeah, exactly. I mean and to some extent there is because for a lot of these algorithms we have even proofs that they will arrive at optimal solutions if you give them enough time and put them in the right context and I actually think it's going to it should be a synergy right because as you said with modern largecale deep learning systems we actually stand a chance to map really complicated noisy real world scenarios into a space where those algorithms might become applicable right now the main argument that uh maybe we are trying to make in some part here is that uh asking the model to both do that translation and robustly invoke the algorithm is likely a bit too much to ask because among other things you've said fixed computational budget that's already one recipe for failure as inputs get larger because as you know for example multiplication as I mentioned is an algorithm which is a is a problem for which we don't really have a super efficient algorithm yet the best known one is n login and that one relies on like complicated number theoretic constructions, let's say. So most people know just the n squ quadratic algorithm for multiplication. So the amount of resources that you need to reliably multiply two numbers will grow and sometimes super linearly uh based on the

21:40 size of those two numbers and currently uh our systems can cope with that implicitly if you add things like chain of thought which gives the model more thinking time and so on. But fundamentally all of those things are patches that might help for a particular class of problems but then fail somewhere else just because of the nature of how complicated the entire space of computational problems is. Right? So basically I believe in a future where the neural network will deal with the understanding of the world with the translation of what's happening in the world into some abstract space which might just be high dimensional embeddings by the way that's also plausible and then there will be some component that we have baked into the system either through priors or through very careful losses or even through combining systems with tools which has already proved really really useful that will actually then execute that computation in a way that we can reason

22:28 about it and I should stress by the What I mean by reasoning is not 100% accuracy on every single inputs. I find that humans can reason and humans are not 100% accurate on every single input you give to them. Right? As as you can see, if you ask me to multiply two numbers that are like 50 digits long, I will definitely make some failures if you ask me to do that. But you know the point is that like uh what I would like is that uh a system understands the amount of effort that needs to go into doing some kind of computation and maybe at least to give me some either an estimate of how likely it is to make mistakes or uh some notion even some notion of I'm sorry the problem you've asked me to do is too computationally large for my capabilities. I would like to just back off and not answer. Right? Currently systems are not trained to do that. They're trained to always try to give you an answer. Right? which is very different to to that. So basically uh I'm fine with making mistakes but I

23:21 would really like some awareness of when mistakes might happen and how big they will be which when you apply algorithms you often have that. So you can have correctness guarantees as well as you know convergence guarantees and things like that. But you're probably thinking why do we need to use such abstract mathematics in the first place? Well, this kind of structured thinking can actually help us see what actually matters.

23:21 To introduce the notion of structuralist mathematics and then the best known example of structure structuralist mathematics category theory. I would like to begin with the distinction between analytic mathematics and synthetic mathematics. And the usual two examples that are given for this is the geometry of Decart versus the geometry of Uklit. For Decart, lines are solution sets to equations. Whereas for Uklid, lines are precisely that which is stretched out between two points. What's the essential distinction here? In analytic mathematics, stuff is made of stuff, right? There's always some question of okay, I have to have some common foundation from which everything is built and all of my lemmas, theorems, etc., everything eventually boils down to a computation in that more basic substance. On the other hand, in synthetic mathematics, it's like I don't need to go I don't need to know what like the inside of a line is. That doesn't matter. The point is I only abstract what are the principles by

24:45 which I can make inference on lines and their relationships to each other. Right? The point is you get rid of everything that is inaccessible to your logic. Right? So you get rid of all of this stuff that you might call detail, but it's not even detail. It's noise. It because it doesn't have any content for that which you can know. Right? Right? And so therefore it's completely irrelevant. So synthetic mathematics gets rid of all of that and focuses just on how you can produce more knowledge. Right? And so then to explain at least what I mean by a structuralist mathematics is I want a synthetic mathematics of structure right what is structure you know in the context of machine learning we've got lots of notion everyone says structure right the best known and best studied example of that structure is group actions right all of geometric deep learning is about group actions but that's only one that's like one pin prick in the vault right that's just like one thing right there

25:34 are lots of other things say that come from theoretical computer science the notion of thing things being lists or you know things being trees all of these other various like algebraic structures. So you want like a single you know language in which all of these various kinds of structure can be described elegantly. This is exactly why we appeal to category theory

25:34 in in the simplest possible terms. What do you mean by two categories? Right. Right. So if we talk about a category as as a a collection of things and relationships between them these relationships are encoded as as something we call morphisms. These are like generalized functions. These are just arrows. We draw them as arrows.

25:59 Before we go any further, let's ground what weight tying actually means. Imagine an RNN processing a sentence word by word. And at every time step, it uses the same neural network cell, the same weights to process each word. That is weight timing, right? Forcing multiple parts of a computation to share identical parameters. In traditional machine learning, we do just this, right? We code it up, but there's no formal theory explaining when this is valid or what structure it preserves. I know it sounds abstract, but it just means that we can prove when weight tying is correct and derive new architectures where weight tying is guaranteed to preserve the structure that we actually care about. But often if we focus on two two objects and look at all the maps between them, all these morphisms. So these are a set in a category. There's a set of morphisms. But now if you take the ethos of category theory and and not just have a set of things, but we try to relate that set with some some ways between them. We if you look at this set of morphisms between two objects. Now if we add the notion or or start describing the ways these morphisms could be related the properties they need to satisfy which is also some kind of composition. Uh then

27:18 we get start getting at the notion of a two category which is objects morphisms but two morphisms as as ways of relating them. Category theory talks about these relationships between um objects, you know, as morphisms. But what about relationships between the morphisms,

27:18 right? Right. So the these are these that we call two morphisms or two cells. And these are the things we we use to model um to model some aspects of neural networks that we deem are important. We shouldn't just think of them as categories. They're not just maps. uh but they have this high we can think of them certainly like this but that that does not encode a lot of the interesting things we want to have about them and this is I think the idea of higher categories where you start modeling something with purely categories and you realize ah well all along I have been forgetting about this other important thing so you start putting more stuff into your theory while still trying to make it consistent and the particular way we encode these hieromorphisms or what they what we use them for I think the most important thing is weight sharing so we get a comprehensive theory of how to do weightaring sharing in a way that's that's not particularly tied to smooth spaces, you know, vector vector spaces that can it's it's one that works for manifolds. It's also one that works that we have now used, you know, me and my collaborators uh in my PhD that we have used to connect to game

28:34 theory where we talk about economic agents that have some strategies and if you want two agents to operate with the same strategy, we do weight sharing there. So there's all these different fields where you can specify what these are and the level of abstraction of a two two cell is the one which really gets to the essence of that without having any specificity about the kind of thing you're studying built in.

28:34 You could presumably just go to the third order and to the fourth order. I mean even with um with self attention transformers they um model these two tpples uh you know which is like a second you know like a first order relationship but you could have third order fourth order and so on. Is is two morphisms enough or should we go deeper than that? Well, depending on who you ask, you will get very opinionated answers. But generally, you know, I it's when I started learning category theory, I was like, well, I'm never going to go to two categories. That seems complicated. Now, I say, I'm never going to go higher than two categories because that seems too complicated. But people do three categories, infinity categories. And and you can really start building up these relationships higher and higher and get this really comprehensive theory that that becomes a very different beast in some ways.

29:24 There is a school of thought that our brain works in this way. So we think using like the the these symbols and these categories and so on and then there's and then there's the notion of the universe is a certain way and we understand the universe with that kind of interface. So it's almost like the driver for this is here's an interface here's how we think here's how the universe works. Let's program computers in that way.

29:48 That's that's that's a that's a big question. Uh it's it's what what happens with these things is that when we start adding more levels, right, more is different. And that's the thing we start seeing in higher categories. When we add different kinds of relationships and morphism, you start seeing these things that can be perhaps more most aptly described as emergent effects, right? Because if you have two things and you want to study their behavior as a composite, well, you can either study their behavior individually and look at

30:15 the joint behavior or you can compose the systems and look at the behavior of the composite. And what we often found is these are not the same. In many compositional cases, these are isomeorphic, but often there's a map going one way but not the other. So you have to track, you start to track since this isn't an equality anymore, you have to start tracking this higher self. But now this itself might be a part of another system that gives rise to this plethora and levels and levels of emergent effects. So that's one of the problems with higher category theory is that it's just so hard for us for with our complexity of mind to do this. Um so it's certainly an open question of what is the best substrate how to encode these things and people have done a lot of work in in programming language theory of encoding not just data structures and and algorithms but but type theories that that these algorithms are hosted in in some categorical way. People who believe in strong e emergence think that there is no reductionism. But even with basic weak emergence, the analytical shortcut between the theories at different scales are computationally

31:30 intractable. It's very difficult to go between them. But we want to have some kind of a theoretical framework that captures the whole thing, right? You know, captures the the the emergent organization as well as what's going on underneath. So, so this is one of the goals that you could say is one of the goals of category theory is to find some fundamental abstractions that give rise to these very simple principles. Often when you look at some systems or some phenomena, it's very complicated. But if you're lucky enough and if you set up the good foundations, it's always, oh wait, it was very simple all along. I I I looked at it the wrong way. So I don't know what where this could go. But we are certainly striving to make things as compositional as as they could be. uh and in many of these fields where we have a pl plenty of experimental evidence uh and lack of good theories category theory has a very good uh vantage point and just a lot of

32:21 practical benefit of let's stop and and see what's the good vantage point here does two morphisms allow us to think about weight tying

32:21 absolutely so if we think about a parametric morphism uh as as so it's a map from A to B with a parametric B we can of we often want to change the parameter space we often want to say do the weight tying which you know in practice means we start from a smaller weight space and copy the weights in particular uh so a twoorphism in the two category of parametric functions is is a reparameterization so it's a it's a map between two parametric morphisms that that is somehow somehow coherent there's some diagrams that have to be satisfied but essentially they encode that one is obtained by pre-omposing some weight some form of weight tying but it doesn't have to be just copying right that's the thing we're finding uh it can it can be arbitrary relationships between the weights. So one of one of the things that these two cells and two morphisms allow us is to see this algebraic structure encoded as relationships between the weights. And then that goes again into what category is about. It's about finding relationships between objects and this. So so absolutely.

33:13 So here's the key connection to programming. In functional languages we define data types like lists recursively. A list is either empty or it's an element followed by another list. Categorically, this is an algebra for an endo funtor. The structure map of the algebra packages together all of the constructors of the data type. And the homorphism from this algebra is exactly what programmers call a fold. A function that consumes the list by recursively applying some operation. So the framework is describing the very structure of recursive computation. when you write code, you you uh encounter syntax errors. You don't so much encounter semantics errors. So the syntax is really quite grounded in the things that you're actually typing in when you're when you're writing something whether it's an ordinary algorithm, whether it's a network architecture uh etc. Uh the semantics is much more about like how can programs behave and you know one example of this for u we have something like list types. So lists are defined by a type constructor. Given a type t you have another type list of t. So what are the semantics of lists? Well the semantics of lists are really things that are

34:46 foldable sort of foldable types. So like uh numbers with addition they're a sort of foldable type. If I have a list of numbers I can just add them to sort of remove the list. Uh and now these these foldable types mathematicians have a very different name for them monoids uh which are a more general kind of group. But in any case like that's sort of the the semantics of lists. And uh before I say something about syntax, let me say that our paper is really mostly exploring things from the semantic angle. Why is this? Uh it's because two different syntaxes can describe the same thing uh very easily. Uh you know we could uh have a an arithmetic theory where we have addition and we also have negation or we could instead have subtraction. And you can describe the same things in those two different languages, but the languages really are different. They give you the same semantics, but the syntaxes are different. And so when doing mathematical analysis, when proving theorems, it's often really

35:58 beneficial to work uh from a semantic point of view. But it's worth really emphasizing that if you want to compare this work to some other work that's done on equivariance and so on, that work is often being done from a syntactic angle. So let's pause to state the central claim of categorical deep learning. The proposal is basically that a neural network layer should be viewed as a homorphism between two algebbras for the same endofuncta. The endofuncta describes the kind of computation a network needs to respect. Be it a group action, a list fold or an automaton transition. And the algebbras describe how that computation transforms the specific data. The homorphism is then a function that maps between these two data representations while preserving the computational structure. When this homorphism is a group action, you recover geometric deep learning. But the framework itself is far more general.

36:31 So what is the syntax for example of of the action of a group? It's really you kind of say well I I want to just think I have like one kind of thing and then each group element takes that thing and makes it sort of sends it back to itself. So I have sort of a single type and then each group action does something to that type. So I might have some points in the plane and my group might be rotations and reflections that move those points around, but I'm still in the plane. But it turns out that this one sorted syntax isn't enough to uh to even capture uh basic type constructors in in computer science. So for example, lists, you cannot deal with the syntax of lists using just a single sort. you need a multi-orted syntax. So the the way that you can do this is to say well think of we have sort of uh zero tupils, one tupil, two tupils etc. And then given a k tupil I might be able to make some other kind of tupil an l tupil by taking elements of my kupil and making them into some lists ls right uh so

38:19 that's that's a syntax in the same way that group elements were a syntax and it's it does have compositionality if I uh have a way of packing things in uh from a tupil into a bunch of lists then I can pack those lists into other tupils of lists. Um but it's clear that this is first of all many sorted and then also differs from the group case because all of this is highly non-invertible, right? There's um uh you you can't sort of by packing things more and more and more into lists eventually undo the lists, right? You just get more lists. But we basically construct a model for the syntax. And in the case of groups, a model in sets means a set acted on by the group. Uh while for example, a model in vector spaces would mean a vector representation of the group. Um whereas in the case of the syntax for lists, you just get what I was calling before foldable types or monoids. uh things that are able to perform these syntactic operations in the expected way. Like

39:30 there's just something uh where the mathematical reasoning just works better if you expand your universe of objects a little bit even if you only care about the original objects. So this is a lesson that mathematicians have learned many times and it's sort of why a lot of people will prefer to work on the semantic side u at least in the first instance. It turns out that there's something very very basic in mathematics that we all learned in elementary school um that has sort of been overlooked in the design of GNN's and that's the notion of a carry. So what exactly is a carry? Well, suppose that I am able to implement a device, a a number wheel uh that can do arithmetic modulo 10. So 0 through 9 on it. And now I want to build a kind of composite wheel that can do arithmetic modulo 100. So what do I need to do? I need sort of this little mechanism that when it when the wheel goes from 9 to zero, it turns the next wheel by one. uh and this is very simple but it's

40:41 extremely at odds with the way that GNN's have been conceived of in the past because in the past you generally you send the whole state but there's no information in the state the information is only in the change of the state but it's even worse than that even if you sent the change in the state that's not enough information because if I went from 9 to zero is it because I added one is it because I added 11 is it because I subtracted nine it turns out that It's quite uh it's quite subtle to uh get this kind of thing to work in the presence of gradient descent. So it somehow is a very fundamental aspect of how we assemble more complicated computational operations from simpler ones. I mean one of the first things that you do if you're describing a CPU is you have to describe an adder. This is already something that we're struggling to do in in GNN terms. It turns out that this behavior is easy to get when you do discrete mathematics and very complicated to get when you do

41:48 continuous mathematics. Uh you can easily give this number wheel example. Everybody understands it because they know how to do addition. But getting it to happen in a way such that everything is continuous turns out to be really interesting. Uh the simplest examples of this phenomenon uh don't occur until you're dealing with three-dimensional manifolds. So you would need to be thinking about things in fourdimensional space. And the simplest example that we know of is the so-called hop vibration. This is a situation where uh you can decompose a three-dimensional sphere. So that's a sphere in four dimensions. Uh you can project it onto a two-dimensional sphere so that all of the pre-im images are one-dimensional spheres or circles. And the threedimensional sphere is very different from the product of the one and two dimensional spheres just the same way that Z mod 100 is very different from the product of Z mod 10 with Z mod 10.

42:51 uh and so this is something that I'm personally very excited about right now coming out of this asynchrony work is uh are there ways to exploit this type of geometric subtlety to create uh the phenomenon of carrying and actually properly model this aspect of algorithmic reasoning and and start to build actual CPUs in neural networks. So their claim is quite straightforward at the end of the day. Deep learning has two languages constraints and implementation and we lack a single framework that cleanly links them together. Categorical deep learning produces the bridge right using a universal algebra in a two category of parametric maps. It recovers geometric deep learning as a special case while naturally expressing things like recursion, weight tying and non-invertible computation. Now if you want the formal story go and read their paper the link is in the description especially the sections on par weight tying and recovering uh geometric deep

43:51 learning. Um, cool. Thanks for watching.

Questions about this episode

What is discussed in "The "Final Boss" of Deep Learning"?

In order: 0:00 geometric deep learning, Taco Cohen; 5:00 category theory, geometric deep learning; 10:00 category theory, geometric deep learning; 15:00 geometric deep learning, category theory, DeepMind, AlphaCode; 20:00 category theory; 25:00 category theory, geometric deep learning; 30:00 category theory; 35:00 geometric deep learning; 40:00 geometric deep learning.

What is mentioned in this Machine Learning Street Talk episode?

7 people, works and ideas are mentioned, including category theory, geometric deep learning, DeepMind, Taco Cohen, AlphaCode, AlphaGeometry. Each one on this page links to its own page with every episode that mentions it.

How long is "The "Final Boss" of Deep Learning"?

The episode runs 44 min; the transcript is about 8,041 words in 54 timestamped sections.

More from Machine Learning Street Talk

• All analyzed episodes
• Books mentioned on Machine Learning Street Talk
• People mentioned on Machine Learning Street Talk
• Topics mentioned on Machine Learning Street Talk