anchor.diff:  (defmethod log-test-error (trainer (bpn mnist-bpn))
     (call-next-method)
     (multiple-value-bind (e ce)
  -      (bpn-error (make-sampler *test-images* :max-n (length *test-images*)
  -                               :omit-label-p t) bpn)
  +      (bpn-error (make-test-sampler :omit-label-p t) bpn)
       (log-msg "TEST CROSS ENTROPY ERROR: ~,5F (~D)~%"
                ce (n-inputs trainer))
       (log-msg "TEST CLASSIFICATION ACCURACY: ~? (~D)~%"
  
positive.code:                                          (floor (n-inputs trainer)
                                                  (length *training-images*)))
                                   *mnist-dir*)
                  *dbm/2*)
    (let ((counters-and-measurers
           (make-bm-reconstruction-misclassification-counters-and-measurers dbm)))
      (when counters-and-measurers
        (let ((errors (map 'list
                           #'get-error
                           (mnist-dbm-mean-field-errors
                            (make-sampler (subseq *training-images* 0 1000)
                                          :max-n
                                          1000
                                          #+nil
                                          (length
                                           *training-images*)
                                          :omit-label-p nil)
                            dbm
                            :counters-and-measurers
                            counters-and-measurers))))
          (log-msg "DBM TRAINING RECONSTRUCTION CLASSIFICATION ACCURACY: ~? (~D)~%"
                   *list-of-percents-format*
                   (list (mapcar #'->percent errors))
                   (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
                           (mnist-dbm-mean-field-errors
                            (make-sampler (subseq *training-images* 0 1000)
                                          :max-n
                                          1000
                                          #+nil
                                          (length
                                           *training-images*)
                                          :omit-label-p t)
                            dbm
                            :counters-and-measurers
                            counters-and-measurers))))
          (log-msg "DBM TRAINING CLASSIFICATION ACCURACY: ~? (~D)~%"
                   *list-of-percents-format*
                   (list (mapcar #'->percent errors))
                   (n-inputs trainer)))))
    (log-msg "DBM TEST RMSE: ~{~,5F~^, ~} (~D)~%"
             (map 'list
                  #'get-error
                  (mnist-dbm-mean-field-errors (make-sampler *test-images*
                                                             :max-n #+nil
                                                             (length *test-images*)
                                                             1000)
                                               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
                           (mnist-dbm-mean-field-errors
                            (make-sampler *test-images*
                                          :max-n #+nil
                                          (length
                                           *test-images*)
                                          1000
                                          :omit-label-p t)
                            dbm
                            :counters-and-measurers
                            counters-and-measurers))))
          (log-msg "DBM TEST CLASSIFICATION ACCURACY: ~? (~D)~%"
                   *list-of-percents-format*
                   (list (mapcar #'->percent errors))
                   (n-inputs trainer))))))
  
  (defmethod positive-phase :around (batch trainer (dbm mnist-dbm))
    (call-next-method)
  
negative.code:                         counters-and-measurers)
    (map 'list #'car counters-and-measurers))
  
  (defun log-dbm-classification-accuracy (dbm sampler name)
    (let ((counters-and-measurers
           (make-bm-reconstruction-misclassification-counters-and-measurers dbm)))
      (when counters-and-measurers
        (let ((errors (map 'list
                           #'get-error
                           (mnist-dbm-mean-field-errors sampler
                                                        dbm
                                                        :counters-and-measurers
                                                        counters-and-measurers))))
          (log-msg "DBM ~A CLASSIFICATION ACCURACY: ~?~%"
                   name
                   *list-of-percents-format*
                   (list (mapcar #'->percent errors)))))))
  
  (defmethod log-test-error ((trainer mnist-dbm-trainer) (dbm mnist-dbm))
    (call-next-method)
    (map nil #'xxx (clouds dbm))
  