lamerose

Those are inputs, ground truth, and outputs from various methods, not training data. Not sure what their training data is though lol.

Where do they show that?

Focus, hike, relax, focus, hike, relax, focus, hike...

>fMRI-to-image

Not so impressive compared to EEG.

This is from a paper published back in September btw: https://arxiv.org/pdf/2309.14030.pdf

Subvocal speech recognition has been going just as long.

Seems like it could just be getting at some phonetic encoding, or even raw audio information. The grammatical and vocab transformations could be accounted for by an imperfect decoder.

Elm can do iterative recursion, which is a thinly disguised loop without side effects.

Lol. IMO the difference between an C and Assembly (as between vacuum tubes and the abacus) is really a difference in power, since it allows the same program to be implemented on different architechtures. It's only fair to start calling things convenience wrappers once you get past C. And often enough, an abstraction aimed at convenience leads to a reduction in expressive power.

For a better reading experience, try the pdf: https://journalofillusion.net/index.php/joi/article/view/983...

The article is presenting a Scheme interpreter running in Scheme, compiled to WASM, not a Scheme compiler, but your idea is also cool. The WASM API apparently doesn't need a pre-made file as its input: you can pass raw bytes generated during runtime into the Module constructor, so it would be totally feasible.

I admit a scenario in which you have to communicate everything that the abstract communicates is kinda contrieved, though it could happen if the article is the main target of your discussion. But in general, pointless paraphrase of other sources is widespread.

>Summarizing another academic work in the context of your own work is a bedrock activity in academic thinking as well as writing.

Summary has its place, but paraphrase is another thing. Quality of paraphrase is defined by surface-level features like vocabulary, grammar, and re-arrangement of sentences, and second-language English education often fails to advance beyond word-by-word substitution. Even when the exercise of paraphrase demonstrates some kind of understanding of the original text on the part of the author, it doesn't necessarily aid the reader.

I'm not trying to deny that tortured phrases may also indicate paper farming and plagiarism btw, just saying that there are other factors.

Nah, this has more symbolic NLP vibes. LLMs mess up in subtler, more uncanny ways.

I think this can result from cases where paraphrase isn't useful but still culturally expected. For example, you often need to introduce the central point of another paper before you can comment on it, and the ideal way to do that would be to insert the whole abstract verbatim, but people look down on that. So, you end up writing a paraphrase as faithful to the original as possible while still being superficially different. If you're good at English, you can paraphrase in a way that flows well and displays your understanding. ESL writers might be at risk of screwing the wording up, not noticing, and getting ridiculed for poor research.

Not a fan of Python, but it isn't too bad pedagogically speaking. JS on the other hand... I hope WASM can one day kill it, leave it obsolete, and have it forcefully deprecated like Flash.

Preferable to doing the Javascript edition of SICP.

>I think there are almost literally no software systems today that don't have bugs in them. Programs that have been formally verified with something like Coq can be bug free. Automating formal verification may be a more effective way to solve the trust issue in this domain.

Yes, alignment is difficult in itself, but why would aligning a more advanced AI be any harder than what has already been done for current AI?

The article makes this sound a bit like a lamer, English version of the Antikythera mechanism. In reality it's just a quadrant, i.e., a portable sundial relying on gravity for alignment, and it's only a decade older than the next oldest specimen.

Ok, those are some good points about what can go wrong. I still doubt that things are particularly more prone to going wrong in more intelligent systems. Wasn't it early, simplistic systems like Tay that went the furthest off the rails? The problem is that more intelligent AI will be used more ambitiously, so when it does go wrong, the consequences might be more serious than some racist twitter posts.

Is your point that a more intelligent AI would develop a more entangled measure of what is good, requiring more specific alignment to be overcome; by way of analogy, are chefs harder to instruct precisely because of their prior expertise? I guess some chefs are like that, but I think it results from personality issues, not structural ones. I find describing an AI as having its own agenda to be a presumptive personification.

Is it fair to say that alignment is just the task of getting an AI to understand your intentions? It is an error to confuse the complexity of a specification of what kind of output you want, with the complexity of the process of producing that output. Getting superintelligent AI to understand simple specifications should be a non-issue. If anything, we would assume that it could be aligned using a specification of inferior quality to what a less intelligent AI would require, assuming that the superintelligent AI is better at inferring intentions.

If a little girl with no knowledge of cooking asks her dad to cook the macaroni extra crispy, his knowledge of how to do that isn't a barrier to understanding what his daughter wants. A trained chef with even greater skills might even be able to execute her order more successfully. Superalignment is nothing less mundane than this.

Advances in AI will lead to more ambitious applications. As well as requiring more intelligent technology, these new applications may well require more detailed specifications to be inputed, but these two issues are pretty orthogonal. In traditional computing, it is already clear that simple specifications often require highly complex implementations, and that some simple computational processes lead to outputs whose properties are highly difficult to specify. Why wouldn't the same apply in ML?