6 ms·

I'm not sure about the 1.0/2.0/3.0 classification, but it did lead me to think about LLMs as a programming paradigm: we've had imperative & declarative, procedu

by OJFord 1y ago

I'm not sure about the 1.0/2.0/3.0 classification, but it did lead me to think about LLMs as a programming paradigm: we've had imperative & declarative, procedural & functional languages, maybe we'll come to view deterministic vs. probabilistic (LLMs) similarly. def __main__: You are a calculator. Given an input expression, you compute the result and print it to stdout, exiting 0. Should you be unable to do this, you print an explanation to stderr and exit 1. (and then, perhaps, a bunch of 'DO NOT express amusement when the result is 5318008', etc.)

ai-christianson 1y ago
Why does this remind me of COBOL.
- wiz21c 1y ago
  'cos COBOL was designed to be human readable (writable ?).
crsn 1y ago
This (sort of) is already a paradigm: https://en.m.wikipedia.org/wiki/Probabilistic_programming https://en.m.wikipedia.org/wiki/Probabilistic_programming
- stabbles 1y ago
  That's entirely orthogonal. In probabilistic programming you (deterministically) define variables and formulas. It's just that the variables aren't instances of floats, but represent stochastic variables over floats. This is similar to libraries for linear algebra where writing A * B * C does not immediately evaluate, but rather builds an expression tree that represent the computation; you need to do say `eval(A * B * C)` to obtain the actual value, and it gives the library room to compute it in the most efficient way. It's more related to symbolic programming and lazy evaluation than (non-)determinism.
dheera 1y ago
def __main__: You run main(). If there are issues, you edit __file__ to try to fix the errors and re-run it. You are determined, persistent, and never give up.
- beambot 1y ago
  Output "1" if the program halts; "0" if it doesn't.
  - fragmede 1y ago
    funnily enough, you can give the LLM the code and ask it if the function will halt, and for some cases of input, it is able to say that the program does/does not halt.
    - pxc 1y ago
      The halting problem is about being able to answer this question in full generality, though. Being able to answer the question for specific cases is already feasible and always was.
    - deleted 1y ago
      [deleted]
aaron695 1y ago
[flagged]
- diggan 1y ago
  > It makes no sense at all, it's cuckooland, are you all on crazy pills? First step towards understanding something you obviously have strong feelings about, is to try to avoid hitting those triggers while you think about the thing, otherwise it clouds you. Not a requirement by any measure, just a tip. > are you telling me people will do three years university to learn to prompt? Are people going to university for three years to write "1.0" or "2.0" software? I certainly didn't, and I don't think even the majority of software developers have done so, at least in my personal experience but YMMV. > I do not understand where there is anything here to be "not sure" on? They're not sure about the specific naming, not the concept or talk as a whole. > LLMs making non-deterministic mistakes Everything they do is non-deterministic when temperature is set to anything above 0.0, as that's the entire point. The "correct" answers are as non-deterministic as the "mistakes", although I'm not sure "mistake" is correct because it did chose the right/correct tokens, it's just that you didn't like/expect it to chose that particular tokens.
- bgwalter 1y ago
  > It makes no sense at all, it's cuckooland, are you all on crazy pills? Frequent LLM usage impairs thinking. The LLM has no connection to reality, and it takes over people's minds.
  - boppo1 1y ago
    >Frequent LLM usage impairs thinking Is there hard evidence on this?
    - MattRix 1y ago
      yes https://www.mdpi.com/2075-4698/15/1/6 https://www.mdpi.com/2075-4698/15/1/6
    - bgwalter 1y ago
