chewxy

We're rebranding mode collapse as MAD now?

> Coding in its purest form is a kind of translation, from natural language requirements to more precise computer languages

Unfortunately not so true. A simple way to check this is to look at what the brain is doing. Coding barely triggers the language components of the brain (your usual suspects like the Vernicke's and Broca's areas + other miscelleneous things). In fact what you'll find is that coding triggers the IP1, IP2 and AVI pathways. These are part of the multiple demand network. We call them programming "languages" because we can represent them in a token-based game we call "language" but the act of programming is far from mere language manipulation.

GopherConAU organizer here. Here's the whole playlist. I am not sure why I cannot make it public. https://www.youtube.com/playlist?list=PLN_36A3Rw5hFsJqqs7olO...

文明昆明 (wenming Kunming) is such an amazing rhyming couplet

Writing code uses the multiple demand network of the brain while writing prose uses mainly the language centres of the brain. Writing code is very much not the same as writing prose.

Source: https://www.cs.cmu.edu/%7Eckaestne/pdf/icse14_fmri.pdf (paper is mostly about reading code, but there are a collection of papers that together with this, puts together a strong argument that it's the same for writitng)

An alternative process is to call describe-function, use embark-collect to put all the auto suggestions into a buffer and memorise all functions.

Edit: I just did that and when I called count words to count lines that are in the buffer, Emacs just froze

Edit: 39180 functions. Not that hard to memorise ;P

which-key helps a lot with prefix commands. But doesn't help when you don't know the variants of I search that have silly default key bindings like the aforementioned C-M-@

emacs' discoverability has been quite terrible. A couple years back I wrote half of a package to do ascii art before I discovered artist-mode. And I had been using emacs for close to a decade by then. This year I discovered ace-window had hidden keybindings (C-x o then instead of choosing the window you want, type '?' to get the dispatch menu). Again, I've been using ace-window for about a decade. Adding a transient dispatch menu to Isearch would be great. I'd also suggest a more global keybinding for hidden dispatch menu (I suggest M-? for dispatch menus when using the minibuffer and ? for other modes).

Also this blog post makes me want to make me transform my embark to using transient

If you mean non-computer games: Magic the Gathering and Go are my top picks. I'm not good at either (due to lack of time to practise) but they are my go-to games when I and an opponent have coincident free time.

For computer games, I'd put Crusader Kings, Stellaris and Cities Skyline (the latest is so ridiculously spec hungry)

Models controlled by large for-profit entities not being a problem? Llocallamas are nice and great but pretraining was still done by Meta. Same with SDs. Users of generative AI models are at the whim of conglomerates.

