anchor.diff:                                     2))
                              :learning-rate (flt learning-rate)
                              :learning-rate-decay (flt learning-rate-decay)
  -                           :batch-size 100)))
  +                           :weight-penalty (if (and input-weight-penalty
  +                                                    (member (name lump)
  +                                                            '((inputs f1))
  +                                                            :test #'name=))
  +                                               (flt input-weight-penalty)
  +                                               (flt 0))
  +                           :batch-size batch-size)))
                (when l2-upper-bound
                  (arrange-for-renormalizing-activations
                   bpn trainer l2-upper-bound))
  +             #+nil
  +             (when (member (name lump) '((inputs f1))
  +                           :test #'name=)
  +               (push (let ((mask (make-sparse-column-mask (nodes lump) 392)))
  +                       (.*! mask (nodes lump))
  +                       (lambda ()
  +                         (.*! mask (nodes lump))))
  +                     (after-update-hook trainer)))
                trainer))
            (make-segmenter (fn)
  -           (if l2-upper-bound
  -               (make-dwim-grouped-segmenter fn)
  -               fn)))
  +           (let ((dwim (make-dwim-grouped-segmenter fn)))
  +             (lambda (lump)
  +               (if (and l2-upper-bound
  +                        (not (and input-weight-penalty
  +                                  (member (name lump) '((inputs f1) (:bias f1))
  +                                          :test #'name=))))
  +                   (funcall dwim lump)
  +                   (funcall fn lump))))))
       (unless (zerop n-softmax-epochs)
         (log-msg "Starting to train the softmax layer of BPN~%")
         (train (make-sampler training :n-epochs n-softmax-epochs)
  
positive.code:                           :n-epochs (if quick-run-p 2 3000)
                            :learning-rate (flt 1)
                            :learning-rate-decay (flt 0.998)
                            :l2-upper-bound (sqrt (flt 3.75)))
        (unless quick-run-p
          (save-weights bpn-filename bpn)))))
  
negative.code: 
  (defun build-maxout-mnist-bpn (&key (n-units-1 1200) (n-units-2 1200)
                                 (group-size 5))
    (build-bpn (:class 'mnist-bpn)
      (inputs (->input :size 784 :dropout (flt 0.2)))
      (f1-activations (add-activations :name 'f1 :inputs '(inputs)
                                       :size n-units-1))
  