maxwells-daemon

Also went to Caltech, and my progression was the complete opposite. Started out going to every lecture and trying to write everything down, but things just moved way too fast -- I'd write down every word and figure without ever internalizing it, and at the end of each lecture I'd have a crappy copy of the lecture notes and no memory of the last hour.

By senior year, my strategy was: don't write anything down, just try to follow the main thread of the lecture. Then afterwards, go back and read the textbook and take exhaustive notes then. Empirically I learned way more that way.

Fond memories of running into my math professor walking around campus at 3am...

Look at the "math test" video.

Given the question: "Jane has 9 balloons. 6 are green and the rest are blue. How many balloons are blue?" The model outputs: "jane_balloons = 9; green_balloons = 6; blue_balloons = jane_balloons - green_balloons; print(blue_balloons)"

That seems like a good justification of a (very simple) step-by-step reasoning process!

Autoregressive transformers take a while to generate text, since you need to run the whole model once for every word in the output.

As an add-on to this: I'd encourage anyone interested in this debate to read Rich Sutton's "The Bitter Lesson" (http://www.incompleteideas.net/IncIdeas/BitterLesson.html).

At every point in time, the best systems we can build today will be ones leveraging lots of domain-specific information. But the systems that will continue to be useful in five years will always be the ones freely that scale with increased parallel compute and data, which grow much faster than domain-specific knowledge. Learning systems with the ability to use context to develop domain-specific knowledge "on their own" are the only way to ride the wave of this computational bounty.

I would argue humans ingest a lot more than 159GB before they can write code. Most of it isn't Python, and humans currently transfer knowledge a lot more efficiently than NNs, but I suspect that'll change as incorporating more varied data sources becomes feasible.

The "language models don't really understand anything" corner is getting smaller and smaller. In the last few months we've seen pretty definitive evidence that transformers can recombine concepts ([1], [2]) and do simple logical inference using contextual information ([3], "make the score font color visible"). I see no reason that this technology couldn't smoothly scale into human-level intelligence, yet lots of people seem to think it'll require a step change or is impossible.

That being said, robust systematic generalization is still a hard problem. But "achieve symbol grounding through tons of multimodal data" is looking more and more like the answer.

[1] https://openai.com/blog/dall-e/ [2] https://distill.pub/2021/multimodal-neurons/ [3] https://openai.com/blog/openai-codex/

I'd rate myself as "above-average receptive" to ML-based tooling, but after trying two "AI autocomplete" tools (Kite and TabNine) I've decided it's not for me. The suggestions were usually good, but I found having complex, nondeterministic IDE commands pretty unsettling.

Most of the responses here seem to imply that the author doesn't understand that physics can be complicated (in the sense of being hard to learn or having big equations). He studies theoretical physics at MIT [1], so I expect he does.

On the content: it's pretty weird that our best models don't use much of the world's underlying structure at all. State-of-the-art vision models like vision transformers and MLP-mixer do just fine when you shuffle the pixels. You could argue that modern image datasets are so big that any relevant structure could be learned by attention, but it still feels like we're doing _something_ wrong when pixel order doesn't matter at all ¯\_(ツ)_/¯

[1] https://danintheory.com/

I think it depends! If you want to zoom out and take the "systems view" using standard components, then you probably don't need much math. If you want to develop new architectures or algorithms, then you definitely will. The well-trodden paths of ML might have most of their math abstracted away, but in my experience every time you get close to the frontiers, people are using math to understand what's going on or develop new approaches.

I often want to run small "experiment code" many times with different inputs, but don't like wrapping everything in a big framework to do it. So I wrote a little tool that calls any command-line program multiple times with different inputs according to a template and a search strategy [1].

Another upside is that most parameter search programs seem to assume you want either grid search (which is hideously inefficient for large search spaces) or bayesian optimization (which can be overkill and comes with its own caveats). I wanted to make it easy to use quasirandom search [2], which is basically always the right choice for small searches where you just want to understand the parameter space better.

[1] https://github.com/maxwells-daemons/argsearch [2] https://en.wikipedia.org/wiki/Low-discrepancy_sequence

Not Fast.ai, but I self-studied ML during undergrad (mostly from books) and am currently working as an ML research scientist.

That being said, I'm also thinking about starting an ML PhD because it does honestly open more doors to top research groups.

It's interesting that the "probability to distance" function (-log(prob(edge))) wound up being the information-theoretic entropy [1]. I wonder if there's anything deeper there?

[1]: https://en.wikipedia.org/wiki/Entropy_(information_theory)

My research (automated theorem proving with RL) sits partway between "good old-fashioned AI" and modern deep learning, and GEB struck me as amazingly prescient, with lots of lessons for modern AI research.

There's a growing sense among many ML researchers that there's something fundamentally missing in the "NNs + lots of data + lots of compute" picture. GPT-3 knows that 2+2=4 and that 3+4=7, but it doesn't know that 2+2+3=7. These heart of these kinds of problems indeed seems to be the sense of abstraction / problem reimagining / "stepping outside the game" that Hofstadter spent so much time talking about.

Chess (accidentally) turned out to be easy enough for a narrow algorithm to work well. But I'd be surprised if other problems don't require an intelligence general enough to say "I'm bored, let's do something else," and I don't believe current algorithms can get there at any scale.

A couple on and off, but most recently a GPU-accelerated differentiable fluid simulator: https://github.com/maxwells-daemons/deltaflow

This seems true about smallish groups, like the example of a Jew in czarist Russia, but when the group is big enough to divide into multiple public-opinion subgroups, I'm not so sure. I think the feminism argument doesn't work here for that reason -- there are enough men that saying bad things about some of them doesn't necessarily disparage the rest.

I'm pretty worried about designing new datasets specifically around observing things we've already seen in real data. Sure, we can observe spatial priors and double descent with this dataset by design, but when we see a new interesting property, what's the chance that it carries over to real-world data?

I graduated from Caltech last year, and the exams are all still take-home. You're expected to time yourself and not consult course materials, and basically nobody cheats. It's a rare sort of equilibrium where nobody's cheating, so it's very hard to start -- you won't find any co-conspirators, and if you're found out it's social death.

One cool thing about Lean is that the next version is trying to become something like a general-purpose programming language, with the idea of "using proofs to write more efficient code."

For example, you might prove that your code never accesses a buffer out of bounds, so you can remove all your bounds checks for efficiency. Another example is implementing recursive functions with induction -- you can implement Fibonacci naively (fib 0 = 0, fib 1 = 1, fib n = (fib n-2) + (fib n-1)) and Lean will rewrite it into an efficient (non-exponential) form.

See: https://leanprover.github.io/talks/LeanPLDI.pdf

I don't think we can say for sure that early stopping is the main reason deep networks generalize. Double descent [1] shows that models continue to improve even once they've "interpolated" the training data (fit every point perfectly), and critical periods [2] suggest that the early part of training is responsible for most of the generalization performance even though much of the numerical improvement happens later.

Overall it looks like gradient descent is a strong regularizer -- we know it tends to prefer small and low-variance weights, for example. So part of deep generalization has to do with how SGD is able to pick "good" features early, and then optimization pushes the unimportant weights to zero later (hence lottery tickets).

[1] https://openai.com/blog/deep-double-descent/ and other papers. [2] https://arxiv.org/abs/1711.08856 and others.