That's quite correct. The IP1 and IP2 areas are usually associated with mathematics and production of motor cues around mathematics and stories. The Broca's and Vernicke's Areas are associated with language understanding and production. You can roughly estimate that the human brain's language model roughly fits into a floppy disk (1.44 MB for you young'uns)

I use a ~Nreal~ Xreal Air as my secondary monitor. When I don't want people to look, I simply lower the brightness of my primary laptop monitor to be a black screen.

TL;DR: LLMs are autocomplete on steroids, but stranger-than-expected steroids means people overhype it.

I'll share my point of view, and leave you to your own conclusions.

1. A sequence learner is anything that can learn a continuation of sequences (words, letters etc). You may call this "autocomplete".

2. Sequence learners can predict based on statistics (invented by none other than Shannon!), or by some machine learning process.

3. The most popular sequence learner nowadays are LLMs, which are neural networks with attention mechanisms.

4. Neural networks are basically linear algebra expressions: Y = σ(W'x + b). A fun thing is that this basic expression can approximate any other function (that are lipschitz and not kolmogorov arnold).

5. Aforementioned attention mechanisms pay attention to input as well as activations activations within the neural network (you can think of it as representations of the neural network's knowledge)

6. LLMs are stupidly large. They have excess computation capacity.

7. Due to training procedures, these excess computation capacity may spontaneously organize to form a virtual neural network with gradient descent in their forward pass (this sentence is a rough approximation of what really happens).

8. This shows the phenomenon of "in-context learning", which people are strangely very excited about. This is because of the hypothesis that an LLM with in-context learning may also use (i.e. pay attention to) its internal knowledge representation (i.e. its activations).

9. This in-context learning phenomenon relies primarily on the next-token prediction capability. Remove that next-token prediction, and the entire scheme falls apart.

From this list of premises, my view is that LLMs are autocomplete on very strange steroids with computational side effects (e.g. in-context learning, which only arises if you do training in a particular way). It has no mind, no concrete understanding of knowledge. It is highly unreliable.

The GPTs are good at interpolative and extrapolative generalization, owing to the manifold of the training data. They can't do abstractive, inductive, abductive generalizations. And those are the more common forms of generalizations that humans can do.

I'm curious how you went. Here's my attempt: https://github.com/chewxy/hm , the core of which (i.e. the interface type) is what powers most of the languages I wrote (different languages I wrote have different unification schemes)

If you use an ErgodoxEZ I've actually implemented the layout: https://github.com/chewxy/keyboards/tree/main/ergodox-ez

I have one for zmk too but I haven't committed/pushed it yet

Oh what a trip down memory lane. Software of that era had really interesting UI and UX. I made a winamp skin that was a blob (of my face, or perhaps my dad's) after using Kai's Power Goo.

I note something very interesting in the AI hype, and I would like someone to help explain it.

Whenever there's a news or article noting the limits of current LLM tech (especially the GPT class of models from OpenAI), there's always a comment that says something along the lines of "ah did you test it on GPT-4"?

Or if it's clear that it's the limitation of GPT-4, then you have comments along the lines of "what's the prompt?", or "the prompt is poor". Usually, it's someone who hasn't in the past indicated that they understand that prompt engineering is model specific, and the papers' point is to make a more general claim as opposed to a claim on one model.

Can anyone explain this? It's like the mere mention of LLMs being limited in X, Y, Z fashion offends their lifestyle/core beliefs. Or perhaps it's a weird form of astroturfing. To which, I ask, to what end?

the problem with the critique of "oh they didn't use the correct prompts" is that prompt engineering is highly dependent on the model. You could technically create an LLM that would not work with the "let's think this through step-by-step" magic prompt (i.e. exclude anything with similar phrases in the pretraining dataset).

Yes, they used GPT3.5-turbo, which would have its set of magic key phrases. Should they have used it? I'd say probably not.

You could measure the efficiency of a language by computing how many bits are required to store the semantics of a word/phrase/sentence losslessly. Assuming ideal encoding to bits of course. Think of things like perplexity and the like.

However, traditional way of computing efficiency of compression would not be useful for a meaningful analysis of the efficiency of a language. Barring issues like having an ideal encoding to bits, or even having the concept of "efficiency" being rigorously defined, there are problems just from the outset.

Take context for example.

All useful compression methods have some sort of decompression key involved. This could be the dictionary, or the bitmap or the know-how (for cases like RLE). In natural langauges, the compression/decompression key is stored in a distributed fashion across the minds of a society.

"Darmok and Jalad at Tanagra" is a VERY efficient compression for what is presumably a very long story about two hunters who met at an island and fought a beast together, but it is only efficient to the people who speak that language. The "local" efficiency (to the population who speak the language) is very high, but the "global" efficiency isn't.

So we must account for efficiency in terms of the size of the compressed concept as well as the compression key. And from my experience, it's a sorta lumpy kinda world out there.

Add something like this?

    (add-to-list 'display-buffer-alist
          '("\\*Magit*\\*"
            (display-buffer-reuse-window display-buffer-in-direction
            (direction . bottom)
            (window . root)
            (inhibit-same-window . t)))*

One thing emacs sorely lacks is support for VS Code's LiveSharing protocol. Otherwise I use emacs for everything

There are many lambda calculi. THE lambda calculus refers to the original lambda calculus as defined by Church.

You can think of prompt engineering as mining the model for what it knows (I hesitate to call it knowledge). Thus prompt engineering is highly specific to the model. Good thing we only have a handful of models trained in very similar ways huh? (that last sentence is sarcasm, and my displeasure is at the lack of diverse models)

The stop words bit is a bit wtf. Someone didn't do their homework

Cars are small and for the most part everyone in the car faces the same direction as the car itself. When you have a ship, you have 3 frames of references to contend with (self, ship, cardinal)

In Malaysian/Singaporean English there's a term: gostan (read "go stun"), which means to reverse. I was curious about it's etymology and went to research it. It came from "go astern", with "astern" being the back of a ship. I imagine this must be a phrase the English speaking colonists must have used quite a lot in the 17th century

Sooner or later we'd have to be more and more precise with prompts. We'd be going from "I want a function that takes anything and returns itself" to "I : a -> a" ... and hey that looks like a programming language

Well the nature of byte pair encoding has a side effect of encoding sounds as well. I briefly explored it here: https://youtu.be/fTDQUxha9qU?t=480

TLDR: ran out of runway, stakeholders from clients moving on all at the same time.

Longer story: I ran a startup that did natural language data analysis (kinda like what people are trying to do now with ChatGPT). You could ask it a question (via email or command line) and it would return its analysis. It could do a variety of statistical analysis and could explain the results in words (tho not as well as a finetuned ChatGPT could do today).

Technically it was strong. And I'd say way ahead of the curve. A few things caused the failure:

1. Spending too much time keeping one potential cash cow instead of finding more clients. Having failed a few prior startups, we (cofounders) were obsessed with getting and more importantly keeping clients. This led us to build integrations for clients. One integration was particularly absurd: the "database" that they wanted to connect to is a PowerPoint file on a SharePoint server. Specifically the tables on particular slides. We spent way too much time building custom integrations

2. Running costs were too high. We had developed a sorta "staggered on-line" training scheme. Each client had its own model. Monthly costs per client reached $2000 per month. But with one of the clients we absorbed the costs because they were a potential cashcow (same client as above)

3. The main stakeholder at this potential cashcow left the company to found his own startup, leaving no one else to advocate for my product. At the same time the two other clients decided it was way too expensive to having not enough of an impact on the business.

Thus, we ran out of money. Good news is that Gorgonia (https://github.com/Gorgonia) was born from this. I'm still working on the framework for deep learning today