anchor.diff:                                              :key #'image-label))
                                  :pass-fold t))
   
  -(with-example-log ()
  -  (let ((*default-mat-ctype* :float))
  -    (train-mnist/5 :training (training-images) :test (test-images))))
  +(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
  
positive.code: 
  (defun init-bpn-weights (bpn &key stddev)
    (map-segments (lambda (weight)
                    (gaussian-random! (nodes weight) :stddev stddev))
                  bpn))
  
  (defun train-mnist/3 (&key training test quick-run-p bpn-var bpn-filename)
  
negative.code:                               :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))
  