Comment by pmayrgundter | Hacker News Reader

Comment by pmayrgundter | Hacker News Reader

One of Wofram's comments is that there appears to be much more internal structure in language semantics that we had expected, contra-Chomsky.

We also know the brain, cortex esp, is highly recurrent, so it should be primed for creating fractals and chaotic mixing.

So maybe the hidden structure is the set of neural hyperparams needed to put a given cluster of neurons into fractal/chaotic oscillations like this. Seems potentially more useful too.. way more information content than a configuration that yields a fast convergence to a fixed point.

Perhaps this is what learning deep NNs is doing: producing conditions where the substrate is at the tipping point, to get to a high-information generation condition, and then shaping this to fit the target system as well as it can with so many free parameters.

That suggests that using iterative generators that are somehow closer to the dynamics of real neurons would be more efficient for AI: it'd be easier to drive them to similar feedback conditions and patterns

Like matching resonators in any physical system

Two quibbles: (1) neural nets don’t necessarily operate on language, (2) they only loosely model biological neurons in that they operate in discrete space. All that is to say that any similarities are purely incidental without accounting for these two facts.

Well, in some sense they don’t operate on language at all - but on mathematical representation of tokens derived from language.

I’m sure from your comment you are aware of the distinction, but it is an interesting concept for people to keep in mind.

1) agreed. it's exciting seeing the same basic architecture broadly applied

2) not sure what you mean by "operate in discrete space"

I'd emphasize the potential similarity to biological recurrence. Deep ANNs don't need to have this explicitly (tho e.g. LSTM has explicit recurrence), but it is known that recurrent NNs can be emulated by unrolling, in a process similar to function currying. In this mode, a learned network would learn to recognize certain inputs and carry them across to other parts of the network that can be copies of the originator, thus achieving functional equivalence to self feedback, or neighbor feedback. It takes a lot of layers and nodes in theory, but ofc modern nets are getting very big.

I didn’t phrase (2) particularly well. I meant that digital neural networks typically use floating point numbers, which can represent only discrete values. Do aliasing effects show up in the behavior of these networks that wouldn’t apply for continuously variable systems, or perhaps more appropriate for biological NNs, temporal coding via spike trains?

Per some offline discussion, I'll note that while this paper is about the structure of hyperparams, it also starts with the analogy between Mandelbrot & Julia sets, Julia as the hyperparam space for Mandelbrot, the param space

Well, they both also have similar fractal dimensions. Mandlebrot's Hausdorff dimension is 2, Julia is 1-2.

I won't argue it here but just suggest that this is an important complexity relationship and that the neural net being fit may also have similar fractal complexity, and that the distinction between param and hyper-param in this sense may be somewhat a red-herring

> Julia as the hyperparam space for Mandelbrot

It’s kind of the opposite, no? The Mandelbrot set is the set of points where the Julia set for that point includes that point.

Yeah, think you're right.. was reading the intro to the paper wrong. Just saw the acko visualization and was reminded your point

https://acko.net/blog/how-to-fold-a-julia-fractal/

Cheers!

An LLM does not model language. The name is misleading, and should be changed to Large Text Model.

Text is infinitely complex. Written text is only somewhat less so. The text people choose to write is full of complex entropy.

The language patterns we use to read text, on the other hand, are much more simple. The most complicated part is ambiguity, and we don't resolve that with language. Instead, we resolve ambiguity with context.

I wonder if we use LLM because LTM (and LSTM) was taken.

I doubt it. The entire purpose of an LLM is to make a model that does language (or at least something close enough). It's an easy mistake to name something what you hope it will do instead of what it literally is. Unfortunately, that distinction becomes important later.

It's a similar problem with "AI". Artificial Intelligence does not exist, yet we put that name on all kinds of things. This causes real problems, too: by labeling an LLM "AI", we anthropomorphize it. From then on, the entire narrative is misleading.

Intelligence does not imply sapience, or person-like-ness.

It doesn't need to to be a problem.

An LLM is a model, not an actor. As soon as we call it "AI", that distinction gets muddled, and the whole narrative follows.

> Text is infinitely complex.

No, it isn’t.

> An LLM does not model language. The name is misleading, and should be changed to Large Text Model.

What, because it isn’t processing speech?

Presumably you are aware of models that model recordings of speech, and therefore this isn’t what you mean.

In that case, it seems to me like you are probably jerrymandering some concepts?

The set of all possible written text is infinitely complex. That's not what is being modeled, though: LLMs model text that was written intentionally by humans. That's less complicated, but it's not simple enough for language rules to completely define it. Natural language is "context-sensitive", so the meaning of a written language statement is dependent on more than the language itself. That's why we can't just parse natural language like we can programming languages.

An LLM is a model of written text. It doesn't know anything about language rules. In fact, it doesn't follow any rules whatsoever. It only follows the model, which tells you what text is most likely to come next.

The set of all strings over an alphabet is infinite in cardinality. I don’t think I would say that it is infinitely complex. I don’t know how you are defining complexity, but the shortest program that recognizes the language “all strings (over this alphabet)” is pretty short.

A program that has a good rate at distinguishing whether a string is human written, would be substantially longer than one that recognizes the language of all strings over a particular alphabet.

If you want to generate strings instead of recognizing them, a program that enumerates all possible strings over a given alphabet, can also be pretty short.

Not sure what you mean by complexity.

I don’t know what you mean by “it doesn’t follow any rules at all”.

When you write a parser, you build it out of language (syntax) rules. The parser uses those rules to translate text into an abstract syntax tree. This approach is explicit: syntax is known ahead of time, and any correctly written text can be correctly parsed.

When you train an LLM, you don't write any language rules. Instead, you provide examples of written text. This approach is implicit: syntax is not known ahead of time. The core feature is that there is no distinction between what is correct and what is not correct. The LLM is liberated from the syntax rules of language. The benefit is that it can work with ambiguity. The limitation is that it can't decide what interpretation of that ambiguity is correct. It can only guess what interpretation is most likely, based on the text it was trained on.

Reply on news.ycombinator.com