montebicyclelo

> LLMs can't think. They are generating tokens one at a time

Huh? They are generating tokens one at a time - sure that's true. But who's shown that predicting tokens one at a time precludes thinking?

It's been shown that the models plan ahead, i.e. think more than just one token forward. [1]

How do you explain the world models that have been detected in LLMs? E.g. OthelloGPT [2] is just given sequences of games to train on, but it has been shown that the model learns to have an internal representation of the game. Same with ChessGPT [3].

For tasks like this, (and with words), real thought is required to predict the next token well; e.g. if you don't understand chess to the level of Magnus Carlsen, how are you going to predict Magnus Carlsen's next move...

...You wouldn't be able to, even just from looking at his previous games; you'd have to actually understand chess, and think about what would be a good move, (and in his style).

[1] https://www.anthropic.com/research/tracing-thoughts-language...

[2] https://www.neelnanda.io/mechanistic-interpretability/othell...

[3] https://adamkarvonen.github.io/machine_learning/2024/01/03/c...

My thoughts are that it's key that humans know they will still get credit for their contributions.

E.g. imagine it was the case that you could write a blog post, with some insight, in some niche field – but you know that traffic isn't going to get directed to your site. Instead, an LLM will ingest it, and use the material when people ask about the topic, without giving credit. If you know that will happen, it's not a good incentive to write the post in the first place. You might think, "what's the point".

Related to this topic - computers have been superhuman at chess for 2 decades; yet good chess humans still get credit, recognition, and I would guess, satisfaction, from achieving the level they get to. Although, obviously the LLM situation is on a whole other level.

