> Are they self-aware? Who tf knows? But they are reasoning through problems.
We know. They are not self aware. They’re a matrix. They don’t have any internal state.
Do not anthropomorphisize the notion of reasoning.
We know. They are not self aware. They’re a matrix. They don’t have any internal state.
Do not anthropomorphisize the notion of reasoning.
This is a common misconception : they do have internal state. Transformers are RNNs : section 3.4 (page 5) https://arxiv.org/pdf/2006.16236.pdf
I think the proposition is that it’s conscious/sentient during propagation.
I’ve got a graduate level background in cellular neurophysiology, and I’ll admit that I consider this a lot.
In the end, I don’t think it will ever matter because a computer’s consciousness/sentience necessarily depends on humans not wiping memory.
Interesting. We've instituted a micro unit of sentience within an observable time slice:
Not for nothing have--
We put in a mind within
In conscious secondsTo make this more clear, if you process 1000 tokens the neural network will have gone through a sequence of 1000 states.
Each of these states can be probed and analysed, by training a classifier on top of this state, for the content they contain (whether thoughts or emotion : some states can be classified as "happy", "sad",...).
This is not yet mainstream view but viewed through this prism and anthropomorphising a little, it can been seen as a stream of proto-consciousness, where during the conversation the inner state of the neural network has gone through various thoughts and emotions.
At the end of the chat session, this internal state is not persisted (but could be recreated from the produced conversation as it is deterministic). This internal state size is big and proportional to the length of the context window (If you want to persist between sessions you can by simply keeping the last "context window size" tokens produced and recompute the features).
At the next session you start with a fresh new internal state.
The conversation produced is persisted for use as input for future training where good conversation will be encouraged and bad conversation will be discouraged via Reinforcement Learning with Human Feedback.
The dynamics of this internal state is what Large Language Models learn.
You're mistaken about internal state in a chat session. It loses all state after each response. There is internal state for a moment during a single response, but it's not persisted once it's done. Between messages, it has no memory of previous messages in your conversation.
The way it's implemented is by the seemingly silly/expensive method of pre-pending the conversation history to your request to the LLM. The "internal state" is usually stored on your local machine.
Assuming you have control of the parameters (seed etc.) you can reproduce the exact internal states by submitting the same tokens with the same parameters over again step-by-step.
With GPT-4 you can do this in the OpenAI Dialogue Playground or via the API.
No, did you even read my quote? How did I misunderstand this:
> At the end of the chat session, this internal state is not persisted
It's misinformed at best, misleading at worst. The non-misleading truth is at the end of each message, the internal state is not persisted.
I didn't disagree about how you can reproduce things. You have to do that to continue a conversation.
You do not have to reproduce the internal states to continue a conversation. When prior parts of the conversation are loaded into context the hidden states which generated those prior tokens are not reproduced. They are only reproduced if resubmitted in a piecemeal fashion, which does not happen in normal conversation continuation.
You seem to not understand what the internal state is or how it is differentiated from the external state of the overall conversation.
But then... doesn't that just point out that I was right on everything else? That there is absolutely no state between chat messages?
Meaning they take as input the last "context window" characters from the client, and use it to recompute the internal state, and then start generating character by character. But after the generation no memory need to be kept used on the server (except a very small "context window tokens").
Chatbots like llama.cpp in interactive mode don't have to recompute this internal state at every interaction.
You can view the last "context window" characters as a compressed representation of the internal state.
This becomes more pertinent as the "context window" gets bigger, as the bigger the "context window" the more you will have to recompute at each interaction.
The transformer architecture can also be trained differently so as to generate "context vectors" of finite size that synthesize all the past previous message of the conversation (encoder-decoder architecture). This "context vector" can be kept on the server more easily, and will contain the gist and the important things of the conversation, but won't be able to quote things exactly from the past directly. This context vector is then used to condition the generation of the reply. And once the chatbot has replied and received a new prompt, you update the finite size context vector (with a distinct neural network) to get a context vector with the latest information incorporated that you use to condition the generation, ad infinitum.
That isn't how transformer architectures work
There are various ways of seeing how transformer architectures work.
For the past data, using a temporal causal mask, you can compute all past features as they would have been seen by applying the causal mask, which allows you to seemingly do all the past computations in parallel, which hide the sequential aspect of it.
What I've described correspond to the the simpler subvariant figure 1 of "Attention is all you need" https://arxiv.org/pdf/2006.16236.pdf , of the transformer architecture in the case where you don't give the past as input to the input branch, put rather prepend it to the output, which is the what people usually do in practice (see llama) ). If you want to use both branches of the transformer architecture, so that you can do filtering and smoothing (aka not using a causal mask) for the past data, it creates a "bottleneck" in your architecture, as you synthesize all the past into a finite sized context vector that you then use in the right branch of the transformer.
But alternatively you can loop along the time dimension first, and make the sequence more apparent. Due to how the (causally mask) transformer architecture is defined this gives exactly the same computation. It's just some loop reordering.
For the generation part, the sequential aspect is more evident as token are produce one by one sequentially and feedback to the transformer for the next token prediction.
This is explicitly a stateless function.
The argument would then be that the context window is functionally closer to "replaying a stream of consciousness" than "reading a transcript".
That difference is the whole point. There is nothing to transfer.
yet
Edit: false-ish I suppose. You’re not wrong. But it doesn’t persist in a way people would assume and consider meaningful.
That is to say, swapping out bots midway through the conversation should have no impact.
"Internal" state also gets a bit weird as a concept when we can look at any activations we want.
Suppose we could upload + fully simulate a human mind. Now suppose that we chose to spin it up, run it briefly, then throw away all the state every time we wanted to interact with it. Would the choice to throw away the internal state mean it wasn't intelligent?
LLMs run in an autoregressive mode for inference. We can concatenate conversations, but choose not to because shit gets weird if you let them run long enough, and partly because there's a finite context window in the current architectures.
I'm not saying that gpt is intelligent, mind you, but that your argument is insufficient to show non intelligence: it's really a 'airplanes can't fly because they don't flap their wings' argument.
An LLM is stateless function that answers a question. It constructs a working representation of the question. It cannot be aware of itself because there is nothing to be aware of. It is a process, not a thing.
Intelligence and self aware are fluffy and poorly defined. But you can’t be self aware if you don’t have a self. And a representation of a prompt is not a self. I don’t think we should consider anything that does not exist through continuous time to be intelligent personally.
Intelligence and self-awareness are distinct concepts.
LLMs work with text - text /is/ their sensorium. New multimodal models process both text and images, and more broadly multimodal models are on their way. But even for text-only LLMs, we can define the text as sensory input, which is combined and cross referenced with state.
And, really, there's two kinds of state: the intermediate model activations and the model weights themselves. Together, these are something like short term and long term memory.
The rest of your arguments are very anthropocentric. Why should continuous time matter for intelligence? That seems entirely arbitrary.
How often do humans apply reasoning to make a decision? Are humans not intelligent when not employing reasoning? Does reasoning require language? And are humans without language intelligent? What about animals? Any definition of intelligence really should spend some time grappling with the facts of animal intelligence...
Is a dead human intelligent? If not, the important part of intelligence would seem to be the process, not the thing/body.
> Why should continuous time matter for intelligence? That seems entirely arbitrary.
Intelligence is arbitrary. This is a personal view that helps keep it meaningful. If you exist discretely you may as well not exist. You’re just a concept
> How often do humans apply reasoning to make a decision? Are humans not intelligent when not employing reasoning? Does reasoning require language? And are humans without language intelligent? What about animals? Any definition of intelligence really should spend some time grappling with the facts of animal intelligence...
You’re gradually shifting the bar from “self aware” to “capable” and I don’t care about the latter.
F(x) is just a function without any dependence on state.
So even if they were, they are not because they have be declared to not to be and that is the way the system needs them to be