anchor.diff:                                :learning-rate 1
                                 :learning-rate-decay 0.998
                                 :l2-upper-bound (sqrt 3.75)
  +                              :input-weight-penalty 0.000001
  +                              :batch-size 96)
  +          (when (and bpn-filename (not quick-run-p))
  +            (save-weights bpn-filename bpn)))))))
  ++
  +
  +;;;; Batch-normalized max-channel
  +
  +(defun build-batch-normalized-max-channel-mnist-bpn
  +    (&key (n-units-1 1200) (n-units-2 1200) (group-size 2))
  +  (build-fnn (:class 'mnist-bpn)
  +    (inputs (->input :size 784 :dropout 0.2))
  +    (f1-activations (->batch-normalized-activation inputs :name 'f1
  +                                                   :size n-units-1
  +                                                   :batch-size 32))
  +    (f1* (->max-channel f1-activations :group-size group-size))
  +    (f1 (->dropout f1* :dropout 0.5))
  +    (f2-activations (->batch-normalized-activation f1 :name 'f2
  +                                                   :size n-units-2
  +                                                   :batch-size 32))
  +    (f2* (->max-channel f2-activations :group-size group-size))
  +    (f2 (->dropout f2* :dropout 0.5))
  +    (f3-activations (->batch-normalized-activation f2 :name 'f3
  +                                                   :size n-units-2
  +                                                   :batch-size 32))
  +    (f3* (->max-channel f3-activations :group-size group-size))
  +    (f3 (->dropout f3* :dropout 0.5))
  +    (prediction (make-softmax f3))))
  +
  +(defun train-mnist/6 (&key training test quick-run-p bpn-var bpn-filename)
  +  (with-cuda* ()
  +    (with-example-log ()
  +      (repeatably ()
  +        (log-msg "TRAIN-MNIST/6~%")
  +        (let ((bpn nil))
  +          (setq* (bpn bpn-var) (build-batch-normalized-max-channel-mnist-bpn))
  +          (init-bpn-weights bpn :stddev (sqrt (/ 1200)))
  +          (train-mnist-bpn-gd bpn training test
  +                              :n-softmax-epochs 0
  +                              :n-epochs (if quick-run-p 2 3000)
  +                              :learning-rate 1
  +                              :learning-rate-decay (expt 0.998 1)
                                 :input-weight-penalty 0.000001
                                 :batch-size 96)
             (when (and bpn-filename (not quick-run-p))
  
positive.code:   (log-msg "test at n-instances: ~S~%" (n-instances optimizer))
    (log-padded
     (let ((bpn (bpn learner)))
       (monitor-bpn-results (make-sampler (test optimizer)) bpn
                            (make-mnist-label-monitors
                             bpn :attributes '(:event "pred." :dataset "test")))))
    (log-mat-room)
    (log-msg "---------------------------------------------------~%"))
  
  
negative.code:                                             :key #'image-label))
                                 :pass-fold t))
  
  (repeatably ()
    (with-example-log ()
      (let ((*default-mat-ctype* :float)
            (*cuda-enabled* t))
        (train-mnist/6 :training (training-images) :test (test-images)))))
  
  (with-example-log ()
    ;; This only works with doubles for now, because boltzmann
  