anchor.diff:    (make-indicator-classifier-parameters (list label2-list label2-list))
     (make-indicator-classifier-parameters (list label1-list label2-list))))
   
  +;; These parameters control the number of iterations of gradient descent, etc.
  +;; They're optional, and the last argument to opt can be omitted.
   (define optimization-params (list (list "epochs" 10) (list "l2-regularization" 1.0)))
   
  +;; Train the parameters (using stochastic gradient).
   (define best-parameters (opt joint-label-sequence-family initial-parameters training-data optimization-params))
  +;; Instantiate the model with the trained parameters.
   (define trained-sequence-model (apply joint-label-sequence-family best-parameters))
   
  +;; Print out some sample tags for stuff.
   (display "Best tags for the man:")
   (display (get-best-value (trained-sequence-model (generate-token-features (list "the" "man")))))
   (display "Best tags for the man eats fast food:")
  
positive.code: ;; accepts a number of parameter vectors, and returns a function that
  ;; tags a sequence.
  (define joint-label-sequence-family (classifier1-parameters classifier2-parameters transition1-parameters transition2-parameters label-parameters)
    ;; sequence-model is a function that tags a sequence.
    (define sequence-model (feature-vector-seq) 
      (let ((cur-label1 (amb label1-list))
            (cur-label2 (amb label2-list))
            (cur-input-features (car feature-vector-seq)))
        (make-featurized-classifier cur-label1 cur-input-features classifier1-parameters)
        (make-featurized-classifier cur-label2 cur-input-features classifier2-parameters)
        (make-indicator-classifier (lifted-list cur-label1 cur-label2) label-parameters)
  
        (if (nil? (cdr feature-vector-seq))
            (lifted-list (lifted-list cur-label1 cur-label2))
          (let ((remaining-labels (sequence-model (cdr feature-vector-seq)))
                (next-labels (lifted-car remaining-labels))
                (next-label1 (lifted-car next-labels))
                (next-label2 (lifted-cadr next-labels)))
  
            (make-indicator-classifier (lifted-list cur-label1 next-label1) transition1-parameters)
            (make-indicator-classifier (lifted-list cur-label2 next-label2) transition2-parameters)
            (lifted-cons (lifted-list cur-label1 cur-label2) remaining-labels)))))
    sequence-model)
  
  (define inputs (list (list "the" "man")
  
negative.code:                      (list (list "JJ" "NN" "VB" "JJ") (list "B" "I" "O" "O"))
                       ))
  
  ;; This code generates indicator features for the words in the input sequence.
  (define generate-token-features (token-list) (map (lambda (token) (feature-func (list (list token 1.0)))) token-list))
  (define featurized-inputs (map (lambda (x) (list (generate-token-features x))) inputs))
  
  ;; Procedure for conditioning the output distribution given the true labels.
  (define require-seq-equal (predicted actual)
    (if (nil? actual)
        #t
  