Do simpler machine learning models exist and how can we find them?
statmodeling.stat.columbia.edu
statmodeling.stat.columbia.edu
While most of my work was porting and cleaning up certain parts of the code for a different purpose (just-clone-and-hack experimentation workbench), I've spent years optimizing neural networks at a very fine grained level, and many of the lessons learned here in debugging reflected that.
I believe that there are fundamentally a few big NP-hard layers (at least two that I can define, and likely several other smaller ones) unfortunately but they are not hard blockers to progress. The model I mentioned above is extremely simple and has little "extra fat" where it is not needed. It also importantly seems to have good gradient and such flow throughout, something that's important for a model to be able to learn quickly. There are a few reasonable priors, like initializing and freezing the first convolution to whiten the inputs based upon some statistics from the training data. That does a shocking amount of work in stabilizing and speeding up training.
Ultimately, the network is simple, and there are a number of other methods to help it reach near-SOTA, but they are as simple as can be. I think as this project evolves and we get nearer to the goal (<2 seconds in a year or two), we'll keep uncovering good puzzle pieces showing exactly what it is that's allowing such a tiny network to perform so well. There's a kind of exponential value to having ultra-short training times -- you can somewhat open-endedly barrage-test your algorithm, something that's already led to a few interesting discoveries that I'd like to refine before publishing to the repo.
If you're interested, the code is here. The running code is a single .py with the upsides and downsides that come with that. If you're interested or have any questions, let me know! :D :))))
I wonder if converting a model back into code and then optimizing that is a viable path, you could then try to drop out little bits of the code to see if they meaningfully affect the output or not.
One could distill the tiny ResNet into a graph network, which with the right constraints could theoretically accomplish the same as the original neural network, and then compress that as small as possible. There's probably an interesting tradeoff in "maximal compression" and "number of iterate rounds" for said graph network. I recently got enough runs (25) and performance difference to have a p=.0014 result or something like that in half an hour for something I was experimenting with against the baseline recently and it felt so good because I wasn't diddling with 5 runs, which in some cases for certain papers take days to finish. It's just a very satisfying feeling.
I guess back to the explainability side of things.... -- that alone I don't think would necessarily provide answers to the explainability problem but I think it would be like a refining-oil type step before diving into the L2-compressed feature representations....
And if you hack this to the point where it is explainable then that in turn might generalize to larger networks and/or different problems.
https://myrtle.ai/learn/how-to-train-your-resnet-8-bag-of-tr...
I wanted to start with his baseline but as that hackable workbench for my own purposes to explore some information theory concepts w.r.t. deep learning and etc. His code is beautiful but also a framework-within-a-framework and nearly purely functional so quick hacks are basically impossible beyond a certain point. There are tradeoffs of course.
Continuing to drop bit depth and a few other improvements will probably carry things surprisingly far, so long as hardware compatibility with said hacks remains Gucci. There's also some Triton kernel hacks that we could dip into but it would taint some of the "pure simple python" goals for the project.
But yes -- this is a port of David Page's work designed for a 1-2 hour quick-sketch experimenting researcher. I've found a few other improvements that I hope to refine and contribute to the repo at some point -- after I fix a few basic, glaring bugs like the console printing the whole progress chart again each time. But yes, we're well on our way and thank you so much for linking that -- I'm a rather large fan of his work and I truly hope that some more of his wizardry comes to public light for us to glean from. :D :)))) <3
Thanks for the detailed comment, I definitely will dive into your script soon! One early suggestion, you might want to try torch dynamo [1], anecdotally I had good speedups (~20%) on some image models; though not sure how significant the impact might be at this (relatively) small scale.
Thanks so much for the suggestion, I'll take a look at it! And much appreciated to a huge degree on interest in the script, it's still not perfectly polished stylistically but now that the baseline checks out, we definitely have a lot of performance gains to be had in the next release! :D :)
Feel free to ping me if you ever need anything, I'm not the most active on GitHub but if you ever need to reach me by email for questions/comments/thoughts/etc, hi [ period ] tysam [ the at symbol ] gmail [ period ] com is my email address. :D
Wow, that sounds nifty! Could you elaborate or point to more resources for that sort of technique?
Alternatively, you can read through the direct code here if you're willing to wade through some of the mathy code on it: https://github.com/tysam-code/hlb-CIFAR10/blob/main/main.py#...
conv_layer.weight.data = (eigenvectors/torch.sqrt(eigenvalues+eps))[-shape[0]:, :, :, :]
## We don't want to train this, since this is implicitly whitening over the whole dataset
What does NP-hard mean in the context of neural networks? You mean the loss minimization of those layers is NP-hard?
There are a few layers in which the order of certain things matter -- basically, any chaotic system arising from the choices made in training neural networks. We oftentimes just randomly choose an answer as that's a "best guess", but in pushing the territory of world records, something more principled is in order.
Weight initialization is one, and what data we show to the network when is another. Each choice at any point influences every single choice that comes after it, so even if it was quantized into discrete decision bins (which it can be for both of those, I believe -- even the weight initialization if you're a lottery ticket hypothesis fan. I cringe in saying that though as that phrase can summon an interesting mix of people.) In that sense, calculating which order of operations/order of values is ideal is I believe an NP-hard problem by definition, and not too much weirdness if we're looking at the discrete case(s) I think.
Maybe solving that up front from a structure perspective is untenable, but if we're able to crack some of the mystery of the solution manifold and turn that into portable priors for architectures like this, then I think that opens the door to connecting things to a more universal, pure mathematical solution. And then that ends up unpacking nicely in other problem domains even if we maybe don't know up front which priors work well for that particular subdomain. If we have some sort of mathematically-connected rule, we can be more sure about it.
That's a loose form of a general workflow I follow, it's a bit more of a crapshoot though where any discrete chaotic processes are involved, unfortunately.
Hope that helps answer some of the question, there's definitely other layers to be had, though. Which means job security for a lot of people for a long time to come, I personally think. :D :))))
I like the new shiny shiny too, but I've been in this field too long to chase all the new stuff that comes along (and I do love me some Hinton too). I thought about FF for this application but didn't see anything that would make it work in this context, is there anything in particular that you were seeing that would benefit us in this particular usecase?
TFA though also reminds me of the phenomenon in mathematical proofs where some long winded proof eventually comes up but then over time it becomes simplified as more mathematicians try to optimize it, in much the same way as programmers with technical debt ("make it work, make it right, make it fast"), such as with the four color theorem that was until now computer assisted but it seems there is a non computer assisted proof out [1].
I wonder if the problem in TFA could itself be solved by machine learning, where models would create, train, and test other models, changing them along the way, similar to genetic programming but with "artificial selection" and not "natural selection" so to speak.
People love to say "it's early" and "it will improve" about ChatGPT. but amount of training data IS the dominant factor in determining the quality of the output, usually in logarithmic terms. it's already trained on the entire internet. it's hard to see how they'll be able to significantly increase that.
And having models build models is drastically overrated. again, the accuracy/quality improvements are largely driven by the scale and diversity of the dataset. that's like 90% of the solution to any ml problem. choosing the right model and parameters is often a minor relative improvement
And (with scary privacy implications) maybe the next frontier is capturing all spoken language uttered by people in real-time and streaming it into a model that is being updated in near-real-time.
And finally brain implants extracting unspoken thoughts and neural activity and combining it all. Extend it to non human life forms as well. (universal consciousness?)
With feedback.
If there were a model that could adequately replace the role of the human, then that approach would probably work well.
On pure # of words, sure.
But for humans, language is actually just a compressed version of reality perceived through multiple senses / prediction + observation cycles / model paradigms / scales / contexts/ social cues, etc. and we get full access to the entire thing. So a single sentence is wrapped in orders of magnitude more data.
We also get multiple modes of interconnected feedback. How to describe this? Let me use an analogy. In poker, different properties a player has statistically take different amounts of data to reach convergence: Some become evident in 10s of hands, some take 100s of hands, and some take 1000s, and some even take 10,000s before you get over 90% confidence. ....And yet, if you let a good player see your behavior on just one single hand that goes to showdown, a good human player will be able to estimate your playing style, skill, and where your stats will converge to with remarkable accuracy. They get to see how you acted pre-flop, on the flop, turn, and river, with the rich context of position, pot-size, and what the other players were doing during those times, along with the stakes and location you're playing at, what you're wearing, how you move and handle your chips, etc. etc.
But it may be better data.
So, you take your baby AI and instead of training it just on a static corpus, you put it in a simulator. And then when you again hit a wall where you conclude data is the problem, you give them a robot body and plug them into the internet bidirectionally. Some would argue this would be a mistake.
This is mostly wrong.
It's possible to get higher quality results in specific domains by fine-tuning on carefully annotated datasets. However these higher quality results wouldn't be possible without the vast pre-training on the huge dataset LAION-5B provides.
> humans tag stuff for machine learning, and make that tagged data set open? Does such a thing exist?
Yes, there are lots. The size of LAION-5B is the innovation here.
A genetical algorithm was also what I was thinking of. One could devise some kind of symbolic (textual) way to represent a wiring/circuit diagram (graph) and evolve the most efficient "learner" using mutation and cross-breeding (e-sex). The earliest GA I read about used Lisp dicing.
As far as "easiest" AI for humans to work with, "Factor Tables" may be a way:
AI tuning then becomes more like accounting instead of a lab with Doc Brown. Factor Tables are much easier to analyze, debug, and modularize than neural nets.
This is a bit incomplete. It goes both ways. Right in the abstract, it says:
"the model size and the number of training tokens should be scaled equally: for every doubling of model size the number of training tokens should also be doubled"
You are probably referring to the statement:
"We find that current large language models are significantly undertrained, a consequence of the recent focus on scaling language models whilst keeping the amount of training data constant."
So GPT3 and co would perform better with more data, but only up to a certain point. At that point, you would also need to scale up the model size again to get better performance.
But also, GPT3 and co would perform better when they would be scaled down a bit, when you keep the same training data. That is actually what the Chinchilla paper does. Their Chinchilla model is smaller than GPT3 and others, trained with same amount of data (as Gopher), and performs better.
I don't really see a problem in scaling up models even more. This paper just says that you should also scale up the training tokens equally.
As far as I remember, this paper does not quite address whether you can use the same training data twice. I think all statements assume that every training token is only used once.
Anyway, residual connections in NNs as well as distillation being only a 1% hit to performance imply our models are way too big.
If you have any ideas to do better and aren't idly wealthy, I'd suggest pursuing them. Create a model that's within a percentage point or two of GPT3 on big NLP benchmarks, and fame and fortune will be yours.
[Edit] this of course only applies for domains like NLP or computer vision where neural networks have proven very hard to beat. If you're working on a problem that doesn't need deep learning to achieve adequate performance, don't use them!
My perspective is more pessimistic. I think people opt for huge unsupervised models because they believe that tuning a few thousand more input features is easier than labeling copious amounts of data. Plus (in my experience) supervised models often require a more involved understanding of the math, whereas there's so many NN frameworks that ask very little of the users.
Companies like Google have even spent huge amounts of time and money on enormous labeled datasets -- JFT-300M or something like that for computer vision tasks, as you might guess, ~300M labeled images. It creates value, but it creates more value for larger models with higher capacity.
And yet people still like to push this idea that we will magically and accidentally build a superintelligence on top of these systems. It's so frustrating how deep into their own koolaid the ML industry is. We don't even know how the brain learns, we don't understand intelligence, there's no valid reason to believe a NN "learns" the same way a human brain learns, and individual human neurons are infinitely more complex and "learning" than even a single layer of a NN.
No, we understand very well how NNs work. Look at PartiallyTyped's comment in this thread. It's a great explanation of the basic concepts behind modern machine learning.
You're quite correct that modern neural networks have nothing to do with how the brain learns or with any kind of superintelligence. And people know this. But these technologies have valuable practical applications. They're good at what they were made to do.
I disagree with the conclusion.
It indicates that our optimisers are just not good enough, likely because gradient descent is just weak.
The argument for residual connections is that we can create a nested family of models which enables expressing more models, but also embedding the smaller ones into them.
The smaller models may be retrieved if our model learns to produce the the identity function at later layers.
The problem though is that that is very difficult, meaning that our optimisers are simply not good enough at constructing identify functions. With the residual layers, we can embed the identity function into the structure of the model, and we now need to learn to map to 0 (since a residual is f(x) = x+g(x)), we need only to learn g(x)=0).
As for our optimisers being bad, the argument is that with an overparameterised network, there is always a descent direction, but we land on local minima that are very close to the global one. The descend direction may exist in the batch, but when considering all the batches, we are at a local minimum.
We can find many such local minima via certain symmetries.
The general problem however is that even with the full dataset, we can only make local improvements in the landscape.
Thus, it’s that the better models are embedded within the larger ones, and more parameters enable us to find them because of nested families, symmetries, and because of always having a descent direction.
No, the networks are ok, what is wrong is the paradigm. If you want rule or code based exploration and learning it is possible. You need to train a model to generate code from text instructions, then fine-tune it with RL on problem solving. The code generated by the model is interpretable and generalises better than running computation in the network itself.
Neural nets can also generate problems, tests and evaluations of the test outputs. They can make a data generation loop. As an analogy, AlphaGo generated its own training data by self play and had very strong skills.
I don’t think that this reply takes into consideration just how inefficient RL and the likes are. In fact, RL is so inefficient that current SOTA in RL is … causal transformers that perform in-context learning without gradient updates.
Depending on the approach one takes with RL, be it policy gradients or value networks, it still relies on gradient descent (and backprop).
Policy gradients are just increasing the likelihood of useful actions given the current state. It’s a likelihood model increasing probabilities based on observed random walks.
Value networks are even worse because one needs to derive not only the quality of the behaviour but also select an action.
Sure enough, alternative methods exist such as model based RL, etc, and for example ChatGPT use RL to train some value functions and learn how to rank options, but all of these rely on gradient descent.
Gradient descent, especially stochastic, is just garbage compared to stuff that we have for fixed functions that are not very expensive to evaluate.
With stochastic gradient descent, your loss landscape depends on the example or mini batch, so a way to think about it is that the landscape is a linear combination of all the training examples, but at any time you observe only some of them and cope that the gradient doesn’t mess up too bad.
But in general gradient descent shows linear convergence rate (cf Nocedal et al Numerical Opt, or Boyd and Vanderberghe’s proof where they bound the improvement of the iterates), and that’s a best case scenario (meaning non stochastic, non partial).
Second order methods can get quadratic convergence rate but they are prohibitly expensive for large models, or require hessians (good luck lol).
None of these though address limitations imposed by loss functions, eg needing exponentially higher values to increase a prediction optimised by cross entropy (see the logarithm). Nor do they address the bound on the information that we have about the minima.
So needing exponentially more steps (assuming each update is fixed in length) while relying on linear convergence is … problematic to say the list
To generate more, you need to interact with an environment, and you also need an objective function. If we could magically generate more textual data, then we have a language model already and don't need to train another language model.
You can't bootstrap a model for language synthesis unless you give it access to the internet to interact with users, at which point ... you have a Tay [1]
Interesting. I was thinking the same, after coming across a preprint proposing a credit-assignment mechanism that seems to make it possible to build deep models in a way that enables interpretability: https://arxiv.org/abs/2211.11754 (please note: the results look interesting/significant to me, but I'm still making my way through the preprint and its accompanying code).
Consider that our brains are incredibly complex organs, yet they are really good at answering questions in a way that other brains find interpretable. Meanwhile, large language models (LLMs) keep getting better and better at explaining their answers with natural language in a way that our brains find interpretable. If you ask ChatGPT to explain its answers, it will generate explanations that a human being can interpret -- even if the explanations are wrong!
Could it be that "model simplicity" and "model interpretability" are actually orthogonal to each other?
As a famous early example, this lady provided an unprompted explanation (using only the information available to her conscious part of her brain in her good eye) for some of her preferences despite the mechanism of action being subconscious observations out of her blind eye.
If you ask ChatGPT to explain its answers, it will generate explanations that a human being can interpret -- even if the explanations are wrong!
The funny thing is that yeah, LLMs often come up with correct method-description for wrong answers and wrong method-descriptions for right answers. Human language is quite slippery and humans do this too. Human beings tend to start loose but tighten things up over time - LLMs are kind of randomly tight and loose. Maybe this can be tuned but I think "lack of actual understanding" will make this difficult.
But if that model could chat with us it would replicate the speech of the loan officers, many of whom sincerely believe that they treat green people and blue people fairly. So interpretability can't be about somehow asking the model to justify itself. We may need the equivalent of a debugger.
If you ask an art expert 'how much will this painting sell for at auction', he might reply '$450k'. And when questioned, he'll probably have a long answer about the brush strokes being more detailed than this other painting by the same artist, but it being worth less due to surface damage...
If our 'black box' ML models could give a similar long answer when asked 'why', would that solve the need? Because ChatGPT is getting close to being able to do just that...
One example is that stable diffusion (SD) (think GPT for images) does a pretty bad job of rendering humans. It also isn't trained on NSFW data. Now, people took these SD models and trained them on pornographic images. Turns out, this new model while excellent at generating NSFW images, also became really good at creating humans in general.
There are similar gains that we are ethically leaving on the table. IMO, it's for the best. The field is moving fast enough as it is.
My SymReg library pops to mind. I'm thinking of rewriting it in multithreaded Julia this holiday season.
It is indeed of limited use, since often I can spot the relationship visually. And once I get the general equation I can easily transform the data to get a linear regression.
And closed-form equations are themselves almost always simplified or abstracted models derived from real-world observations.
Which is why actual option prices have the "smile", with tail prices being higher than the model would predict (because traders know that the model underestimates tail risk, and generally have a good sense of how far it underestimates it, because the model is fairly transparent).
Because B-S is closed form, you can run it backwards, to convert actual prices to an implied volatility.
Which is also known to be wrong, because historical standard deviations of returns are only somewhat predictive of future observed returns.
As one person put it, Black-Scholes is the wrong model, into which you put the wrong data, to get the right answer.
Also, plenty of "deep learning" tasks work equally well with decision trees if you use the right feature extractors.
Lolwut? Does your average regular person know machine learning is used to make these decisions at all?
However it seems to deal more with problems of perception in AI and how things might be better in the ideal rather than present any specific results.
Maybe I’m missing something, not sure of the insight here? I agree it’s an important issue and laudable goal.
Lines are being drawn around what AI can be permitted to engage; if the methods aren't understood then they can't be controlled, and there are large domains where the Powers That Be won't tolerate what they can't control.
Of course, it is at least as likely that the outcomes are actually less arbitrary than the conventional, and this this is what causes consternation.
Cynthia Rudin, Professor of Computer Science, Electrical and Computer Engineering, and Statistical Science, Duke University
https://pdfs.semanticscholar.org/7b99/2c46800f8913c251259c1d...
https://publications.jrc.ec.europa.eu/repository/handle/JRC1...
This seems to be Rudin's thing - finding equally accurate but simpler models for things upon which deep learning can be trained. Where is there something on this that's not paywalled?
Cynthia Rudin, Professor of Computer Science, Electrical and Computer Engineering, and Statistical Science, Duke University
https://pdfs.semanticscholar.org/7b99/2c46800f8913c251259c1d...
It starts using the example of "rectangle" learning, where data points are encoded as points in a 2-dimensional space, just like many other learning algorithms start by encoding things as points in N-dimensional space.
But then, instead of launching straight into decision trees or k-means or Gaussians or anything like that, the book does something strange: It uses "rectangle" as a machine learning model. The idea is that some points are marked with one label (red) others with another (blue). You want to fit a model to distinguish red from blue.
So you just take the min/max of all the x/y corrdinates that you've seen in your training data to get a lower-left and upper-right point defining a rectangle and predict that all points inside the rectangle are red.
Then the book continues with all the usual stuff like figuring out error surfaces, computing precision/recall and so forth and then introduces concepts like big-O analysis of data complexity, overfitting problems by having a sense for the kolmogorov complexity in the model space versus amount of data, etc. etc.
This really blew my mind, that, at the point where the "magic" was supposed to come in, introducing neural networks or whatever, they just skip over that, sort of saying: That's not important yet, let's just use a simple thing like 'rectangle' as a placeholder for now as it will serve our purpose just as well.
So: Any method for selecting a model (e.g. particular rectangle) from a meta-model (e.g. set of all rectangles) can be a valid machine learning method and there really is no "magic" to neural networks. What really matters is whether the model is well-suited to the phenomenon being modelled, given the way the data is encoded. So it makes a lot of sense to obsess over preprocessing of data and to come up with custom models to fit custom modelling needs. It makes very little sense to chase all the newest and greatest breakthroughs in [machine learning flavour of the week].
This has been pretty much how I have been doing machine learning over the course of 10 years, working as a Data Scientist.
My advice to people starting out in this field: By walking down this path, you will have predictably successful project outcomes while at the same time flushing your career down the tube. ...your ignorant bosses will never see you as the smart guy in the room, if everyone else is talking about neural networks and you are talking about rectangles.