Neural Chip Plays Doom Using a Thousandth of a Watt | Hacker News Reader

Neural Chip Plays Doom Using a Thousandth of a Watt

tomshardware.com

139 pointsrbanffy46 comments

That's a verbose way to say 1mW, and I wouldn't have guessed from the title that the chip is being trained to play Doom, rather than running the game at that power level.

Thing is, Watts don't have a time dimension. It sounds like this is how much power was being consumed by the chip while it ran the model to play the game in realtime, but it also sounds like they were using the chip to train the model. From the linked IEEE Spectrum article:

>"After its first kill, it unloads the clip, but then it figures out that’s not a good strategy,” ...

It sounds cool, but some more details would be nice. This chip seems to use a custom Tensilica core like the ESP8266/32 family started with, but we'll also have ARM Cortex-M CPUs with neural accelerators soon, so this space will be interesting to watch.

Yeah, the title is really misleading -

> Syntiant trained the NDP200's neural network using VizDoom, a version of Doom used for AI research and reinforcement learning from raw visual information. Training required understanding what the neural network was seeing, primarily identifying the enemy and ultimately defining a response. In this case, see demon, shoot demon. The "player" is tasked with defending a circular room that is under constant attack.

> The purpose of the demo is not to show how well it can play Doom, but to demonstrate how efficient the NDP200 is at "bounding-box person detection"

So like... it's playing a DOOM mod that teaches it to turn in circles and aim and shoot when it sees an enemy - until it runs out of ammo and it dies because it's standing still and the enemies walk up and kill it. It's not that that's not an accomplishment, it's more that that's not really 'playing DOOM' as far as anyone who's ever played DOOM would understand it. You know?

> The purpose of the demo is not to show how well it can play Doom, but to demonstrate how efficient the NDP200 is at "bounding-box person detection"

Personally this part seemed like a tall claim to me as well. Bounding box detection in the environment shown would be incredibly easy.

There is no visual complexity at all. Just detecting patches of a certain colour would do the job.

It looks like the Tensillica is only DSP. The control core is M0. 1mW is quite low though - typical M0 running at full speed would typically be 10-100mW and they have the neural unit on as well.

Watts have a time dimension: W = J/s (Joule of energy per second) measuring power/intensity.

It is a great philosophical question, though. Speed is derived from the distance traveled per unit of time, but does speed itself have a time dimension?

...perhaps if it changes over time, but that's acceleration and so on.

One of the degrees of freedom in speed is time. We can hold the distance constant and obtain different speeds by varying time.

True, but if you pick just one (constant) speed/power value, like the 1 mW in the article, only the distance/work varies as a function of time.

In this case i assume Watts = Volts*Amps, if volts is 5v, then its easy enough to calculate the continuous current draw of the chip.

isn’t the change over time amps? or volts for that matter.

It is the very definition of a milliwatt.

I guess the issue is that it could be running for a million years to complete training, all the while "only" consuming 1mW.

Power should still be an indication of the overall energy spent provided it was used up somewhat evenly. "Neural Chip Plays Doom for 2 Hours Using 7.2 J of Energy" is quite a mouthful.

Plus, that’s not really Doom.

It's not even running Doom? It looks like a single arena like room with a few enemies from Doom and you are able to shoot... Not really playing Doom.

Ahhhg! "it unloads the magazine"

> I wouldn't have guessed from the title that the chip is being trained to play Doom, rather than running the game at that power level.

The illustration and the opening paragraph, which is all about devices that run Doom, not "play" it, isn't helping either.

In the article it says, explicitly, that what it is doing is doing bounded box person detection

The article confuses training, inference and running the game environment. Best guess is the NDP2000 chip does just inference based on the serialised visual data it receives from another machine running Doom. I seriously doubt it would be efficient to train the model on that chip either. Don't get me wrong: Inferencing a 600k parameter model at 1mW is more efficient than probably anything else out there, so it's impressive and great for IoT and edge inference use-cases.