iLoveOncall 1y ago
> maybe we'll come to view deterministic vs. probabilistic (LLMs) similarly I can't believe someone would seriously write this and not realize how nonsensical it is. "indeterministic programming", you seriously cannot come up with a bigger oxymoron.
- diggan 1y ago
  Why do people keep having this reaction to something we're already used to? When you're developing against an API, you're already doing the same thing, planning for what happens when the request hangs, or fails completely, or gives a different response, and so on. Same for basically any IO. It's almost not even new, just that it generates text instead of JSON, or whatever. But we've already been doing "indeterministic programming" for a long time, where you cannot always assume a function 100% returns what it should all the time.
  - klabb3 1y ago
    You’re right about the trees but wrong (hear me out) about the forest. Yes, programming isn’t always deterministic, not just due to the leftpad API endpoint being down, but by design - you can’t deterministically tell which button the user is going to click. So far so good. But, you program for the things that you expect to happen, and handle the rest as errors. If you look at the branching topology of well-written code, the majority of paths lead to an error. Most strings are not valid json, but are handled perfectly well as errors. The paths you didn’t predict can cause bugs, and those bugs can be fixed. Within this system, you have effective local determinism. In practice, this gives you the following guarantee: if the program executed correctly until point X, the local state is known. This state is used to build on top of that, and continue the chain of bounded determinism, which is so incredibly reliable on modern CPUs that you can run massive financial transactions and be sure it works. Or, run a weapons system or a flight control system. So when people point out that LLMs are non-deterministic (or technically unstable, to avoid bike-shedding), they mean that it’s a fundamentally different type of component in an engineering system. It’s not like retrying an HTTP request, because when things go wrong it doesn’t produce “errors”, it produces garbage that looks like gold.
semiquaver 1y ago
LLMs are not inherently indeterministic. Batching, temperature, and other things make them appear so when run by big providers but a locally-run LLM model at zero temperature will always produce the same output given the same input.
- oytis 1y ago
  That's an improvement, they are still "chaotic" though in that small changes in input can change the output unpredictably strong
  - behnamoh 1y ago
    Yes, this paper says exactly what you talked about: https://arxiv.org/abs/2404.01332 https://arxiv.org/abs/2404.01332
- lmeyerov 1y ago
  That assumes they were implemented with deterministic operators, which isn't the default assumption when using neural network libs on GPUs. Imagine random seeds, cublas optimizations - like you can configure all these things, but I wouldn't assume it, esp in GPU-optimized OSS..
llflw 1y ago
Why bother using human language to communicate with a computer? You interact with a computer using a programming language—code—which is more precise and effective. Specifically: → In 1.0, you communicate with computers using compiled code. → In 2.0, you communicate with compilers using high-level programming languages. → In 3.0, you interact with LLMs using prompts, which arguably should not be in natural human language. Nonetheless, you should communicate with AGIs using human language, just as you would with other human beings.
- standeven 1y ago
  Why bother using higher-level programming languages to communicate with a computer? You interact with a computer using assembly - raw bit shifting and memory addresses - which is more precise and effective.
  - wing-_-nuts 1y ago
    You can express dang near anything you wish to express in assembly in a higher order programming language because it is designed to allow that level of clarity and specificity. In fact most have compile time checks to stop you if you have not properly specified certain behavior. The English language is not comparable. It is a language designed to capture all the ambiguity of human thought, and as such is not appropriate for computation. TLDR: There's a reason why programmers still exist after the dawn of 4GL / 'no code' frameworks. Otherwise we'd all be product managers typing specs into JIRA and getting fully formed applications out the other side.
  - dustbunny 1y ago
    Using assembly is not really more precise in terms of solving the problem. You can definitely make an argument that using a higher level language is equally if not more precise. Especially since your low level assembly will be limited to which architectures it can run on, you can state that the c++ that generates that assembly is "more precisely defining a calculator program".
    - tim333 1y ago
softfalcon 1y ago
If this is what it comes to, it would explain the many, many software malfunctions in Star Trek. If everything is an LLM/LRM (or whatever super advanced version they have in the 23rd century) then everything can evolve into weird emergent behaviours. stares at every weird holo-deck episode
- kewldev87 1y ago
  [dead]
no_wizard 1y ago
I wonder when companies will remove the personality out of LLMs by default, especially for tools
- dingnuts 1y ago
  that would require actually curating the training data and eliminating sources that contain casual conversation too expensive since those are all licensed sources, much easier to train on Reddit data
  - amelius 1y ago
    Just ask an LLM to remove the personality from the training data. Then train a new LLM on that.
    - omneity 1y ago
      It will work, but at the scale needed for pretraining you are bound to have many quality issues that will destroy your student model, so your data cleaning process better be very capable. One way to think of it is that any little bias or undesirable path in your teacher model will be amplified in the resulting data and is likely to become over represented in the student model.
