anchor.diff:  
   #|
   
  -(save-weights (merge-pathnames "mnist-2-2.dbn" *mnist-dir*)
  -              *dbn/2*)
  -
  -(let ((dbn (make-mnist-dbn/2 (make-mnist-dbm))))
  -  (load-weights (merge-pathnames "mnist-2.dbn" *mnist-dir*) dbn)
  -  (dolist (rbm (rbms dbn))
  -    (dolist (cloud (clouds rbm))
  -      (log-msg "~A: ~A~%" cloud (xxx (weights cloud))))))
  -
   (train-mnist/1)
   
   (train-mnist/1 :load-dbn-p t)
  
positive.code: 
  (defmethod log-test-error ((trainer mnist-dbm-trainer) (dbm mnist-dbm))
    (describe-trainer trainer)
    (unless (zerop (n-inputs trainer))
      (log-msg "DBM TEST RMSE: ~{~,5F~^, ~} (~D)~%"
               (map 'list
                    #'get-error
                    (bm-mean-field-errors (make-sampler *test-images*
                                                        :max-n #+nil
                                                        1000
                                                        (length *test-images*))
                                          dbm))
               (n-inputs trainer))
      (let ((counters-and-measurers
             (make-bm-reconstruction-misclassification-counters-and-measurers dbm)))
        (when counters-and-measurers
          (let ((errors (map 'list
                             #'get-error
                             (bm-mean-field-errors (make-sampler *test-images*
                                                                 :max-n #+nil
                                                                 1000
                                                                 (length
                                                                  *test-images*)
                                                                 :omit-label-p t)
                                                   dbm
                                                   :counters-and-measurers
                                                   counters-and-measurers))))
            (log-msg "DBM TEST CLASSIFICATION ACCURACY: ~{~,2F%~^, ~} (~D)~%"
                     (mapcar (lambda (e)
                               (* 100 (- 1 e)))
                             errors)
                     (n-inputs trainer)))))))
  
  (defmethod positive-phase :around (batch trainer (dbm mnist-dbm))
    (call-next-method)
  
negative.code:   ((counter :initform (make-instance 'rmse-counter) :reader counter)))
  
  (defmethod log-training-error ((trainer mnist-dbm-trainer) (dbm mnist-dbm))
    (let ((counter (counter trainer))
          (n-inputs (n-inputs trainer)))
      (log-msg "TRAINING RMSE: ~,5F (~D)~%"
  