Edit: Seems I was wrong about training, it does do it, more details: https://youtu.be/QammxdPqP4g?t=08m57s

Good for active learning or fine-tuning at the edge, but it is to slow for model development in practice.

That is the only plausible interpretation. It doesn't say it plays it well. Could just be a few neurons to wiggle the wasd keys.

Here's actual talk from last year that goes into detail... I found the article lackluster. https://www.youtube.com/watch?v=QammxdPqP4g

A slightly related question: There's been a few articles in the recent years about ways to reduce the size of NNs. Does anyone know how efficiently packed are the new models like GPT? Essentially, what percentage of weights could be thrown out post-training without much impact on the quality?

Sparse matrices (i.e. filled mostly with zeroes) are apt to represent discrete structures, since you can interpret them as binary/n-hot vectors as opposed to points in space. I'd imagine there's some potential to do sparse matrix optimization on GPT since natural language has a tree-like structure, but it's a well known technique and I'm sure the big players are already doing it

what percentage of weights could be thrown out post-training

At least 60% according to this paper: https://arxiv.org/abs/2301.00774

So we just pick 60% of the weights arbitrarily, throw them out, and see how it goes?

No, we use the algorithm described in the paper.

The silly theoretical lower bound is finding a seed for a random number generator that unrolls weights in the order they’re used. So down to 32 bits minimum :) Silly answer but with enough compute you could find it and enable enormous models like that

It's an attractive idea but I believe that probability says "no". Assuming a perfect RNG, the odds are stacked that you can assume any length(index), into the correct set of data, will be longer than that data you're seeking a location of.

More background here:

https://math.stackexchange.com/questions/432017/can-random-n...

I'm sure there may be isolated exceptions where this wouldn't happen and it'd be fascinating to learn about what they'd be.

To my knowledge none have been found yet. If you know of any, do share.

I guess one counter argument is lossy compression. Another argument is to think about how rng generators are constructed in some cases (algebraic curves) and imagine instead of finding a seed, solving for an algebraic curve with the desired properties. More data necessary (the curve data) and tons of compute still (solving multivariate polynomials) but less so than finding a seed.

Then there’s also ideas like creating the weights out of another network (basically moving around in that sub space) which is a much more feasible idea and something Hardmaru has a cool article about

Such “random number generator” would be equivalent to the training algorithm.

That would reduce the storage requirement, but not energy/CPU. After decompressing you'd need to still process the original network.

I was interested in dropping the weights for processing on smaller devices.

A key achievement on the road to pervasive killbots. Something to celebrate!

eco-friendly killbots! that's important.

it's less about being eco-friendly as much as being able to loiter on station for longer durations before needing a recharge

or lurk in your ceiling until the Authority decides to dispose you.

The perfect union of the killbot and the Kill-A-Watt!

Doom was released 30 years ago 1993. The minimum system requirement was a 66 Hz 486 processor running at 3.50 Watts.

3500X increase in power efficiency, equal to over 30% annual increase in power efficiency.

There has got to be a better article about this device than this.

Now run it on a potato.

It's hard to get hard numbers, but https://www.worldrecordacademy.org/2023/1/most-power-generat... lists

> 8,580 Lay’s potatoes connected together to generate an initial 11.43W (Watts) of Power

which divides to 0.0013 Watts per potato, so you probably literally could.

(Meta: this is one of the weirdest comments I've written in a while, though "can you literally run AI on a potato in hard numbers" is very Hacker news feeling)

If you attached a camera, and trained the NN running on the potato to recognise potatoes, then put a mirror in front of it have you made a self-aware potato?

(And what a time to be alive)

Maybe having many specialized neural chips on a motherboard is the next step on the way to making an artificial brain.

Then, we will have just a few large chips running several functions in parallel, with those functions having the opportunity to integrate and modify each other as needed.

500 years in the future, spaceship technology will be tested by playing DOOM through it's AI.

with that progess we will rather have Hell on Earth /s

in 500 years, we will have hell on earth

How long until Skyrim is ported?

Reply on news.ycombinator.com