OJFord 1y ago
You know, the more I think about it, the more I like this model. What we have today with ChatGPT and the like (and even IDE integrations and API use) is imperative right, it's like 'answer this question' or 'do this thing for me', it's a function invocation. Whereas the silly calculator program I presented above is (unintentionally) kind of a declarative probabilistic program - it's 'this is the behaviour I want, make it so' or 'I have these constraints and these unknowns, fill in the gaps'. What if we had something like Prolog, but with the possibility of facts being kind of on-demand at runtime, powered by the LLM driving it?

by OJFord 1y ago

ai-christianson 1y ago

Why does this remind me of COBOL.

wiz21c 1y ago
'cos COBOL was designed to be human readable (writable ?).

crsn 1y ago

This (sort of) is already a paradigm: https://en.m.wikipedia.org/wiki/Probabilistic_programming https://en.m.wikipedia.org/wiki/Probabilistic_programming

stabbles 1y ago
That's entirely orthogonal. In probabilistic programming you (deterministically) define variables and formulas. It's just that the variables aren't instances of floats, but represent stochastic variables over floats. This is similar to libraries for linear algebra where writing A * B * C does not immediately evaluate, but rather builds an expression tree that represent the computation; you need to do say `eval(A * B * C)` to obtain the actual value, and it gives the library room to compute it in the most efficient way. It's more related to symbolic programming and lazy evaluation than (non-)determinism.

dheera 1y ago

def __main__: You run main(). If there are issues, you edit __file__ to try to fix the errors and re-run it. You are determined, persistent, and never give up.

beambot 1y ago
Output "1" if the program halts; "0" if it doesn't.
- fragmede 1y ago
  funnily enough, you can give the LLM the code and ask it if the function will halt, and for some cases of input, it is able to say that the program does/does not halt.
  - pxc 1y ago
    The halting problem is about being able to answer this question in full generality, though. Being able to answer the question for specific cases is already feasible and always was.
  - deleted 1y ago
    [deleted]

aaron695 1y ago

[flagged]

diggan 1y ago
> It makes no sense at all, it's cuckooland, are you all on crazy pills? First step towards understanding something you obviously have strong feelings about, is to try to avoid hitting those triggers while you think about the thing, otherwise it clouds you. Not a requirement by any measure, just a tip. > are you telling me people will do three years university to learn to prompt? Are people going to university for three years to write "1.0" or "2.0" software? I certainly didn't, and I don't think even the majority of software developers have done so, at least in my personal experience but YMMV. > I do not understand where there is anything here to be "not sure" on? They're not sure about the specific naming, not the concept or talk as a whole. > LLMs making non-deterministic mistakes Everything they do is non-deterministic when temperature is set to anything above 0.0, as that's the entire point. The "correct" answers are as non-deterministic as the "mistakes", although I'm not sure "mistake" is correct because it did chose the right/correct tokens, it's just that you didn't like/expect it to chose that particular tokens.
bgwalter 1y ago
> It makes no sense at all, it's cuckooland, are you all on crazy pills? Frequent LLM usage impairs thinking. The LLM has no connection to reality, and it takes over people's minds.
- boppo1 1y ago
  >Frequent LLM usage impairs thinking Is there hard evidence on this?
  - MattRix 1y ago
    yes https://www.mdpi.com/2075-4698/15/1/6 https://www.mdpi.com/2075-4698/15/1/6
  - bgwalter 1y ago

iLoveOncall 1y ago

> maybe we'll come to view deterministic vs. probabilistic (LLMs) similarly I can't believe someone would seriously write this and not realize how nonsensical it is. "indeterministic programming", you seriously cannot come up with a bigger oxymoron.

diggan 1y ago
Why do people keep having this reaction to something we're already used to? When you're developing against an API, you're already doing the same thing, planning for what happens when the request hangs, or fails completely, or gives a different response, and so on. Same for basically any IO. It's almost not even new, just that it generates text instead of JSON, or whatever. But we've already been doing "indeterministic programming" for a long time, where you cannot always assume a function 100% returns what it should all the time.
- klabb3 1y ago
  You’re right about the trees but wrong (hear me out) about the forest. Yes, programming isn’t always deterministic, not just due to the leftpad API endpoint being down, but by design - you can’t deterministically tell which button the user is going to click. So far so good. But, you program for the things that you expect to happen, and handle the rest as errors. If you look at the branching topology of well-written code, the majority of paths lead to an error. Most strings are not valid json, but are handled perfectly well as errors. The paths you didn’t predict can cause bugs, and those bugs can be fixed. Within this system, you have effective local determinism. In practice, this gives you the following guarantee: if the program executed correctly until point X, the local state is known. This state is used to build on top of that, and continue the chain of bounded determinism, which is so incredibly reliable on modern CPUs that you can run massive financial transactions and be sure it works. Or, run a weapons system or a flight control system. So when people point out that LLMs are non-deterministic (or technically unstable, to avoid bike-shedding), they mean that it’s a fundamentally different type of component in an engineering system. It’s not like retrying an HTTP request, because when things go wrong it doesn’t produce “errors”, it produces garbage that looks like gold.

