Use linearly falling learning rate

This makes big strides on the completely untrained network, but treads
more carefully later on. Prevents overshooting with reLU, and even
slightly improves Sigmoid.

Simplify code

Eliminate unnecessary persistent variables and initializations.

Tweak network structure

Increase first layer size, otherwise the network does not "see" enough
detail in the input.  Drop second layer, it makes the recognition rate
actually much worse.

Process many images in parallel

Provide one object per NN layer and implement their functionality
separately, like in
https://www.kdnuggets.com/2019/08/numpy-neural-networks-computational-graphs.html

Each layer does not take only one image vector, but a whole 10,000 of
them, which massively speeds up the computation -- much less time spent
in Python iterations.

Add backpropagation batching

This will eventually speed up learning, once it gets run with random
subsets of the training data.

Add backpropagation and first round of learning

Move forward feeding to sigmoid

Let's comare it to reLU later on.

Initial Neural network with forward feeding

Two hidden layers with parametrizable size. Two possible transfer
functions, defaulting to reLU for now.

Initialize weights and biases randomly. This gives totally random
classifications of course, but at least makes sure that the data
structures and computations work.

Also already add a function to recognize the test images and count
correct ones. Without trainingh, 10% of the samples are expected to be
right by pure chance.

Rearange image vector

Put each image into a column instead of a row, which works much better
with the standard formulation of backpropagation algorithms.

Read MNIST db into numpy arrays, display

Add script to download MNIST digit database

README.md: First steps and resources