anchor.diff:            for mse = 1.0 then (present-vectors net t-set)
             while (and (> mse target-mse) (not (stop-training net)))
             when (or
  -                (and (> i 1) (> mse 0.80) (or rerandomize-weights annealing))
  +                (and (> i 1)
  +                     (> mse (* 10 target-mse))
  +                     (or rerandomize-weights annealing))
                   (randomize net)
                   (anneal net)
                   (shock net))
  -          do (shock-weights net mse rerandomize-weights randomize-weights
  -                            logger-function annealing i)
  +          do (shock-weights net target-mse mse rerandomize-weights
  +                            randomize-weights logger-function annealing i)
             when (and report-function
                       (or (not last-report-time)
                           (>= (- (get-internal-real-time) last-report-time) rf)))
  
positive.code:        do (backprop layer))
      net))
  
  (defmethod output-layer-error ((net t-net) (outputs vector))
    (loop for neuron across (neuron-array (output-layer net))
       for expected-output across outputs
       for actual-output = (output neuron)
       do (setf (expected-output neuron) expected-output)
       summing
         (* 0.5 (expt (- expected-output actual-output) 2))))
  
  (defmethod learn-vector ((inputs vector) (outputs vector) (net t-net))
    (feed net inputs)
    (let ((err (output-layer-error net outputs)))
      (backprop net)
      err))
  
  (defun tset-list-to-tset-vectors (tset)
  
negative.code: 
  (defmethod transfer ((neuron t-neuron))
    (setf (output neuron)
          (funcall (transfer-function neuron) (input neuron)))
    neuron)
  
  (defmethod connect ((net t-net))
  