dbfclark

I think your per-axis std normalization is likely doing a big pile of the work —- it’s fairly well-known that “wrong” PCA, setting sigma=Id or just taking a square root, gives better embeddings than the un-normalized version. It would be worth showing a comparison to similarly-normalized PCA I think, if it’s not too hard?

I did a goodly chunk of vibe coding over the summer and I found that the best language for me was Rust implementations with Python bindings for interface. A few reasons:

- Everything about rust enforcing correctness catches lots of bugs

- Using a high-level API means I can easily hand-check things in a repl

- In addition to tests, I required a full “demo notebook” with any PR — I should be able to read through it and confirm that all the functionality I wanted has actually been implemented

If the philosophy is (and it should be) “loc is free”, it’s worth thinking about how we can make LLMs produce more loc to give us additional comfort with correctness. Language choice is very much a way.

Another completely viable solution (other than adding extra starch) I’ve found is to sprinkle a bit of sodium citrate (the sodium salt of citric acid, a common food additive and cheap on Amazon) over the cheese before adding to the pan. This improves the melting qualities of the cheese and avoids the starch issue altogether. You’re basically using pecorino velveeta.

A good way to understand why cosine similarity is so common in NLP is to think in terms of a keyword search. A bag-of-words vector represents a document as a sparse vector of its word counts; counting the number of occurrences of some set of query words is the dot product of the query vector with the document vector; normalizing for length gives you cosine similarity. If you have word embedding vectors instead of discrete words, you can think of the same game, just now the “count” of a word with another word is the similarity of the word embeddings instead of a 0/1. Finally, LLMs give sentence embeddings as weighted sums of contextual word vectors, so it’s all just fuzzy word counting again.

Convergent sequences are always Cauchy; for metric spaces, compactness and sequential compactness are the same.

The key question here isn’t so much whether GPT-4 beats the actual human decks as much as what it had to fabricate to do so. The humans are probably constrained by things like “reality” and “what their business has done in it” while GPT-4 could make up anything it wanted. A fair comparison would be to humans given the same prompt and told to invent whatever facts they wanted.

Very let down by the title -- why no ancient Roman abstract algebra?

Not my company, but Zocdoc has the best values I’ve ever seen exactly because they all have anti-values:

Patients First

Important, not Immediate

Learners before Masters

Together, not Alone

Progress before Perfection

Adaptable, not Comfortable

Sure. Moonshine I know a lot about, relative to physics at least. Given that I now work somewhere that specializes in term embeddings, it kind of feels like I've spent half my life injecting stuff into vector spaces...

Hey, I'm a mathematician, not a physicist. We tend only to get as far as "oh yeah, here's all this pretty math we care about. I hear it has some applications to physics..."