It's already been more than two years since I last shat on the whole subject of AI, and also more than a year since my last brief commentary on the matter. Meanwhile, the bubble that we've all been expecting to burst has only gotten bigger; and it's caused quite a few changes in the so-called technological landscape along the way, from hardware pricing to collateral damage caused by "hyperscaler" datacenters, to heated debates on who's the bestest model of them all. So if none others, these are good enough reasons to review said subject.
First of all, I should mention that while I still don't believe that LLMs are able to think in the proper sense, and that their association with "thought" is a perversion, I don't claim to have any sort of ideological beef with them. Quite the contrary, in fact: all the naïve reactionary waves of the "AI is taking our jobs" ilk make me believe there is something to it. After all, computers are tools, so even assuming LLMs may be a particularly broken variety thereof, I think it would be a sin to paint them in such preconceived colours.
Second of all, I'll add that while I'll do all I can to leave aside the ideological and sociopolitical commentary, I can't lie that my assessment of LLMs is largely influenced by my personal experience with it. Your mileage may vary, and unfortunately the sheer complexity of these tools makes it so that I can't properly evaluate the exact variance between your mileage and mine -- which incidentally is also why I think that "AI benchmarks" are bullshit. For example, my own experience with LLMs is biased towards baking software or studying subjects related to computing, and to this end I've used various classes of models (Claude, Gemini, GPT) in specific ways that work well in specific circumstances while failing utterly in others; thus, frankly speaking, I don't think I have enough space to cover these specifics in a single reasonably-sized blog article.
So before even attempting to focus on specifics, let's try to sort out the generics. More precisely, any Large Language Model -- or, dare I say, any "generative AI" -- is a function of:
- a large (tera/petabyte-sized) corpus of so-called "training data"; think: literature, academic databases, videos, emails, Facebook comments, in other words, all the data that a large "service provider" such as Google or Meta could have gathered in a few decades;
- a "training algorithm", which is a mechanism that can be described in a variety of ways, among which: a lossy compression scheme; or a statistical pattern matching scheme; or a geometrical processing function; in any case, an algorithm which reduces the training data to a so-called "model" that lies today in the order of tens to hundreds of gigabytes; there's quite a lot to say about these models, but I'll only add that the smallest practically usable model should fit within the amount of memory of a beefier GPU, otherwise really, there's no point to the whole exercise;
- a user input, which is typically a bunch1 of text, i.e. the so-called "prompt"; and finally,
- a so-called "inference algorithm", which runs the user input "through" the model and as such, based on the two pieces (the user input and the model), generates some output data, as if attempting to statistically decompress a portion of the initial data, by generating "the most expected reply" to the input.
There is a lot of detail to unpack in that "inference" part as well; but perhaps the most important side to it is that the user input goes through a preprocessing phase, and that the preprocessed input, stored under the form of so-called "tokens" (symbolic representations of the initial user-provided data), is called a "context". And all the technical jargon aside, this "context" is important because the typical "AI conversation session" is designed so that the associated data accretes as the so-called "conversation" progresses: you feed the so-called agent one piece of text, and it answers; and as you feed it the second, third and so on up until the Nth piece, the entire history of that conversation is fed back into the loop, so that the agent keeps a semblance of a short-term memory. There are at least two problems with this approach: one is that the available space for holding context is limited, and thus precious, and so the resource usage costs tend to mount as the conversation advances; and the other problem, and the more painful among the two in my opinion, is that performance tends to decrease proportionally with context size. And as far as the second problem goes, both response time and response quality tend to suffer, at least as far as my experience goes.
Now, as I've said before, there's a lot more detail to this, and a large bunch of it pertains to each particular type of model: some implementations are more sycophantic than others, or more hallucinogenic, or capable of generating some particular classes of data (e.g. images) or others. But all these details aside, all LLMs are constrained by the same factors, which derive from the design space exposed above; namely: the relation between the input size and inference/model capacity; and the relation between the user-provided data and the training algorithm/corpus. In other words: the latter relation says that the quality of the output depends on the quality of the input data and that of the training corpus2; while the former stipulates that the input space is finite, and more precisely bounded to (probably the logarithm of) the model size3.
At this point, the reader will naturally stop and ask: but Lucian, how exactly could one achieve the feat of working with LLMs within these efficiency constraints? the problem being that those who choose to work with LLMs are indeed treading a fine line between a win in orders of magnitude and a loss in the same, which actually denotes the exact characteristics of a power tool at the end of the day. The other problem downstream being that, once your competition becomes able to solve a non-trivial problem in a day as opposed to a month, you're pretty much coaxed into using the same means, so it's not like LLMs are optional anymore.
The answer to the question in the previous paragraph is that, well, it depends: on the problem domain, and on how well you can master it and all the interconnected fields surrounding it, not to mention the particulars of the problem itself and the space of potential solutions. Supposedly AI should help you understand things that you weren't familiar with before; but -- unless you possess excellent reading comprehension skills, and the patience to go through the tons upon tons of output that a LLM agent is able to generate within seconds, I'm pretty sure that it will be more of a hindrance rather than a helper. In my recent but plurious private discussions on AI, I've readily confessed that in the past few months I've scarcely skimmed the code generated by LLMs; in fact, if some agent manages to bullshit me, then the code is going to be the least of my worries, since the faulty code is most likely a symptom of a more fundamental aspect that I'd overlooked in one of the preceding conversations. Instead, nowadays I spend a painstaking amount of labour, and then some, to make sure that I've crossed all the tees and dotted all the eyes, as they say. And if shit goes down, I will rather clear the LLM context and start from scratch with corrected prompts rather than persisting in the accumulated errors of a faulty session.
But this is already getting into the sphere of practical advice, which this article was not meant to provide. My point is that LLMs do indeed have some limited use if you're very careful when and how to use them; and just like it usually goes with stupidity, they also hold an unlimited potential for misuse if you're not.
Post Scriptum, and a note to self: maybe discuss the human-machine interfacing angle sometime.
-
Typically around a few kilobytes, but often going in the order of megabytes to tens or hundreds of megabytes. Note the difference in scale between the initial training corpus, the model and the user input. This should give the reader an intuition of, if not how, then at least why AIing is a hard, computationally-intensive problem, at least for machines based on silicon substrates. How the human nervous system manages to do it more efficiently, that's an open question that an AI cannot answer; at least not yet. ↩
-
On one side, if you're trying, say, to solve a problem in the field of medicine, but the model you use was not trained on a corpus containing medical papers and the likes, then that model will be anti-useful, and that is leaving aside that no model, not even ones trained on medical data, are able to emit any sort of original prose. They're at most able to organize the information (that they were trained on) in a way that help you reach an original conclusion, and that is if you provide useful inputs.
Which brings us to the other side: if you're not trained in the medical sciences, and for some arbitrary reason -- say, that your left testicle hurts and you have no idea why -- you try to get info from a LLM, well... that still won't be of any actual use, given that you don't have access to the sort of language that would help one get an insight into this problem domain.
In other words, LLMs really are statistical expert systems of sorts, in that both the expert and the system must be a fit for each other in order for the work to do the work, if y'know what I mean. ↩
-
This boundedness is hard to evaluate in general, but what this means in practice, and in principle, is that it's not possible to discuss problems ad infinitum with a generative AI, i.e. you actually have a very limited (ten or so) number of turns to get a decent response; and as a consequence, the problems you discuss cannot be open-ended. Even if previously unsolved, the problem you're working on must have a very well-defined, measurable epistemological scope; that is, its conclusions must be at least potentially, if not actually (as in e.g. predicate logic) derivable from the premises.
Say, if you want the LLM to write a computer program for you, said program must be reasonably sized, e.g. in a number of variables that is proportional to the logarithm of the number of available tokens, as per the SAT problem; and it must be specified at least to the extent that you yourself would be able to implement it without any additional questions. Otherwise, if the problem size is too large, then you need to layer your design on multiple levels and work on them independently in separate sessions (y'know, just like in real life); or if it's not sufficiently clearly specified, the result will be a mess that you'll have a very hard time recovering from (also just like in real life). In other words, the whole idea is to build your inputs such that they steer the damned thing to converge into a singular state, or at least somewhere within the boundaries of a finite and well-determined set.
But say, try to discuss Heidegger with a LLM, and at worst you'll get some regurgitated crap; while at best you'll get references to texts you did not previously know. The "interpretation" is going to suck either way. ↩