M3 module was formalized fully purely from experimental data and from a nudge by earlier versions of codex in 15-30 minutes in a simple write/compile/fix-first-error loop. I was a bit surprised how fast it picked up the pattern but given there was a paper from '70s it became clear why later.
Regret analysis in bandit and similar algorithms shows how inference is connected to loss function. If your loss function is good, greedy inference is as good as joint inference.
Training on cost-to-go loss is good enough.
Perfect cost-to-go eliminates the need for global algorithms and allows local decision making. Given “natural” datasets it is probably the best thing to attempt to learn.
The fact that probabilistic graphical models never really worked proves it somewhat.
Github was already struggling with bazillions of throw-as-much-crap-on-the-wall software running in actions, and now the world is running throw-as-much-LLM-crap-on-the-wall computation, as unstoppable as the pre-LLM era. Turning compute into excrement as fast as the planet is filled with it. Excrement being "Github Copilot code review" in compute world, and no need to draw what it is in our real world.
Weird that Anthropic decided to build a Claude Code Routines toilet.
Following the bottle-cap madness, I don't think any current data shows the actual issue was resolved. Even worse, the effect on marine life is still not measured, and afaik reduction of harm was the primary goal. Instead of brutally high fines on fishing net waste, we got bottle-cap madness.
We have so much experience with scientific method, yet these massive decisions are adhoc, that's how the whole world works. We never tested what would happen by allowing mass production of plastic, or phones, or whatever, so these antipatches are going by the "feels" as well, with no individual taking responsibility for failures.
haha, all of a sudden I see a tab "waifu pillow" on Amazon, and think I have a split personality that runs searches in between consciousness shifts, and then I come back to a funny message.
I had a similar feeling trying to calculate some combinatorial structures. At some point the LLM made a connection to extremal combinatorics and calculated tighter bounds and got me to the solution faster.
Felt flashbacks of playing chess against humans online as a teen by copying moves from a chess engine.
Libraries create boundaries, which are in most cases arbitrary, that then limit the way you can interact with code, creating more boilerplate to get what you want from a library.
Abstractions are the source of bloat. Without abstractions you can always reduce bloat, or you can reduce bloat in your glue, but you can't reduce glue.
It takes discipline to NOT create arbitrary function signatures and short-lived intermediate data structures or type definitions. This is the beginning of boilerplate.
So many advances in removing boilerplate are realizing your 5 function calls and 10 intermediate data structures or type definitions, essentially compute a thing that you can do with 0 function calls and 0 custom datatypes and less lines of code.
The abstraction hides how simple the thing you want is.
Problem is that all open source code looks like the bloat described above, so LLMs have no idea how to actually write code that is without boilerplate. The only place where I've seen it work is in shaders, which are usually written to avoid common pitfalls of abstraction.
LLMs are incapable of writing a big program in 1 function and 1 file, that does what you want. Splitting the program into functions or even multiple files, is a step you do after a lot of time, yet all open source looks nothing like that.
White colar work is just a lucky place to be, 99% of it is completely made up, there's people doing nothing, and people doing work of 10 people, does not matter, the work itself has no impact on anything.
A nice way to realize why this AI wave hasn't produced massive economy growth, it is mostly touching parts of economy which are parasitic and can't really create growth.
No. There is good signal in IMO gold medal performance.
These models actually learn distributed representations of nontrivial search algorithms.
A whole field of theorem provingaftwr decades of refinements couldn’t even win a medal yet 8B param models are doing it very well.
Attention mechanism, a bruteforce quadratic approach, combined with gradient descent is actually discovering very efficient distributed representations of algorithms. I don’t think they can even be extracted and made into an imperative program.
On reddit it's even worse, I feel like Reddit is internally having their own bots for engagement bait.
As someone who loves LaTeX, I can't imagine ever spending so much time on typography on online forums, italics, bold, emdashes, headers, sections. I quit reddit and will quit hn as well if situation worsens.
Funny how pydantic is used to parse and not validate but then there are post conditions after parsing which you should parse actually or which can be enforced with json schema and properly implemented constrained sampling on the LLM side.
Pipelines are often dynamic, how is this achieved?
Pipelines are just a description of computation, sometimes it makes sense to increase throughput, instead of low latency, by batching, is execution separate from the pipeline definition?
It's quite tricky as they optimize the agent loop, similar to codex.
It's probably not enough to have answer-prompt -> tool call -> result critic -> apply or refine, there might be a specific thing they're doing when they fine tune the loop to the model, or they might even train the model to improve the existing loop.
You would have to first look at their agent loop and then code it up from scratch.
https://github.com/vjeranc/fixed-rtrt
M3 module was formalized fully purely from experimental data and from a nudge by earlier versions of codex in 15-30 minutes in a simple write/compile/fix-first-error loop. I was a bit surprised how fast it picked up the pattern but given there was a paper from '70s it became clear why later.