> Zero reinforcement should be given in case of perfect matches, high reinforcement should be given in case of `near-misses', and low reinforcement again should be given in case of strong mismatches. This corresponds to a notion from `esthetic information theory' which tries to explain the feeling of `beauty' by means of the quotient of `subjective complexity' and `subjective order' or the quotient of `unfamiliarity' and `familiarity' (measured in an information-theoretic manner).
This type of architecture is very similar to GAN which later became very successful
The language of reward mechanism can be translated to language of emotions. Emotions is something humans experience and understand on innate level, they are qualia. If a reward structure is translated to our language we can get a better intuitive understanding.
E.g. a direct negative reward associated with undesired states is often called "pain". E.g. if you want robot to avoid bumping into walls you give it a "pain" feedback and then it would learn to avoid walls. That's exactly how it works for humans, animals, etc. Obviously robot does not literally experience "pain" as an emotion, it's just a reward structure.
What you've written doesn't change anything to the fact that there's a contradiction in the author's writing. And as ithkuil said in another comment[1] it's not surprising at all that such a contradiction would occur in a work of fiction written by a human, because we are first an foremost emotional beings and we cannot really imagine how would a society of purely rational beings would be.
I don't really understand why you want to pretend that there's no inconsistency in a piece of fiction, by invoking pseudo-technical arguments that are entirely foreign to the said piece of fiction.
Note that this works within a single sequence of tokens. It might be consistent with "episodic memory" metaphor if we consider a particular transformer run as its experience.
But this might be very different from what people expect from "memory" - i.e. ability to learn vast amounts of information and retrieve it as necessary.
This is more like a refinement of transformer attention: instead of running attention over all tokens (which is very expensive as it's quadratic), it selects a subset of token spans and runs fine-grained attention only on those. So it essentially breaks transformer attention into two parts - coarse-grained (k-NN over token spans) and fine-grained (normal).
It might be a great thing for long-context situations. But it doesn't make sense when you want millions of different facts to be considered - making them into long context is rather inefficient.
It would be inefficient if you had to do it from scratch for every query, but if you can do it once as a preprocessing step and reuse the prepared context for many queries, it might start to become more efficient than a shorter context that includes only some documents but has to be reprocessed because it's different every time.
Yes, I think it might be a good solution where you have a context up to 10M of tokens and you do a lot of requests with that context. It might be relevant for agentic stuff which tends to produce long chat logs - especially with some gadgets on top, e.g. some 'episodes' might be completely removed as obsolete.
But I don't think it's a good solution for bigger amounts of data - as in that case it's more beneficial if that can be formed into independent memories.
Another paper related to attention distillation, although doing something far more radical: transformer attention is distilled onto RWKV-like model: https://huggingface.co/papers/2505.03005
Cursor: Autocomplete is really good. At a time when I compared them, it was without a doubt better than Githib Copilot autocomplete. Cmd-K - insert/edit snippet at cursor - is good when you use good old Sonnet 3.5. ;;; Agent mode, is, honestly, quite disappointing; it doesn't feel like they put a lot of thought into prompting and wrapping LLM calls. Sometimes it just fails to submit code changes. Which is especially bad as they charge you for every request. Also I think they over-charge for Gemini, and Gemini integration is especially poor.
My reference for agent mode is Claude Code. It's far from perfect, but it uses sub-tasks and summarization using smaller haiku model. That feels way more like a coherent solution compared to Cursor. Also Aider ain't bad when you're OK with more manual process.
Windsurf: Have only used it briefly, but agent mode seems somewhat better thought out. For example, they present possible next steps as buttons. Some reviews say it's even more expensive than Cursor in agent mode.
Also something to consider: I have a script I wrote myself which just feeds selected files as a context to LLM and then either writes a response to the stdout, or extracts a file out of it.
That seems to be often better than using Cursor. I don't really understand why it calls tools when I selected entire file to be used a context - tool calls seem to be unnecessary distraction in this case, making calls more expensive. Also Gemini less neurotic when I use it with very basic prompts -- either Cursor prompts make it worse, or the need to juggle tool calls distract it from calls.
I've been using IntelliJ IDEA and similar products for almost 10 years, and I'm not impressed.
Java/Kotlin is their main thing, and yet neither Maven nor Gradle builds are stable. If your build fails or there are some unresolved dependencies, you restart IDE in hope it works...
AI coding tool trial failed for me -- IDE told me it's not activated even after I activated it on billing portal. And doc implied it might take some time. WTF. Does it take some batch processing?..
People who were able to get AI coding tools working said it's way behind Cursor (although improving, apparently).
Counterpoint from me: I've been using Jetbrains tools for over 10 years as well. Mostly Webstorm and Rider and it's all working well. Sometimes there are bugs, yes, but I had plenty those in VSCode and Visual Studio as well.
Aside from their initial AI plugin rollout fiasco it has been smooth sailing for me.
There's something severely wrong with your setup if you can't get stable maven or gradle builds, and your AI problem... maybe it was really early right after release? Either way, contact their support.
And if "If your build fails or there are some unresolved dependencies" you check your dependencies and config.
I'm tired of people complaining and not trying to understand how their systems (or an IDE for that matter) work.
Because JetBrains products DO have issues, but rest assured, the things you are complaining about are on the main path of basic features they take care of the most.
Source: at first reluctant but now happy IntelliJ user, after thinking for a long time that Eclipse/Netbeans would be better. I was wrong.
> There's something severely wrong with your setup if you can't get stable maven or gradle builds
To be fair with OP, I had a similar experience in the previous company. Sometimes after bumping a dependency or something, even if you asked IntelliJ to "Reload All Gradle Projects" something wouldn't work and I needed to restart the IDE. Not saying it was common, but it did happen. This was a Kotlin codebase.
Now working in a company using Scala, I had a few cases where IntelliJ failed to resolve a dependency correctly so it was saying that the class I just created didn't exist (this was in shared library and two different dependencies pulled it, but we did pin the dependency directly and sbt was building it correctly, it was only IntelliJ that was becoming confused). Cleaning up the build sometimes worked, sometimes didn't, but even when it worked it would go back after a while. Eventually we updated all dependencies in all projects and it now always works, but it was painful for a while.
Look, I understand that IntelliJ is better than Eclipse. Eclipse is just bad. (E.g. if you open existing workspace with a newer version of Eclipse it crashes - a problem they haven't fixed for 20 years!!!)
But I can tell you IntelliJ has way more issues than e.g. Visual Studio I used 20+ years ago.
I take preview to mean the model may be retired on an accelerated timescale and replaced with a "real" model so it's dangerous to put into prod unless you are paying attention.
Scheduled tasks in ChatGPT are useful for keeping track of these kinds of things. You can have it check daily whether there's a change in status, price, etc. for a particular model (or set of models).
Neither do I, but it's the best solution I've found so far. It beats checking models/prices manually every day to see if anything has changed, and it works well enough in practice.
But yeah, some kind of deterministic way to get alerts would be better.
That's actually not true. Cobain used a rather "weird" technique where he would "accidentally" hit 4th in addition to 5th. That actually has characteristic Nirvana sound and is sometimes called "Cobain chords". Assuming Cobain doesn't hit any other strings these are sus4 chords.
I find it really weird that people claim these are power chord even though they sound really different. In my view they are important to the vibe of "Smells like teens spirit" as they bring some dreamy characteristic as they make it a lot brighter compared to what it would be if it was played with only two lowest notes.
I'd be a lot more interested in AI which can take existing music as the base. I don't want a new song, I want to hear music I love in a new way. Like img2img but track2track.
Literally the opposite problem in Portugal: you go to a restaurant, food is good, you want to drink espresso in the end, the bring Delta's worst blend.
https://people.idsia.ch/~juergen/curiositysab/curiositysab.h...
This mechanism can be formalized.
> Zero reinforcement should be given in case of perfect matches, high reinforcement should be given in case of `near-misses', and low reinforcement again should be given in case of strong mismatches. This corresponds to a notion from `esthetic information theory' which tries to explain the feeling of `beauty' by means of the quotient of `subjective complexity' and `subjective order' or the quotient of `unfamiliarity' and `familiarity' (measured in an information-theoretic manner).
This type of architecture is very similar to GAN which later became very successful
reply