euclaise

Maybe RL? Just like similar corrections in reasoning traces. You can train non-'thinking' models the same way (though if you're naive about it then you might end up with responses that are similarly rambly), and I'd expect it to have been

There isn't, though you can run it over wasm on it. I tried it a while back with a port of the w2c2 transpiler (https://github.com/euclaise/w2c9/), but something like wazero is a more obvious choice

This is not exactly propaganda in the typical sense, but it clearly is the case that people successfully edit Wikipedia to further objectives. As an example, the Wikipedia page for Meta-analysis (which isn't even that obscure of a topic) currently contains content that seems to plausibly be trying to promote Suhail Doi's methods, and it seems that it has been like this for a number of years. It cites 5 papers from him, more than anyone else, of which the largest has 297 citations. It has a subsection devoted to his method of meta-analysis, despite it being a rather obscure and rarely used method. There have been additional subsections added over time, which also focus on somewhat obscure areas, but frankly these additions are sketchy in similar ways.

In general, it is not uncommon to come across slantedness issues. Is it completely 100% clear that Doi has come on and maliciously added his papers? Not quite, but good propaganda wouldn't be either, and would actually be far less suspicious-looking.

https://en.wikipedia.org/wiki/Meta-analysis

Simpler than, but somewhat reminiscent of, Plan 9's windowing system https://man.cat-v.org/plan_9/4/rio

Between the official nvidia drivers and Linuxulator, FreeBSD can run CUDA applications, but it's a bit hacky

No other BSDs can

This one does have attention, it's just chunked into segments of 4096

A lot of embedding models are built on top of T5's encoder, this offers a new option

The modularity of the enc-dec approach is useful - you can insert additional models in between (e.g. A diffusion model), you can use different encoders for different modalities, etc

LM studio is closed source, so no

Neat. I've worked on some similar projects in the past

I have previously ported w2c2 to Plan 9 here: https://github.com/euclaise/w2c9

It ran basic Rust code fine.

I later managed to run C++ code without wasm, by (partially) porting musl and doing some linker hacking here: https://sr.ht/~euclaise/cross9/

There's a new 7B version that was trained on more tokens, with longer context, and there's now a 14B version that competes with Llama 34B in some benchmarks.

They actually have a performance edge, but they aren't well suited to chat models because you can't do caching of past states like with decoder-only models

That tweet had it backwards, more tokens in tokenizer means that the 16k token context window typically allows for even longer passages than if LLaMA were 16k

phi-1 is a code-specific base model, with further finetuning on top of that. This is a general language base model, not really comparable.

RWKV also uses some sort of L2-esque regularization, which was supposedly an idea taken from PaLM (although I can't find a source on this point, other than some message in the RWKV discord)

After skimming https://alexanderobenauer.com/articles/os/1/ - I think the items are more like objects than files. Files have a uniform I/O interface, while items seem like they can have unique properties instead of having a uniform interface.

I like runpod, although I've found that I typically have to set NCCL_P2P_DISABLE=1

Training as GPT vs RNN will give you numerically identical results with RWKV, it's just two ways of computing the same thing. It's trained in GPT-mode because it's cheaper to train that way -- you can parallelize over the sequence length. In practice it isn't going to be any different than training with back-propagation through time for the same sequence length.

> The bitter lesson [1] is going to eventually come for all of these. Eventually we'll figure out how to machine-learn the heuristic rather than hard code it. Recurrent neural networks (RNNs) do this implicitly, but we don't yet know how to effectively train RNNs on ultra-deep sequences.

Linear RNNs and RWKV are examples of RNNs on deep sequences:

https://arxiv.org/abs/2303.06349

https://arxiv.org/abs/2305.13048

Important note: They only did experiments up to 32k length

Runit is way more minimal, the difference between them is extreme even on that alone

The only paper that I could find using an approach with fully separated experts like this is https://arxiv.org/pdf/2208.03306.pdf

Here, lobste.rs, mailing lists, and 4chan

The other alternatives don't seem very viable

GPT-4 with Bing search ability, slightly lobotomized, but free

Can't be less though, the latency difference between them implies that GPT-4 is significantly larger. This is unlike with PaLM, where latency decreased.

I don't trust this. The article cites semafor (https://www.semafor.com/article/03/24/2023/the-secret-histor...), but semafor states the 1T parameter count without any source.

Perhaps you're thinking of Rob Pike?

I think they're talking about compilation speed

I'd like to see this ported to TI graphing calculators