semiquaver 1y ago

LLMs are not inherently indeterministic. Batching, temperature, and other things make them appear so when run by big providers but a locally-run LLM model at zero temperature will always produce the same output given the same input.

oytis 1y ago
That's an improvement, they are still "chaotic" though in that small changes in input can change the output unpredictably strong
- behnamoh 1y ago
  Yes, this paper says exactly what you talked about: https://arxiv.org/abs/2404.01332 https://arxiv.org/abs/2404.01332
lmeyerov 1y ago
That assumes they were implemented with deterministic operators, which isn't the default assumption when using neural network libs on GPUs. Imagine random seeds, cublas optimizations - like you can configure all these things, but I wouldn't assume it, esp in GPU-optimized OSS..

llflw 1y ago

Why bother using human language to communicate with a computer? You interact with a computer using a programming language—code—which is more precise and effective. Specifically: → In 1.0, you communicate with computers using compiled code. → In 2.0, you communicate with compilers using high-level programming languages. → In 3.0, you interact with LLMs using prompts, which arguably should not be in natural human language. Nonetheless, you should communicate with AGIs using human language, just as you would with other human beings.

standeven 1y ago
Why bother using higher-level programming languages to communicate with a computer? You interact with a computer using assembly - raw bit shifting and memory addresses - which is more precise and effective.
- wing-_-nuts 1y ago
  You can express dang near anything you wish to express in assembly in a higher order programming language because it is designed to allow that level of clarity and specificity. In fact most have compile time checks to stop you if you have not properly specified certain behavior. The English language is not comparable. It is a language designed to capture all the ambiguity of human thought, and as such is not appropriate for computation. TLDR: There's a reason why programmers still exist after the dawn of 4GL / 'no code' frameworks. Otherwise we'd all be product managers typing specs into JIRA and getting fully formed applications out the other side.
- dustbunny 1y ago
  Using assembly is not really more precise in terms of solving the problem. You can definitely make an argument that using a higher level language is equally if not more precise. Especially since your low level assembly will be limited to which architectures it can run on, you can state that the c++ that generates that assembly is "more precisely defining a calculator program".
  - tim333 1y ago

softfalcon 1y ago

If this is what it comes to, it would explain the many, many software malfunctions in Star Trek. If everything is an LLM/LRM (or whatever super advanced version they have in the 23rd century) then everything can evolve into weird emergent behaviours. stares at every weird holo-deck episode

kewldev87 1y ago
[dead]

no_wizard 1y ago

I wonder when companies will remove the personality out of LLMs by default, especially for tools

dingnuts 1y ago
that would require actually curating the training data and eliminating sources that contain casual conversation too expensive since those are all licensed sources, much easier to train on Reddit data
- amelius 1y ago
  Just ask an LLM to remove the personality from the training data. Then train a new LLM on that.
  - omneity 1y ago
    It will work, but at the scale needed for pretraining you are bound to have many quality issues that will destroy your student model, so your data cleaning process better be very capable. One way to think of it is that any little bias or undesirable path in your teacher model will be amplified in the resulting data and is likely to become over represented in the student model.

OJFord 1y ago

You know, the more I think about it, the more I like this model. What we have today with ChatGPT and the like (and even IDE integrations and API use) is imperative right, it's like 'answer this question' or 'do this thing for me', it's a function invocation. Whereas the silly calculator program I presented above is (unintentionally) kind of a declarative probabilistic program - it's 'this is the behaviour I want, make it so' or 'I have these constraints and these unknowns, fill in the gaps'. What if we had something like Prolog, but with the possibility of facts being kind of on-demand at runtime, powered by the LLM driving it?