Open question - are these proofs brute forcing, or are they generating new theory at a level of abstraction and complexity we can't understand?
Controversial statement: I think we've always done math by generalising from concrete experience. So concepts like numbers, spaces, shapes, distances, and curvature are based on physical experiences we use as anchors before expanding them far beyond physicality and looking for patterns in the abstractions.
If AI is generalising from patterns in latent space, that's a different kind of abstraction, and one that's much more alien to us, because it's going to be much, much bigger - too big to fit inside even the smartest human mind.
So AI theories and abstractions may be valid in true/false terms, but we will never be able to comprehend them in their raw form - just as we can't experience latent space directly, and will only experience tiny slices of it as outputs to our queries.
> If AI is generalising from patterns in latent space, that's a different kind of abstraction
How's latent space conceptually different from neuronal activations in our brains?
> just as we can't experience latent space directly,
Your LLM also doesn't "experience" their activations in the latent space either when generating tokens.
I'm not saying LLMs are not conscious/sentient/etc. Just saying if you ask your LLM which activation was stronger that led to a particular solution, they won't be able to answer without using external tools to inspect it.
It may just be that LLMs have such a huge context window (short-term memory) compared to humans, that they can process a lot more raw data without having to compress them into theories yet.
If they're wanting to focus on using GPUs instead of playing finance games, then why are they spending all the time playing finance games on $8B when they've got >$100B cash on hand?
> So the author's point is that "other" can never appear in-between "parent before" and "child start".
But isn't it true for JavaScript too? So I don't really get the author's point... am I missing something or the author('s LLM?) forced a moot comparison to JavaScript?
Edit: after reading the examples twice I am 99.9% sure it's slop and flagged it.
In JS, there are microtasks and macrotasks. setTimeout creates macrotasks. `.then` (and therefore `await`) creates microtasks.
Microtasks get executed BEFORE macrotasks, but they still get executed AFTER the current call stack is completed.
From OP (and better illustrated by GP's example) Python's surprise is that it's just putting the awaited coroutine into the current call stack. So `await` doesn't guarantee anything is going into a task queue (micro or macro) in python.
That doesn't make sense. That would mean the awaiting function doesn't have access to the result of the Promise (since it can proceed before the Promise is fulfilled), which would break the entire point of promises.
Yep, it's another slop. We are getting these about daily now where there's lots of comments on articles that'd are clearly slop.
Half the article is paragraph headings, the other half is bullet points or numbered lists, if there was anything interesting in the prompt
it'd been erased by an LLM which has turned it into an infodump with no perspective, nothing to convey, and I have no ability to tell what if anything might have been important to the author (besides blog clicks and maybe the title).
I really wish we could start recognizing these sooner, I think too many people skim and then go to the comments section but I don't think we really want HN to be a place filled with low value articles just because they're good jumping off points for comments.
I've been flagging them here and then heading over to kagi and marking as slop there. Makes me wish we had something similar here rather than just "flag".
And I know we aren't supposed to comment when we flag, but this feels different to me, like we've got to collectively learn to notice this better or we need better tools.
They are async across operations that do 'yield', i.e. when the function eventually runs an i/o operation or sleep or similar. Those are the points where the functions can be interleaved. Simply awaiting another function is _not_ one of those points: await here only means the called function might yield to the scheduler at some point in its execution (it doesn't have to!), not that the calling function will yield immediately.
Tasks are async funcs that have been spawned with asyncio.create_task or similar, which then schedules its execution. A timer of zero doesn't spawn anything so the coroutine just executes in the same frame as the caller so yes it essentially a noop.
> To find the most informative examples, we separately cluster examples labeled clickbait and examples labeled benign, which yields some overlapping clusters
How can you get overlapping clusters if the two sets of labelled examples are disjoint?
The information you're seeking appears to be left out of the post. My best guess is that a separate embedding model, specifically tuned for document similarly, is used to generate the vectors and then a clustering algorithm is chosen to create the clusters. They may also use PCA to reduce the embedded vector dimensions before clustering.
> How can you get overlapping clusters if the two sets of labelled examples are disjoint?
What's disjoint are the training labels and the classifier's output - not the values in high-dimension space. For classification tasks, there can be neighboring items in the same cluster but separated by the hyperplane - and therefore placed in different classes despite the proximity.
If the diagram is representative of what is happening, it would seem that each cluster is represented as a hypersphere, possibly using the cluster centroid and max distance from the centroid to any cluster member as radius. Those hyperspheres can then overlap. Not sure if that is what is actually happening though.
They only did that for image generation. The more interesting part is that an LLM can approach or find the correct caption for an image, video or audio during test time with no training using only the score as a guide. It's essentially working blind almost like the game Marco Polo where the scorer is saying "warmer" or "colder" while the LLM is finding its way towards the goal. This is an example of emergent capabilities since there are no examples of this in the training data.
Actually, it's the name of the paper. And while the team also developed and released a system to elicit the behavior by doing what you described, it's entirely possible that the researchers thought the title to be the most important finding in their work.
In many cases the build output also has hardcoded paths unfortunately
so doing `brew install` inside a container with the proper volumes it’s not sufficient to fix the issue. Everything would have to run from within the container as well.
reply