I guess the main (valid) concern is that LLMs get so good at thought that humans just don't come up with ideas as good as them... And can't execute their ideas as well as them... And then what... (Although that doesn't seem to be the case currently.)

It's permissive; but that doesn't imply not crediting people for their work

> king-man+woman=queen

Is the famous example everyone uses when talking about word vectors, but is it actually just very cherry picked?

I.e. are there a great number of other "meaningful" examples like this, or actually the majority of the time you end up with some kind of vaguely tangentially related word when adding and subtracting word vectors.

(Which seems to be what this tool is helping to illustrate, having briefly played with it, and looked at the other comments here.)

(Btw, not saying wordvecs / embeddings aren't extremely useful, just talking about this simplistic arithmetic)

> Many have touted smoking marijuana as a safer alternative to cigarettes

Wierd take, given that they are completely different drugs, with completely different effects on the brain, with the only similarity being that they are both ingested via smoke.

Hmm, for my use case just allowing the lines to fail would have been better, (which I told the model)

Does the code consist of many large try except blocks that catch "Exception", which Gemini seems to like doing, (I thought it was a bad practice to catch the generic Exception in Python)

There's also two DBs I know of that have an updated Hacker News table for running analytics on without needing to download it first.

- BigQuery, (requires Google Cloud account, querying will be free tier I'd guess) — `bigquery-public-data.hacker_news.full`

- ClickHouse, no signup needed, can run queries in browser directly, [1]

[1] https://play.clickhouse.com/play?user=play#U0VMRUNUICogRlJPT...

So could do better than chance by excluding the option it's picked?

Awesome work / demo / blog

Link to the demo in case people miss it [1]

> using a customized camera app which also recorded my phone’s motion

Using phone's gyro as a proxy for "controls" is very clever

[1] https://madebyoll.in/posts/world_emulation_via_dnn/demo/

> Always zero out your graphs

Great way to end up with useless graphs where you have a tiny line at the top that's been compressed to the point where you can't see any changes...

The "rule" about ensuring axes are zeroed is for bar charts not line graphs.

> How close would this be to GPT 2

Here's a post from 2015 doing something a bit like this [1]

[1] https://nbviewer.org/gist/yoavg/d76121dfde2618422139

It brings way more to the table than just being fast, like people are commenting. E.g. it manages Python for your projects, so if you say you want Python 3.12 in your project, and then you do 'uv run python my script.py', it will fetch and run the version of Python you specified, which pip can't do. It also creates lock files, so you know the exact set of Python package dependencies that worked, while you specify them more loosely. Plus a bunch of other stuff..

Great point. I've found it's very often possible to understand and fix problems "one shot" from stack traces alone — and we're talking production builds here... So I wouldn't turn them off, (an idea mentioned in the article), unless profiling shows that they are one of the last things preventing the code from reaching the target performance.

Super cool to see this idea working. I had a go at getting an LLM to play Pokémon in 2023, with openai vision. With only 100 expensive api calls a day, I shelved the project after putting together a quick POC and finding that the model struggled to see things or work out where the player was. I guess models are now better, but also looks like people are providing the model with information in addition to the game screen.

https://x.com/sidradcliffe/status/1722355983643525427?t=dYMk...

A gameplay video at the top of the post would go a long way; for those who don't have time to click through and play on itch.io. (I see a few gifs on the itch.io page, but a longer gameplay video would be nice!)

Top runners can run fast and far without it hurting. But when going for personal bests / very fast times, my understanding is that it is painful, for most of the run. E.g. watch some parkrun vlogs, and you'll hear people say things like "after the first 1km it's really painful, so just take things one step at a time, and hold on to the pace", etc.

The author asks:

> Has the model ever seen cosine similarity?

Yes - most of the time, at least for deep learning based semantic search. E.g. for semantic search of text, the majority are using, SentenceTransformers [1], models which have been trained to use cosine similarity. Or e.g. for vector representations of images, people are using models like CLIP [2], which has again been trained to use cosine similarity. (Cosine similarity being used in the training loss, so the whole model is fundamentally "tuned" for cosine similarity.)

Articles like these cause confusion, e.g. I've come across people saying: "You shouldn't use cosine similarity", when they've seen SentenceTransformers being used, and linking articles like these, when in fact you very much should be using cosine similarity with those models.

[1] https://sbert.net

[2] https://arxiv.org/abs/2103.00020

This 100%. Vector DBs have been heavily pushed by vector DB companies and cloud providers, and despite companies often having mere MBs of documents to search through for their use cases, amounts that trivially fit into RAM / can be searched via dot product in milliseconds, managers and engineers less familiar with the space think people are doing it wrong if they don't use a vector db. So.. vector DBs end up getting used when actually a simpler in-memory, non-approximate, solution would be fine, (but less monetizable)

One approach to this is the SingleFile browser plugin [1], configured to save pages to a GitHub repository - it saves the whole web page as a single HTML file in the repo. (Ok it's probably closer to archiving than bookmarking... but it's not too far off)

[1] https://github.com/gildas-lormeau/SingleFile

Conda has a faster solver, as of 2022

https://www.anaconda.com/blog/a-faster-conda-for-a-growing-c...

QR-to-QR: https://github.com/sradc/QR-to-QR

The app lets phones send messages to eachother via QR codes. The two phones have to be put face to face.

Video here: https://www.youtube.com/watch?v=4zUBj8X5EWA

Nice, I guess a more established framework for writing webapps in Python is Streamlit, which is pretty good - minimal syntax can create quite an advanced, "reactive", GUI. It's very quick to throw together functional / relatively complex stuff with. But it's also very opinionated, so all Streamlit apps tend to have a similar look. Also it's more aimed at ML demos, for a few, non-persistent users, rather than for large apps with persistant users, etc. Wonder how this compares.

Agreed. Uncomfortable in many ways:

- Heavy on the head, making the neck sore after a while.

- Press into the face, which can also get sore.

- Seals around the face, which is claustrophobic.

- Insulates head/face, making hot and sweaty.

- Even high resolution headsets look pixelated, making things like reading / trying to see details irritating.

- VR motion sickness is very real, (with guides on how to develop your VR legs... which takes multiple days of careful practice).

Despite current headsets being excellent from a technical perspective, IMO they still need to get significantly ligher and more physically comfortable, significantly higher resolution, and ideally solve VR motion sickness in some way...

Very cool! As a further variation on this idea, I'm imagining training a reinforcement learning agent on atari games / super mario, but with an additional music-based reward/input, to try to get a "musical" looking playthrough... (Not sure how good it would look / whether it would be worth it though...)

It passes the test you've proposed. For the below results, the prompt is the same for A and B, except for in B the radius of the last circle is twice as big to make the rendered output unintelligible.

A. Valid Mickey is detected by the model. "...This arrangement might resemble a basic version of a Mickey Mouse shape, where the two smaller circles represent the ears and the larger circle represents the head...", https://chatgpt.com/share/3999859a-b6db-4671-8b69-0ec6a5bac3...

B. Invalid Mickey is not misclassified as Mickey by the model and is correctly described. "...these circles will overlap, creating a pattern where the largest circle (Circle 3) dominates the right side of the canvas, with the other two smaller circles overlapping it and each other in the middle...", https://chatgpt.com/share/df3c57ac-495b-4e4c-b00c-bae31781c4...

Chat GPT:

> Given the arrangement of three overlapping circles, it resembles the classic depiction of a *Mickey Mouse* head silhouette:

> The two smaller circles represent Mickey's ears.

> The larger circle represents his head.

> This is a stylized version of the iconic Mickey Mouse logo.

Imo: In order to predict the next token for non-trivial tokens, (of which there are many on the training data), you do have to do some more complex thinking/reasoning than just a lookup of past training data.

The core concept of agent graphs seems quite similar to an LLM agent framework I created last year, [1].

Imo it is a more promising way to make agents, than the prior approach of just giving an LLM N tools to use at once.

[1] https://github.com/sradc/MakeAgents

Their 2d music programming language, Orca is very cool/fun. Some examples:

https://youtube.com/watch?v=MNF8SF69QvM&list=PLb1uDATFJPcEEG...

https://youtube.com/watch?v=DBI8eBMGyYs

https://youtube.com/watch?v=mxr8Dtw2R5w

https://youtube.com/watch?v=RDZiKYSGsjg

People throw that proof around all the time; but all it does is show that a neural net is equivalent to a lookup table; and a lookup table with enough memory can approximate any function. It's miles away from explaining how real world, useful, neural nets, like conv-nets, transformers, LSTMs, etc. actually work.