A review of ``Playing Atari with Six Neurons''

Under review is the following academic paper seen under this URL: https://arxiv.org/abs/1806.01363v2

I also provide a copy of the paper here directly.  I've only seen its code in action under this URL:
https://twitter.com/giuse_tweets/status/1004382011551870976
https://xcancel.com/giuse_tweets/status/1004382011551870976

I've heard about this paper sporadically over the years, and decided to finally give it a read.  Its
title is, unsurprisingly, misleading.  The titular neurons are the final single-layer neural network
used to provide the controller input to the game, in the simplest case, with eighteen for those more
complex games; the system uses many more than this for other processes, however.  The thought behind
the paper is basic enough: Rather than go straight from video input to output fed to the controller,
the video input is fed into a network, which recognizes features it has built dynamically over time,
and output from that network is then fed into the single-layer network determining controller input.

The goal of the paper is to show that separating networks like this to be a good strategy, which I'd
have thought to be obvious.  I liken this to emergency access to infrastructure which enables one to
peer into the system, like visual access to plumbing, decreasing its efficiency at a minor cost when
compared to the benefits.  That word ``debug'' is a misnomer, and I much prefer the verb ``reveal''.
With this separation, a man can literally see the mid-level data on which the decision network acts.

That method by which the decision network is enlarged as its input size grows is rather neat, and so
simple.  There are a great many neat thingamajigs used across this paper to demonstrate how it acts.

While reading this paper, I was struck rather hard by ignorance of many terms used therein, although
most of them are easy enough to figure out by context.  I've since decided to correct this ignorance
by reading the earliest good works I could find and moving forward in time from there, starting with
the book ``Perceptrons'' which I plan to finish and review later; that book is rather different than
what I expected, in terms of method and material, but rather interesting, and can be purchased here:
https://mitpressbookstore.mit.edu/book/9780262534772

Some of the mathematics in particular went over my head as I was reading the paper, but I'd not call
complex, just unfamiliar.  One criticism I can level against the work is the lack of demonstrations,
I'd have liked to see some detailed graphic example of a step showing the network making a decision.
This code is public, but I've made no attempt to peek into it, given its complicated infrastructure.
.