anchor.diff:           (upper-bounds (make-array k :initial-element 0))
            (filters
              (make-trainable-parameter
  -            (make-random-array n-filters :element-type (element-type array))))
  +            (make-random-array
  +             (list n-filters (length stencil))
  +             :element-type (element-type array))))
            (d nil))
       ;; Determine the dimension of the stencil.
       (loop for offsets in stencil do
  
positive.code: (defparameter *test-images* (load-array "mnist-data" "test-images.npy"))
  (defparameter *test-labels* (load-array "mnist-data" "test-labels.npy"))
  
  (defun main ()
    (let* ((input (make-instance 'parameter
                    :shape (~ 1 28 ~ 1 28)
                    :element-type 'single-float))
           (output
             (make-fully-connected-layer
              (make-maxpool-layer
               (relu
                (make-convolutional-layer
                 input
                 :stencil '((0 0) (1 0) (0 1) (-1 0) (0 -1))
                 :n-filters 12))
               '(1 2 2))
              (~ 0 9))))
      (train (make-network output)
             (list
              (α 'coerce
                 (α (lambda (n i) (if (= n i) 1.0 0.0))
                    (reshape *train-labels* (τ (i) (i 0)))
                    #(0 1 2 3 4 5 6 7 8 9))
                 'single-float))
             :learning-rate 0.02
             input (α #'/ *train-images* 255.0))))
  
negative.code:               for value in (multiple-value-list
                              (apply #'call-network training-network (reverse args)))
                do (setf (trainable-parameter-value trainable-parameter)
                         value))))
      ;; Return the trained network.
      network))
  
  (defun nth-datum (index data)
    (reshape
  