Artificial Intelligence – Lesson 15 – Rabbi Michael Abraham
This transcript was produced automatically using artificial intelligence. There may be inaccuracies in the transcribed content and in speaker identification.
🔗 Link to the original lecture
🔗 Link to the transcript on Sofer.AI
Table of Contents
- Review of the previous line of thought: from logical electrical circuits, through a digital computer, to neural networks — emphasizing that the mathematical meaning is imposed from outside and does not exist in the machine itself.
- Binary and arithmetic representation in the machine: 5 volts as one, 0 volts as zero, and adding numbers as a game of switching on and off with no internal “understanding.”
- The difference between a digital computer and a neural network: a computer receives explicit instructions in software, whereas a neural network is trained on examples without the rule ever being formulated.
- The structure of a neural network: neurons, connections, and weights, summing inputs and an activation function — and the idea that the weights are what determine the network’s function.
- Supervised training by examples: feeding in input, comparing output to the correct answer, and updating weights again and again until it generalizes even to new cases it has never seen.
- The analogy to human learning: top-down teaching of an explicit rule versus bottom-up learning from many examples, with a neural network operating in the second style.
- The Tadiran analogy and analog electronics: the intuitive work of technicians versus orderly mathematical design, as an illustration of the non-algorithmic approach of networks.
- Face recognition as an example of something networks can do and classical software struggles with: characterizing “my grandmother” at any age and in any lighting without an explicit list of features.
- Visual recognition in Bava Metzia as a philosophical parallel: recognition that is not formulated as a list of features, and the discussion whether this is tacitly rational recognition or an immediate ability.
- The debate over “whitening the black box”: whether one can interpret the network’s activity as an explicit system of features, or whether an unarticulated component will always remain.
- The move from one task to many tasks: the difficulty of getting a single network to perform addition, face recognition, and more, without one training process harming performance on another.
- The brilliant idea of the language model: translating every problem into a verbal question and answer, so that the universal task becomes matching sentences to sentences.
- LLM training: feeding in enormous amounts of text, cutting off the last word, predicting the continuation, and updating weights — until it can produce relevant textual answers.
- Searle’s Chinese Room as an earlier model: matching symbols to symbols without semantic understanding, illustrating that a language model operates only syntactically.
- Basic technical concepts in the transformer: tokenization, vectors, embedding, attention, probability distributions, temperature, and sampling — and their connection to AGI and tools.
Summary
General Overview
The lecture continued building the picture from the ground up: from simple electrical circuits, through the digital computer, to neural networks and large language models. The central focus was the distinction between a system that receives explicit instructions about what to do, and a system that is never told what the rule is, but is only trained on examples of input and output. From there, the Rabbi moved on to explain how the idea of the LLM was born: to turn all possible problems into one problem of matching an answer sentence to a question sentence.
## From an Ordinary Computer to a Neural Network
In an ordinary digital computer, the hardware is the same hardware, but for each task you write different software. The software gives the computer explicit instructions: what to do, in what order, and how to solve the problem. All the meaning — numbers, addition, logical operations — is our interpretation; inside the machine itself there are only electrical currents.
A neural network works completely differently. It contains neurons and weighted connections, and each cell decides whether to “fire” according to the sum of the signals entering it. The purpose of training is to find the collection of weights that will cause a given input to produce the desired output. If you want to teach the network to add numbers, you do not tell it “add” and you do not explain the algorithm; you give it thousands of examples of two numbers and the result, and whenever it makes a mistake you update the weights until the answers get closer to the correct one.
## Top-Down versus Bottom-Up
The Rabbi emphasized the difference between top-down learning — learning the rule and deriving all the cases from it — and bottom-up learning, in which one learns from examples without an explicit formulation of the rule. A neural network is fundamentally a bottom-up mechanism. He said this is similar to the work of technicians and engineers in analog electronics: there is not always an orderly theory explaining what they are doing, but they know how to “fix” the system so that it works.
## Face Recognition and Visual Recognition
The clearest example of the advantage of neural networks is face recognition. It is very hard to write classical software that will identify “my grandmother” at any age, under any lighting, and in any condition, because there is no simple list of features that can be formulated. By contrast, if you train a network on many positive and negative images, it learns to output 1 for the grandmother and 0 for others.
From here the Rabbi connected this to the Talmud in Bava Metzia about returning a lost object on the basis of visual recognition. He presented two possibilities: either this is recognition by means of a collection of signs that we do not know how to formulate in words, or it is a more holistic, immediate ability. In his view, neural networks are more similar to the second possibility: they do not operate according to an orderly list of features, but through an organization of weights that produces the correct identification.
## From a Single-Task Network to a Universal Language Model
The problem is that an ordinary network is usually trained for one task, and new training may destroy weights that were intended for a previous task. So the question arises: how do you build a “universal machine”? The answer given was: by means of language. If every task can be described as a question requesting an answer, then all the world’s problems become one problem: matching incoming sentences to outgoing sentences.
That is the idea of a large language model: an enormous network trained on huge amounts of text, each time learning to predict the next word, then the one after it, and in that way producing a complete answer. In practice, you feed it an incomplete sentence, check which word it predicted, and if it was wrong — you update the weights. And so on and so on, over an enormous corpus from the internet, books, and other sources.
## Searle, Syntax, Transformer, and AGI
The Rabbi identified this as the realization of John Searle’s “Chinese Room”: matching symbols to symbols without understanding their meaning. That is the heart of the discussion: the language model operates syntactically, not semantically. It does not “understand” the question or the answer; it has only learned to connect input patterns with output patterns.
Finally, some technical concepts were briefly introduced: tokens, vectors, embedding, attention, probability distributions, temperature, and sampling. Through these, the Rabbi explained how a transformer builds a representation of the question and produces the answer word by word. He concluded by saying that the main technical part has now been completed, and from here on the discussion will move to questions of meaning: what is present here cognitively, what the philosophical implications are, and what the relation is between such a system and understanding, intelligence, and AGI.
Full Transcript
We started with a simple electrical circuit that can represent a logical operation. Two switches in series are AND, two switches in parallel are OR, and so on. From that we built a collection of electrical circuits that know how to add numbers. At that point we had already created a calculator that performs an arithmetic operation — it adds numbers. Five volts is one, zero volts is zero, and from our point of view this is now a game between on and off. That is the one and zero, and in that way on and off basically represent numbers. And turning on and off is basically transforming zero into one and one into zero, and so on. You can already see that the mathematical interpretations — meaning, inside there they’re only turning lights on and off, or circuits on and off, current is flowing. The mathematical interpretations are the meaning that we assign to the state of a light being on or off: one, zero, and so on. That exists only in our heads. In the computer itself there is no addition, no numbers, and nothing of the kind. Just electrons flowing — that’s all there is there.
After that I said we move on to a digital computer, where by means of one device you can solve many problems. Still, every problem requires software. In other words, people write a program, and that program solves a certain problem. They write a different program, run it on the very same device, on the same computer, but the different program gives it different instructions and uses the same hardware, yes? The same golem, in order to solve a different problem. The software simply separates between the different problems that we solve. For each problem, you write software.
The next stage was to move to a neural network. A neural network — that’s what we dealt with last time — is basically some kind of hocus-pocus where we place a series of nerve cells, neurons, yes? States that can be either zero or one, connections between every cell and every other cell, so that it creates some sort of network of nodes and links between them. Those connections have weights, numbers; every such connection has some kind of number attached to it. Every neuron, yes? Every such cell, decides whether it is on or off in the following way: it takes all the signals reaching it from the other cells, which transmit their electrical currents to it, it sums all the signals coming from all the cells entering into it, and then there is some function that decides, after that sum, whether I myself switch on — yes, the cell to which all this information is coming — or do not switch on. And of course “I” means every one of the cells in the system. In other words, once I decide to switch on, I send the information that I am on forward to the next cells, the ones to which I connect my own electrical wires, yes? I pass currents from myself to them. And so all the cells receive from other cells and pass on to other cells, and this network is interconnected.
The weights between the cells are what determine the function of the network. And our goal when we train a neural network — the goal is basically to find the set of weights, which number to attach to each such connection, so that if a certain input comes in, the output I want will come out. For example, if I want this network to add numbers, then I say that as input there enter, say, two numbers, and I want the output to be the number that is their sum. But I don’t do this the way it’s done in software on a computer, by giving it the instruction “add the numbers,” like we did there with the electrical circuits, yes? No, it doesn’t work like that at all. It works in a completely indirect way. I simply find some series of such weights, such numbers attached to the connections between the cells, and in this whole crazy and complicated process, I set the weights so that after all this process, whenever two numbers go in, the sum comes out. Okay?
How do I do that? I take a set of training examples. Let’s say I take, I don’t know, 10,000 addition exercises. Suppose I want to teach it to add numbers, so I take 10,000 addition exercises. In each such exercise there are two numbers and the result, okay? I build a table: number A, number B, result. Okay? Three columns. Now I give the system — I feed it the two numbers, and it outputs some result. I don’t know what result. Based on the computation with the current weights, just the arbitrary weights we started with, it outputs some result. Of course that result will be incorrect; there is no reason it should happen to produce the right result. What I do is use the result it produced, and update the numbers — the weights, yes, the numbers attached to the connections — in such a way that the result gets closer to the correct result.
Now I do another round of training, put in another example, and once again I get some number, it won’t be the right number, and I again update the whole collection of weights in the network so that the result will be closer to the correct one, and so on. After enough training examples, the weights arrange themselves in such a way that now every pair of numbers I feed in — including numbers it has never encountered before, new numbers that I feed it — it will output the result of the addition. So basically I have created here a machine that knows how to add numbers, without giving it an explicit instruction: add the numbers. Software written for a digital computer is software that tells it: add the numbers. In other words, that’s not — and it also tells it what to do in order to add them. Here in our case you don’t tell the system what to do. That’s the most important point to understand here.
Notice: in the case of a neural network, you don’t tell it what to do at all! It has no idea what it’s doing, it receives no instructions about what it’s doing, nothing. You give it a puzzle and a solution, that’s all. If it gives the wrong solution, you update the weights in order to make the solution correct, or closer to correct, and so on, and I keep updating and updating and updating the weights until I reach a situation in which it gives me the correct results, or something very close to the correct results, and then I assume that the machine is already trained. To train the machine means to arrive at the correct weights, or the effective ones, the ones that will do for me the job I want done here. That’s what it means to train the neural network, okay?
So for a neural network, you don’t write software for it, you train it. You train it through examples. It’s very similar, for instance, when you think about human learning. So if I want, say, to teach students how to add numbers, I have two possibilities. I can tell them: listen, this is the meaning of the operation of addition, and I explain to them exactly how you do it: take this digit, that digit, add them, write it like this, carry the remainder over, like we did at the beginning with the digital computer. That’s top-down learning. Top-down means you give the higher, larger, overarching rule, and from that the student already knows how to handle all the specific examples, because they are only specific examples of the rule, okay?
On the other hand, you can teach him differently. I don’t teach him the rule at all. I say to him: look, 2 plus 3 is 5, 4 plus 7 is 11, 2 plus 6 is 8. I give him various examples until he catches the idea, and at no stage do I explain to him what addition is or how to perform addition. But I am relying on the fact that if he sees enough examples, he will somehow internalize it, and when I give him an exercise with two new examples, he will know how to give me the correct result. With a student that usually won’t happen. But in a machine, in a neural-network machine, that’s exactly what is done. You give it a collection of examples without explaining to it at all what you want it to do, without giving it instructions to do this or that, you simply give it examples and the correct answer, examples and the correct answer. This is what’s called supervised learning. There are several kinds of learning, but this is the more common approach — controlled learning, so to speak. Meaning, you basically say: the learning is, take two numbers and give me a result. Wrong result? I change your weights so as to fit the result to the correct one. I give you another training example — you gave an incorrect result? Once again I change your weights. That’s called training it. Training it means bringing its weights to the correct values. Once they are at the correct values, remarkably enough, every pair of numbers it gets — the usual methods didn’t work there. You had to do something else, okay?
Now, I saw that over there I was doing lots of mathematics and this and that, and on the other hand around me I saw the people working — mainly technicians but also engineers — and I saw that if something didn’t work for them, they kicked it. In other words, if the capacitor didn’t work, okay, they went pop and put in a transistor instead. I don’t know, in the end it would somehow work. Now, that used to kill me, because I wanted to see how one works systematically, with mathematics, with planning — how do you design, execute according to plan, and everything comes out fine. We’re talking about analog electronics, for those who know, yes? There it mainly works like that. In digital electronics you really can plan; in analog, in any case — so I saw that all the technicians and engineers there, in the field, that’s just how it worked. Yes? They’d take some Japanese component — after all the Japanese are the best, even though of course they’re not allowed to make military-grade things, but their products are ultra-military-grade without being called that — they’d take some Japanese component and copy it or something like that, and if it didn’t work, they’d kick it. And that was the method.
Now, that used to drive me crazy. That’s one of the reasons I went into physics. I mean, I had no patience for that plumbing. In any case, what was interesting there was that in the end, it was clear to me that my program would not have worked. I have no doubt, because it was very orderly, very mathematical, and therefore it would not have worked. In other words, those guys — the technicians and practical engineers, the people who know the field — they know how to get things to work. Now ask them: what exactly is the explanation? Why did you put a transistor there instead of a capacitor? I don’t know, it seemed to me it would be okay. You won’t get any explanation out of him, certainly not a justification with some equation or something, nothing. Just, that’s how it seemed to me, my gut instinct told me so. And it turns out that these really are things that work, whereas when you do it systematically with mathematics, that דווקא doesn’t work. Yes? The technological uncertainty principle, which I developed in that period to my great frustration, said that the amount of mathematics in a given component multiplied by the chance that it works is a constant. In other words, if there is lots of mathematics, the chance it will work is zero. If there is no mathematics, the chance it will work approaches one. In other words, that’s the principle. And I think what we are talking about here reflects that whole business very nicely, because when you write software for a digital computer, that is exactly digital work. There you can plan, you give it precise instructions for how to solve the problem, and it follows the instructions. If you built it correctly, the problem is solved. That’s top-down. In other words, you give the rule and it carries out the instructions you gave it. That’s teaching the student top-down: give him the rule, and he’ll do exercises that are just particular cases of the rule.
By contrast, in a neural network it goes bottom-up. In a neural network it goes like those practical engineers and technicians there at Tadiran. Meaning, if it doesn’t work, you kick it a bit — in other words, you change the weights. You never tell it: listen, you need to add the numbers, it should come out 17, not 16 — why are you giving me 16? No, no, it doesn’t know what you’re talking about. In other words, it came out 16 and not 17? Update the weights, get it to become 17, manually, okay? Make sure it becomes 17. Why? Because 8 plus 9 is 17, that’s all. But at no stage do you tell the computer what the rule is — that is, what instruction it is supposed to carry out. It doesn’t know what it’s doing. It doesn’t know. A digital computer doesn’t know either. A digital computer receives an instruction in software telling it what to do. It knows nothing, but it receives an instruction about what to do. A neural network does not receive an instruction about what to do. You simply arrange it so that in the end what needs to come out comes out, that’s all, without saying to it: listen, now you’re doing such-and-such, okay? We simply organize the weights so that what I want to come out will come out, okay?
In certain senses, with the neural network we’ve gone back to an analog computer. We are basically returning to some kind of system that simulates the result that is supposed to come out, and therefore the result comes out, but it does not perform the computation itself, yes? Like the intelligence of water or of birds that navigate, remember from the introductory lectures? So a neural network is very much that kind of thing, okay?
[Speaker C] Rabbi, but there is a difference between models. I mean, the model is its ability to train itself for all kinds of situations.
[Rabbi Michael Abraham] Wait, wait, wait — I haven’t even gotten to models yet. You’ve already reached LLMs; I’m not there yet. At the moment I’m still with a neural network. In a neural network you have ten sites with some bonds between them, and that knows how to do a certain task. You built the weights so that it would do a certain task. So that’s — but this is very important for me, because this is the root of the matter. Everything else is only further complications. This is what it’s very important for me that you understand. In other words, what a neural network does is not that at some stage it receives an instruction what to do — not at all. It kind of decides on its own what to do, or call it that, but actually it doesn’t decide on its own; it doesn’t decide at all, nobody decides. You simply put weights into it so that what needs to come out will come out, without ever defining that what you are doing here is addition, or multiplication, or face recognition, or whatever it may be — nothing. You simply give it lots of examples, and the assumption is that if you work mathematically correctly, then the weights of the network will arrange themselves so that they perform the operation you want them to perform.
In other words, whenever they see my grandmother’s face, the output will be one, and if they see another face, the output will be zero, that’s it. Organize the weights so that all the faces, in all contexts, of my grandmother — at every age, in every lighting condition and weather condition and I don’t know what, and season of the year — in the end the output will be one when they see my grandmother. By contrast, other pictures, no matter under what circumstances, should always come out zero. That’s what I want. So what do I do? I take lots of pictures of my grandmother when she was a child, when she was older, when she was young, yes? And I feed them into the program. Now I check. If it outputs zero, I say to it: no, that’s no good, you should have output one. So let’s organize your weights so that the result will be one. Okay, now I feed in another picture of my grandmother. It outputs zero again? Once again I organize the weights so that it will output one. Now I feed in a picture that is not of my grandmother; if it outputs zero, excellent, I don’t touch it. If it outputs one — oops, not good, that should have been zero, because this is not a picture of my grandmother, so I need to organize the weights so that here it will output zero. And from many positive and negative examples, I train the network — that is, I find this weight matrix, all these numbers attached to the connections,
so that it always outputs one when it needs to output one, and zero when it needs to output zero. Okay? That’s it. That’s how I simply build the result by hand. At no stage am I carrying out a cognitive process. I’m not doing face recognition, or adding numbers, or some process that has clear cognitive meaning. I’m just doing a manipulation of matching: there is this input, I want that output, and I’ll build the weights so that that’s what comes out, okay? That’s all. That’s a neural network. Now, that is actually the most important difference in this whole series; this is what you need to understand really well, what I just said. Okay? Now, the continuation works like this: suppose I want a network—or maybe before that—a neural network performs operations, and I mentioned this last time too, that an ordinary digital computer cannot perform. For example, if I want it to recognize my grandmother, okay? How can I write a program, a classical program, that tells it to recognize my grandmother? I’m supposed to tell it: listen, the features of grandmother’s face are A, B, C, D. I need to identify or conceptualize the set of features there that distinguish דווקא her from all the faces in the world. How do you do such a thing? You can’t do such a thing. What exactly are you supposed to do there? There’s no way. What would you describe? That she has a nose like this? Lots of people have a nose like that. How exactly do you determine the set of features that characterize only her—and notice, in every state of age and lighting and weather? But as long as it’s her, you need to output one for me, and if it isn’t her, output zero. In other words, it needs to recognize countless possible images and understand from them who is my grandmother and who is not. You know how Google shows you what a child will look like in five years, or ten years, or thirty years? Or what an adult would have looked like as a child? How does it do that? Also by techniques of this kind. More complicated, but of this kind. In other words, once it has learned me, it basically knows how to do some sort of extrapolation or interpolation—what happens to me at an older age or when age moves backward. Meaning, it identifies the features that remain, and the effect of age or circumstances or whatever changes the features, but still leaves them inside the framework that defines that this is me. It is still me, even though these are very, very different pictures from one another. And if it sees a picture of someone else, it is supposed to recognize that no, that isn’t me, that’s someone else. Okay? That is very hard to achieve—I think impossible to achieve—with a classical program, with if-then: if you have this then do this, if you have that then do—what exactly are you going to do there? You can’t do such a thing. By contrast, in a neural network, give it enough examples of pictures of my grandmother, or of me, of various kinds, in various weather conditions, at various ages, in various lighting conditions, and always give it pictures of me and pictures that are not me, and tell it: this result is one, this result is zero, organize the weights. In the end, astonishingly, if you do it with enough examples—and by the way, you need a lot of examples for this—but if you do it with enough examples, in the end it will recognize pictures of me even pictures it never saw. If you give it a picture of me it will output one, if you give it a picture that is not me it will output zero, no matter the weather conditions, ages, whatever you want. Which is amazing. But that can be achieved with a neural network. That is almost impossible, I think, to achieve with a classical program. A possible example of this you might bring from the Talmud in Bava Metzia, in the second chapter. The Talmud says there that when returning a lost object, you return it based on identifying marks. Right, the person who lost it gives identifying marks, and then the finder, if the marks match and are distinctive, returns the lost object to the owner. The Talmud says there that to a Torah scholar one returns a lost object based on visual recognition, by visual impression. Meaning, he says: this—I recognize it—this is mine. He doesn’t give a sign: there’s a scratch here, and it was this color, and here the paint is peeling. No. He says: I recognize it, I see it, this—yes, yes, this is my chair, this is the chair that I lost, and we return it to him. In yeshivas they always like to say that this visual recognition of a Torah scholar means a Torah scholar has some special visual capacity, he knows how to identify objects. Come on, that’s nonsense of course. The Talmud brings in the Torah scholar simply because there is no concern that he is lying, not because he knows how to identify objects better. We all know how to identify objects. It’s just that with others there is concern that they might lie, so you can’t return it to them unless they gave us distinctive identifying marks. With the Torah scholar there is no concern that he will lie—at least then there wasn’t such concern—so we can return the lost object to him even without his giving the marks. But it’s not that he has special powers of recognition compared to another person; that is not what the Talmud says there. Never mind. In any case, for our purposes, I have always wondered: how is such recognition carried out? And this really touches on neural networks and software. How is such recognition carried out? There are two scenarios I can imagine. One of them is a bit mystical and one is more rational. The rational scenario says this: basically, in this chair there are all kinds of small signs. Here the paint is peeling, here there is a scratch, here the fabric is a little torn. Every chair, even if it was from the same manufacturer and looked the same when new, is now already different after use. And therefore, the collection of these little features actually helps me identify that this really is the chair I lost, this is my chair, okay? What does that mean? That in principle I could have given identifying marks here, but try remembering how long the scratch was and how much fabric was torn. I don’t know how to define it verbally or put it on the table for you as a list of signs so that you could measure the scratch length and the size of the tear in the fabric. So I tell you: look, I generally look at all these signs, this is my chair. I simply see it. I don’t know how to give you the signs, but this is still recognition built on ordinary recognition. I simply see the signs and identify that it’s mine. I just don’t know how to formulate this recognition in words. I don’t know how to give an ordered list of signs—where there were scratches, and how long, and what—but it is basically a collection of observations about the scratches and tears and peeled paint. It’s basically there. It’s just a kind of shortcut. I can’t do it explicitly, but that’s what is happening in me behind consciousness. That is the rationalist view, okay? The more mystical view says no, it doesn’t go through such external signs at all. I have some ability to identify my chair directly—some kind of sense of smell, some intuition, I don’t know exactly how to define it—this is my chair, I see that it is mine. It is not the collection of scratches and tears in it. There is no such list. Not only do I not know how to write it down or conceptualize it, there is no list of signs. It isn’t the sum of a huge collection of many, many little signs. It is some direct ability to identify this whole thing as a whole. I simply see that it is mine, okay? That is a little mystical, but I think quite a few people understand the process that way. And understand that Kahneman’s System 1 and System 2—we talked about this in previous lessons—neither of them is this. Even System 1, Kahneman’s intuitive system, at least assumes that this is a system that simply performs the calculation using the specific signs, just not consciously. But it is done somewhere behind awareness, and in the end it comes out as an output: one or zero, my chair or not my chair, okay? But it is done there. It’s not that we skip the process of identification according to signs. Here I suggested a more radical proposal, a proposal that says: it isn’t done that way at all, not even in my unconscious regions. It isn’t done that way. Rather, I have some ability to see this chair and identify that it is mine, not by paying attention to the collection of little signs. I don’t know, it’s a bit mystical. I’m really not sure how much I stand behind that possibility, but there certainly is such a possibility, and there are people who understand it that way. I don’t know. I’m not completely sure one way or the other. Why am I bringing this up? Because in a neural network, basically, something quite similar happens. It recognizes my grandmother’s face, but in ordinary software I would need to tell the software, in order for it to recognize my grandmother: look, she has eyelashes like this and hair of this color and wrinkles like this here and—of course, when she is young she doesn’t yet have those wrinkles, so it would be very hard to define—but suppose that theoretically I could see what lines characterize my grandmother both at age ten and at age seventy, okay? Maybe there is some way to identify that. It is very difficult to give an orderly list, exactly as with a found object. It is very difficult to give an orderly list of signs, and therefore I have no way to build software that would perform this recognition. But what does a neural network do? A neural network does not receive a closed list of signs and operate according to it, just as it does not receive an instruction to add the two numbers fed into it. What does it do? It simply organizes the weights in such a way that the output is one if it is my grandmother, and zero if it is not my grandmother. It turns out that if I organize the weights—if there are enough examples and many weights, the network is large enough, right—then after I organize this according to very many examples, the weights organize themselves so that for every picture of my grandmother the result comes out one. That is exactly recognition by visual impression. Yes, it is recognition by visual impression. The system does not work according to: she has such-and-such a sign here, in this part of the face, and there she has a wrinkle and here she has eyelashes and here she has, I don’t know, hair color. No, it doesn’t work that way. Rather, this collection of examples somehow gets translated inside the machine into a kind of function such that when you feed in my grandmother’s face, it outputs one.
[Speaker D] Rabbi, yes. What I know from image recognition or also speech recognition and things like that, in the end there is some vector, say, that indicates the user or the person. If you do some projection of the vector, then you can actually see what each dimension indicates. Now sometimes these are dimensions we don’t understand, but there are dimensions like, say, the distance between the eyes, the distance from the nose, or things like that, so—
[Rabbi Michael Abraham] Yes, no, so that is image recognition in classical software, not in a neural network, though it is still performed. It is performed through compression, through sampling. Meaning, it may be that you can make do with only part of the information, and that is unique enough to define who the person is whom you want to identify. There are Shannon sampling theorems and so on: how much of the information you need in order to uniquely identify an image, okay? But that follows precisely from the fact that in classical software you need to give it the data so that it can produce the result. That is not training in a general sense. That is recognition according to signs; it is not recognition by visual impression. Therefore it is very limited. Very limited. The quality is really not great, because in varied images there are many, many changes, and it is hard to find the features that really, really characterize exactly all the pictures of my grandmother, and no picture of someone else under any conditions. In a neural network, I don’t go through the collection of features like distance between the eyes and the like at all. That is not interesting at all. They simply give it the pictures and say: this is my grandmother, this is not my grandmother.
[Speaker D] Yes, no, I was talking about a neural network. I’m simply saying that in the end it also represents it, and that connects to what you said about the more rational method. It’s not that—the neural network in the end does the—
[Rabbi Michael Abraham] You are assuming things here that, as far as I know, are really not agreed upon. Meaning, the question is whether you can turn the black box white—yes, whitening the box—and you try to see what happens inside the box of the neural network, and you try to identify certain circuits that represent facial features, and you try to identify how the network nevertheless works like classical software. It is very unclear whether that is really there.
[Speaker D] There are—so part of it, right, some of the features are really as if it partitions the space into things that are sometimes not clear to us, but some of them are very clear. Some you really see are actually, say, a certain feature that really marks the distance between the eyes.
[Rabbi Michael Abraham] There are certain parts you can identify, but that is exactly the point. If you could identify it, you could do it in ordinary software too. Just take those features and feed them into ordinary software.
[Speaker D] No, it could be that it is simply very complex for us too. It is many, many features that are hard to measure.
[Rabbi Michael Abraham] The great advantage of a neural network is that it is not attached to the collection of features that you identify. It does it differently. It may be that in the end you decipher some features there—and by the way, that is only you deciphering them; it has nothing to do with what the network itself is doing. But you identify that such-and-such a distance between the eyes always activates these neurons and not those, or something like that, right? It creates some structure inside the network, and then you say: ah, so this structure is responsible for identifying the distance between the eyes. That is an interpretation you are giving to the matter. And therefore you may find some characteristic lines, but you will not be able, I think at least—again, I’m not an expert in this field—you will not be able to imitate explicit recognition. Meaning, to extract the recognition that a neural network performs and feed that into a regular computer so that it recognizes in the same way. Give it all the features; the neural network will simply insert into it: this is the eye distance, this is this, and let it identify. In principle, if you could completely whiten the box and see exactly what processes are happening inside, in principle you could move it to a regular computer and do it there, because you know that it goes according to distance between the eyes—exactly recognition by scratches, right? Not by visual impression. And then in principle you could do it with a regular computer too. Therefore there will always be a significant part of the matter, I think at least, a significant part of the matter that you will not identify. You will not succeed in tying it to such-and-such physical features of the face. There will be a part that yes, a few prominent features you may perhaps see that activate certain circuits inside the network. In any case, okay, I’m not going into too many details here. I do want you to understand the principle. I’m not an expert either, so it’s not as though I can really get into all sorts of details, but I am trying to explain the principle, how, in principle, this thing works. So that is a neural network. Now that is not enough. Because now I want—exactly the same move we made with the computer—I now want to build a neural network that solves many problems, not just one. Now notice, in a regular computer, in order to solve many problems you need to write many programs. Each program solves a type of problem, right? So with many programs I can use the same computer to solve many problems. In a neural network there are no programs; there is training. You train the network. What does the training do? You give it examples, and these examples update the weights, okay? Until you reach a set of weights that does the job. Meaning that for every given input it gives the output you are looking for, the result you are looking for. The problem is this: now you want that same golem itself, that same hardware, right? That same golem itself, to do both the work of adding numbers and identifying my grandmother. What do you do now? With the same machine, and now there is no program. What can you do? You might train it both on examples of pictures of my grandmother and not my grandmother, and also on examples of number addition, and hope that this set of weights, you will succeed in building it in such a way that it will manage to perform both tasks. Okay? Meaning that one will not interfere with the other. Yes, you have to understand that when I train the network to perform number addition, that organizes the weights in a way suitable for number addition, but then it will not suit face recognition. And vice versa. So if I trained the network and reached a certain list of weight values, and now it knows how to recognize my grandmother’s face, and now I want this network also to know how to add numbers—well, here we start training it on numbers and addition as we talked about before, but that will reorganize its weights in order to perform addition, and then it will change the weights I trained before. So now it will no longer be able to recognize my grandmother, because I need a very specific set of weights for it to know how to recognize my grandmother. Now, it turns out that I can do multitasking with a neural network. If I have many weights and I take enough examples, I can train it to perform both tasks, or even five tasks. In principle it’s possible. Very often the quality is harmed, but if you have a large enough network and train it enough on enough examples, you may succeed. But that is a limited number of tasks. If you want to reach a universal network, meaning a network that knows how to solve all tasks, how do you do such a thing? How can you train a network on—I don’t even know what all types of tasks are. How do I know what tasks might occur to me that I will want the network to do? There could be a million things. Yes, a huge number of things. That it should conduct a physics experiment, analyze the results of a biology experiment, describe a cell for me, add numbers, identify mice—I don’t know, a million things. A million is nothing, of course. A vast number, yes? Endless things. So there is no way to train a network to do all tasks. I do not have a closed list of tasks. And even if I did have a closed list of tasks, on the face of it, in light of what I described before, each training for a particular task would destroy the weights for the other tasks. Because after all, you need a certain set of weights in order to output one if it is my grandmother’s face and zero when it is not my grandmother’s face, but that set of weights is not the set that will bring about correct number addition. When I want the network to add numbers correctly, I need to organize its weights accordingly. But if that is so, if I reorganize them, then it will no longer be able to recognize my grandmother’s face. So now there is some problem here, because there is no program here, and I cannot write a different program for each task, and yet I still want to use the same golem, right, the same hardware, to perform many tasks. What do I do? Now, the brilliant idea that came up not so long ago—seems to me maybe ten years ago or something like that, maybe a little more—it first arose, it was not implemented, it first arose, was that we can work through language. What does that mean? Basically, every task is a task that can be described as a question requesting an answer, such that the output will be an answer. And therefore you can in fact ask the question in words: Is this my grandmother? And give some description of my grandmother, and get an answer: yes or no. Never mind. The answer too is words. Okay? Suppose. Now if I know how to translate all these tasks into words, then you understand that what I am now looking for is a function that matches words to words. And if a certain set of words comes in, the output will be another set of words, where the set of words that comes out is the answer to the set of words that came in, which was the question. Now you understand that once I have translated everything into words, I have turned all the problems of the world and the universe into problems of a single type that one machine can handle. A machine that knows how to match one sentence to another sentence. And if I have a sentence that comes in, which is the question or the task or whatever it may be, it outputs for me a sentence that is the answer. If you know how to match the answer sentence to the question sentence, then you basically know how to solve all the problems of the world. Because solving a problem means giving an answer to a question. That is what it means to solve a problem. Giving an answer to a question is a function that matches the outgoing sentences to the incoming sentences. The incoming sentences are the question, and the outgoing sentences are the answer. I am putting this very schematically and roughly, but that is the idea, it seems to me. Okay? And this brilliant idea basically said: if so, maybe there can be a universal machine such that all it knows how to do is match one sentence to another sentence. If it knows how to answer every sentence with the relevant sentence, then it basically knows how to solve all the problems of the world. So if we are now building what is called a language model—yes, a language model—then perhaps it will be the universal machine. Meaning, language is actually the medium that unifies all problems into one type of problem. And that type is matching an answer sentence to a question sentence, or answer sentences to question sentences. Okay? If I know how to find this universal function that knows how to match the correct sentences to the incoming sentences, then I have basically solved all the problems of the universe. That was the idea. And then what is called a large language model was created, an LLM. Large language model as a large language model. Why? Because it is clear that if you want a match between all the sentences in the language and the answers appropriate to them, you need many, many connections, a gigantic network, because you want enough degrees of freedom when you fit the weights across all the connections in such a way that they know how to do the matching for countless problems. Meaning, for one sentence they will give the answer as, say, sentence number 117; for sentence two they will give sentence 1451; for sentence three, that other sentence; and so on. Okay? So if you number all the sentences in the language—I don’t want to get into Berry’s paradox—meaning, if you translate all the sentences in the language, then you can basically look at this as a machine that matches sentences to sentences. That’s all. And once again, without understanding anything. Just matching. Like what we did in a neural network for a particular task, this network too is for a particular task, the task of matching sentences to sentences. Except that we understand that matching sentences to sentences can in fact represent every type of problem. So if the machine knows how to match sentences to sentences, it knows everything. Now, yes, when we basically—think: when we learn arithmetic in class, mathematics, okay? What does the teacher do? He draws on the board and explains to us in words, right? He says: if you have such-and-such a problem, you solve it in such-and-such a way, and he gives a verbal description of what needs to be done. You understand that this is exactly what we do with the machine. We simply tell it a sentence in words, and we want an answer in words, but we already know how to translate that also into the result of a numerical exercise, because it is only a verbal description of the mathematical formula, or of the number that is the answer. Everything can be translated into words. And this brilliant idea of turning the matter into a language machine, creating a neural network that is basically a large language model, is actually theThe universal machine, okay? In principle, potentially. It can be universal. That was the idea. But of course, as I said, it has to be a huge machine. A huge machine, because you understand that the more complicated the problem is, and the more input versus output there is, the more matches you have to make, the more parameters you need, because you want to play with them in order to always get the right answer to every question. If you have a lot of—say you want to match, I don’t know, 1,000 numbers to 1,000 other numbers, and do it through some function—then obviously you need more and more parameters inside the function in order to make that fit than if you want to match two numbers to two numbers. Okay? So if you want to match infinitely many numbers to infinitely many numbers, you need huge models. Okay? Fine, but by now we already have computational tools and the technology is advancing, so it’s possible to build huge models. And of course they keep getting bigger all the time, okay? And then basically the possibility opened up of creating a language model. Now I want to explain how you train a language model, first in principle, before we get into specific architectures. How do you train a language model? What we do, basically—again, a brilliant idea—we take all the sentences in the universe. Okay? The internet, for example, is full of sentences, right? We simply pull all kinds of texts from the web, and we train the network on those texts. What does it mean to train the network on texts? We feed it a sentence, cut off the last word, say: “The cat sat ליד the table.” Okay? Now I say: “The cat sat near the—,” without telling it the answer. Then I say to it: “Network, tell me what the next word is.” It tells me “mouse.” Wrong. It gave me mouse; it should have given table. So I update the weights so that it gives table, okay? Then I feed it another sentence, and again I remove the last word, and I tell it: “Predict the last word for me.” Again it fails, I update the weights, and basically I teach the network to complete sentences. To complete sentences. And afterward, of course, it no longer completes just one word, but one word and then another word and then another word and then another word, and it basically gives me a sentence as a response to the sentence that was fed into it. Right? Training on a single word is just one step in the process, but I want it to give me a whole text as an answer, so I have to train it to produce the text word by word, something like that, so that it produces the text that fits the text that came into it. Okay? So that’s very rough, but that’s the general idea. And then I train the network, and if I take—and this is why information today is worth a lot of money—and there’s huge investment in producing information to train these networks, because the internet is already exhausted. That is, they’ve trained them on all the—you people don’t grasp how much information there is on the internet. They train a model like this on all the information that exists on the internet, and not only on the internet: in books, in whatever you want. The more information these companies can get, the more they want it, and they’re willing to pay a great deal of money for information. The information is running out. We want to train networks on as much information as possible, because we need to determine the values of a huge, huge, huge number of weights. And for that you need a huge number of examples. Okay? So we take all the texts we can get our hands on, and we constantly train the network to predict what the next word will be, what the next sentences will be, and so on. Until I arrange the network’s weights—and I’m talking about billions upon billions of weights, all right?—I arrange the network’s weights so that when it receives a sentence, it gives me the correct sentence in response. It completes, as it were, what is supposed to come after it, but what it completes is actually the answer to the question sentence that entered it. That’s how we do it. Now, I want to remind you of what we talked about in the introductory sessions about the Chinese Room. Understand that what’s happening here is simply the Chinese Room. John Searle was ahead of his time. His example was given, I think, in the 1960s or something like that—60s or 70s, I think. And basically, let me remind you what the Chinese Room is. A person is sitting inside the room. He doesn’t know Chinese; he only knows Hebrew—okay, in our case, let’s say English. And they feed him questions in Chinese, and he has to produce answers in Chinese. He has a box full of Chinese letters or words, and he has to build an answer out of those words and pass it outside through the window to someone who checks it there. If he gives the correct answer—great, he gets a candy. If he gives the wrong answer, he gets an electric shock. Okay? Then he tries another word. Doesn’t work—another electric shock. Until he learns to match the answer he gives to the question he receives. This Chinese Room experiment is nothing other than training a neural network. That’s simply what it is. It’s exactly that. One to one. That’s precisely it. Now, there too we saw that the person, after a very, very long time and a very, very large number of training examples—and feedback of course, feedback is very important—that is, you need to receive feedback. If your answer is wrong, they rearrange your weights. You get a shock, or you rearrange the weights, it doesn’t matter—but there is some kind of backpropagation process, right? You go back from a wrong answer and update the weights to improve the next answer. So that process is exactly the process of training a neural network. It receives examples, receives feedback as to whether the answer it gave was correct or incorrect, rearranges the weights inside itself so that next time it won’t get a shock—that is, so the answer will be correct—until after many, many, many examples with shocks, with feedback, its neural network is arranged so that every question it receives, it produces the relevant answer. Now notice: already there we talked about this, and this is what Searle was trying to show. This person does not know Chinese. He has no idea what the question means, and no idea what the answer he’s producing means. He has no clue. But he does know that for a question that looks like this, you produce an answer that looks like that. I have no idea what the question means, no idea what the answer means, but I do know how to make the match between the question and the answer. And that is exactly what happens in a neural network—exactly. The neural network receives a collection of symbols that it has no idea what they are, but it knows how to match them to another collection of symbols and produce that as an answer. And if you train it on enough examples, enough times, it outputs the relevant collection of words as an answer to the collection of words that entered it as a question. That is exactly what’s happening there. And the hope—which was realized in the end as well—was that if we take a sufficiently large network, with enough, many many many textual examples of this kind, it will know how to answer every question, it will pass Turing tests. It will pass Turing tests, meaning that you’ll be able to talk to it. Give it a question, it gives you an answer. And again, it has no idea what you asked or what it’s answering, no idea. All it knows is that it receives one set of symbols, it outputs another set of symbols in response, and it knows how to make the match. If this set of symbols comes in, that set of symbols should come out. And it learns this from all the information you can gather in the world—from the internet, from books, from newspapers, from whatever it may be. You feed it this information, train it on this information, and it knows how to match words to words. Say it reads, goes through all kinds of articles. This article deals with a certain problem, so there’s a question there, right? In the article. There’s a problem that it deals with. Then it proposes an answer to that question. And even within the article there are smaller questions that have answers, inside a paragraph and so on. The moment you train the network on all texts of that kind, it basically learns to provide the relevant answers to every question, because it knows how to match the symbols to one another. Notice: without knowing anything! There’s no semantics there; it’s only syntax. That is, it’s only matching symbols to symbols. There is no dimension of understanding here. That’s why I spent so much time in the introduction distinguishing between semantics and syntax, between formal manipulations—manipulations of form—and the meanings that accompany those manipulations in our minds, which is semantics. The network doesn’t have that. Well, that’s the simple view, except for a few eccentrics who want to claim that it does. But it doesn’t. It manipulates symbols and produces other symbols. That’s how you train it, simply. Like in the Chinese Room—it really is the Chinese Room, okay? Even though John Searle wasn’t dreaming about neural networks. That wasn’t his direction at all. He only wanted to show how it is possible to carry out acts of communication without understanding, actions that connect input to output without understanding. And what happens in a neural network is that this is exactly what it does. It creates a connection between input and output without the dimension of understanding. There’s no cognition here; there’s only a function that matches sentences to sentences, okay? Now, that’s the idea in broad terms. I want to go a little more into a few technical concepts related to neural networks—to language models now, not neural networks, sorry. We’ve moved to language models, notice. A neural network solves one particular problem, or two or three particular problems. A language model can already talk to you. Ask it a question in mathematics, it answers in mathematics. Ask it a question in history, it answers in history. Ask it a question in politics, it answers in politics, because it has read everything, seen everything, it knows what connects to what. “Knows”—it simply correlates sentences with sentences or words with words, and it knows how to give you the relevant sentence if you give it a question sentence, okay? That’s basically what’s happening there. Now, more specifically, I’ll go a bit more into the details because it is important, after all, to understand at least a little of what’s going on there. A question in spoken language enters the model, right? You ask ChatGPT some question, okay? What happens to that question? It turns out that in the prevalent configuration—called a transformer, a transformer configuration—in that prevalent configuration what happens is the following: they take the question you sent, break it down into units called tokens. These aren’t exactly words; they’re units. It doesn’t matter—sometimes even the definite article “the” can be a token. It’s not necessarily a word, but you can think of it as words, all right? We build the question sentences as a collection, a sequence of consecutive words, okay? Each such word—each token—has a number. This is the first token, this is the second, this is the third, the fourth, and so on. A sequence of tokens—that’s the question, right? That’s the input. What happens there? After the breakup into tokens—tokenization, as it’s called—they take each token. Each such token has an index, because in a language there is a finite number of tokens, right? There aren’t infinitely many words in a language, or syllables or things like that. There is a finite number—many, very many—but still a finite number of tokens, and each token has a number, an index, okay? That index is sent to the computer’s memory and retrieves some sequence of numbers—a vector, as it’s called—that represents that token, okay? Each such word is represented by a sequence of numbers, by a sequence of thousands of numbers—it doesn’t matter—but it’s called a vector, some collection of thousands of numbers that represent that word. Now, the set of tokens that came in as a question—each one of those tokens has been translated into a vector of numbers—and this enters the transformer. This transformer basically does—maybe even before that, yes, no, yes, you can combine it—it does what’s called embedding. Never mind the term. It represents that sequence of tokens as some large vector. This is already a vector that represents the whole question, not a single token. You build from these tokens some very large vector that represents the question, okay? Now, I want to know what the next word is, to predict the next word, or to construct the first word in the answer, okay? I need to know what the first word in the answer is, and I take the sequence of words that entered. In the vocabulary that contains all the words—or tokens, yes—of the language, each one is attached to some such vector. I check which vector matches the question vector. There is some mathematical operation—an inner product, never mind—of these two vectors, which determines how similar they are, parallel, however you want to call it, and I get results. Now, in principle, when there is a question vector, a certain question represented by a vector, it matches to some extent every word out of the thousands of words in the language, out of the hundreds of thousands of words in the language, okay? But there are different degrees of fit. There are words in the language that fit this vector very well; there are words in the language that fit this vector less well, okay? So we basically have a distribution. What is the probability that it will be—for example—“The cat sat near the—”? Now I need to know what that “the” is. What’s written there after “the”? I ask the model: “Near what did the cat sit?” It needs to tell me “near the table.” Now it does this calculation and says the word “table” fits pretty well here, but the word “chair” might also fit, because “the cat sat near the chair” is also a possible sentence, okay? So there’s also some probability that this word is “chair,” not “table.” And there is some probability that this word is “moon,” but there is less probability that “the cat sat near virtue.” That’s not a sensible sentence, right? So the probability that the next word will be “virtue” is negligible, very small, okay? But it still exists. There is some distribution over all the words, all right? We are now building some distribution—it doesn’t matter—a logit of some sort. That is, we assign a number that represents the probability that the next word is “table,” “virtue,” “moon,” “mouse,” okay? And now I need to choose which of these words to output. Right? So what do I do? I now have to sample which word to output. In principle, I could have output the most probable word. Say “table” came out as the most probable word, then I’d output “table.” But it turns out—somewhat strangely, but it turns out—that this does not give the best results. What gives us better results is if we say: choose a word randomly, but take into account that “table” is the most probable. Perform the sampling in such a way that there is a much higher probability that it will be “table” than “mouse,” but still allow some chance that it will be “mouse.” Because sometimes a person writes a poem, and in a poem it won’t say “the cat sat near the table”—that’s a prosaic sentence—but rather “the cat sat near my mood,” okay? The poet got poetic, okay? So I want there to be some possibility that it understands that this is a poem, and therefore I don’t rule out the possibility that it will write there “my mood” or “virtue”—a small chance, but such a chance exists. Now, there is a parameter called temperature. It’s not really temperature, but it performs an operation similar to what temperature does in thermodynamics. This whole story, by the way, comes from physics—that’s how I first encountered it. So temperature basically means that, say, at a very low temperature—temperature zero—it will choose the most probable result, with probability one; it will simply always choose that. At a slightly higher temperature, it will also give some probability to very good results, though not necessarily the very best one, but those close to it. At a somewhat higher temperature, it broadens the Gaussian, okay? At an even higher temperature, it broadens it even more. If you want it to write a poem, give it a high temperature. If you want a scientific, authoritative, informative answer, give it a low temperature, because there there is one correct answer and we’re not looking for inspiration or creativity or anything like that—we want the correct answer and not nonsense. So temperature is a kind of parameter we play with, and it basically determines how we sample the output word. Now it turns out that the process is of course more complex; I’ve described it here very schematically. Because in a transformer, for example, we know there can be a sentence built like this: “Danny put the book on the table because it was heavy.” Who is “it”? “Danny put the book on the table because it was heavy.” Is “it” Danny? Is “it” the book? Is “it” the table? Who is “it”? You understand that we as human beings immediately understand that it means the book, right? Danny put the book on the table because it—the book—was heavy, okay? But how do you explain to a computer that “it” is the book? Maybe it’s Danny, maybe it’s the table, maybe it’s—I don’t know—maybe it’s the Holy One, blessed be He. Who is “it”? “I will be what I will be.” So the transformer basically knows how to do what’s called attention. What does that mean? It knows how to attribute the “it” to the relevant word in the sentence—and again, probabilistically. There’s a high probability that it’s the book, but some probability that it’s Danny or the table, okay? Here too there is a distribution, there are probabilities. That is achieved through training. It has seen many, many sentences, and the training built in it the distribution that helps it understand whether the word “it” refers to the book, to Danny, or to the table. That is achieved through training. But after I’ve trained the system, my transformer knows how to identify, through different distributions, to whom the word “it” refers, okay? And then what happens is that you feed in a sequence of words as a question, and now it takes all these words—not one after another, but all together—builds some distribution out of them, understands which word the “it” belongs to, disambiguates all the ambiguous words, turns them into some numerical vector, and from that vector it can predict what the next word will be. Again, I don’t care at the moment about the technical details, but I do want you to get used to the idea—to how this story works, how mechanical it is, and where statistics comes in, for example. You understand that the answer such a model gives is not “the answer.” There isn’t one single correct answer; there is a distribution, and there will be different answers. Sometimes it will give the most probable answer, sometimes it will give a less probable answer. And why? Why not always give the most probable answer? Because the most probable answer isn’t always actually the correct one—sometimes people write poems. So you want to give the model some kind of flexibility, and if you want to give it some kind of flexibility, you have to allow for some statistical component in its decisions. So the calculation it performs is deterministic; there is no statistics there. The calculation says: the word “table” has 70% probability, the word “mouse” has 15% probability, the word whatever has 8%, and so on. That is a deterministic calculation. But once I have all those probabilities, now I need to decide which word to output. Which word do I output? Here there is already what’s called sampling. Sampling says: I sample from this distribution and produce some result, where the sampling is done in such a way that 70% of the time you get cat, 15% of the time you get mouse, 8% of the time you get mood, okay? Something like that. And through the sampling I produce the word. Then I produce a word, attach that word to what came before, do embedding—yes, create a vector—search for the next word, and so on. At least that’s how it worked at the beginning; today they skip over that a bit, I think. I’m not fully up to date on the details either. But that’s the rationale; that’s how it works in principle. And little by little it basically gives you the next words that are expected to come after this question, and it turns out that those words are the answer we’re looking for, the one we want to receive. And that, basically, is how a large language model is built. A large language model is nothing other than a neural network trained on textual, linguistic tasks. But as I said, linguistic tasks are basically a translation of all possible tasks on earth. Everything can be translated into language, and if you know how to match one sentence to another in language, then in principle you know how to perform all conceivable tasks. We still don’t have—what’s it called?—AGI, yes? Artificial General Intelligence. “General” meaning a model that knows how to do everything. So every so often a new headline comes out: here, we’ve already reached AGI. Yes, now this latest GPT—what’s its name, I forgot, don’t remember—this one that just came out, GPT-6. Astra. Messages, what? GS Astra. Yes, exactly. So I’m saying, headlines came out: here, we’ve reached AGI, it already knows how to do everything. Fine. I spoke with it—not really. We’re not there yet. But we’re advancing, all right? So AGI is that dream of something that doesn’t make mistakes—that is, it knows how to do all tasks theoretically, yes? Or at least does them at a high level, all right? They always measure it by saying: it’s at the level of a PhD, meaning it knows how to answer like someone who has completed a doctorate in that field. In this field we’re still at the master’s level; in that field we’re at the middle-school level, and so on. We want something that knows how to answer all questions at the level of a specialist, an expert, a professor. But the big dream is that there will be a model that knows how to answer all questions—not at some level, but at a 100% level. That is, well, even the experts don’t know everything; we still have more to research, all right? AGI, theoretically—of course this is all hypothetical—but AGI in principle would answer every question with the correct answer, so there’s no point measuring what level it’s at. That is—yes, AGI is the ultimate. It knows how to answer everything, all of it, that’s it. It’s not a professor, because a professor doesn’t know everything either. At best, a professor knows what is known up to now. At best, right? He knows what is known up to now, but it has knowledge humanity has not yet reached. In principle, a perfect model knows how to answer all questions with the correct answers, and that’s it. It’s not a professor; it’s a perfect ultra-professor of the end of days in every field, okay? That is, assuming that by the end of days we will have reached all knowledge.
[Speaker D] More than that, when people talk about AGI they also mean that it will do lots of actions in the real world too, I don’t know—
[Rabbi Michael Abraham] Prepare food, yes. That’s already models that act, moving further ahead. I’m speaking right now—let’s talk on the intellectual plane. That is, it knows how to solve intellectual problems and answer questions. Of course after that you can translate it into machines that also perform physical actions in the world—that’s obviously a derivative—but right now I’m speaking only on the intellectual plane. So that is basically a broad-brush description of what a language model is. Now, I retuI think this was a bit dense. Those who already know the material obviously know it better than I do, but for those who don’t, I assume it was a little overloaded and not completely clear. I very strongly recommend: listen to this lecture again—those who don’t yet have a good grasp of it—because it’s very important to me that we understand this picture. In other words, this picture matters. I don’t care right now about the details, or exactly how this vector is built, or what comes after what, but I do want us to understand the idea of how this process works, okay? At the conceptual level. Because we’re going to want to ask all kinds of questions. At this point I’ve basically finished the technique, more or less, okay? Now we’ll want to ask various questions: what is the significance of this thing? What is it? To go back to all the introductions and ask ourselves various questions, now that we already know what a computer is, what a neural network is, and what an LLM is—yes, what a large language model is. And now we’ll ask ourselves, okay, what does this thing mean at the conceptual level? We’ll also talk a bit about agents and tools—yes, about tools and things of that sort—but as for the technical part, I’ve more or less finished it. So, really, in a very general way—and again, part of this is also because I’m not an expert—but I think I can more or less describe the rationale, how this whole business works.
[Speaker E] How does it know how to generalize things that weren’t sampled? Say mathematics, for example—what do I mean? Mathematics, after all, is not finite, right? I can do an interpretation, a calculation, for numbers it has never seen before, in language. But we, as human beings, know how to generalize, to formulate the more abstract law, so to speak. What, exactly, does AI know how to do based on what it has already seen before?
[Rabbi Michael Abraham] At the moment, in that area, astonishingly enough, AI is very weak at adding numbers. It fails catastrophically at adding numbers. Today that’s no longer the case, because now it connects to tools, but that’s not—ah—that’s it.
[Speaker E] So the tools basically close the gap. Yes. What? I understand. Right, I figured maybe there was some tool they connected to it so that it would know—
[Rabbi Michael Abraham] Yes, exactly.
I’ll talk more about the periphery of the models. There’s more periphery. And we’ll still talk a bit about that before we move on to the discussions and the implications and the meanings and so on. But it was important to me that we understand what this thing even means, and not talk about it in a completely detached way. Okay, that’s it for now. If there are comments or questions? No. Okay. So, may you have a good year, may you be sealed for good. We’re going into the break, okay? We’ll meet after Sukkot. The first Thursday after Sukkot.
[Speaker F] Thank you very much. Happy New Year.
[Rabbi Michael Abraham] Happy New Year, may you be sealed for good. May you be sealed for good, thank you very much.
[Speaker F] Good.