Loss augmented inference using SparseNetworks

saul-core/src/main/scala/edu/illinois/cs/cogcomp/saul/classifier/JointTrainSparseNetwork.scala

@@ -18,16 +18,16 @@ object JointTrainSparseNetwork {
 
   val logger: Logger = LoggerFactory.getLogger(this.getClass)
   var difference = 0
-  def apply[HEAD <: AnyRef](node: Node[HEAD], cls: List[ConstrainedClassifier[_, HEAD]], init: Boolean)(implicit headTag: ClassTag[HEAD]) = {
-    train[HEAD](node, cls, 1, init)
+  def apply[HEAD <: AnyRef](node: Node[HEAD], cls: List[ConstrainedClassifier[_, HEAD]], init: Boolean, lossAugmented: Boolean)(implicit headTag: ClassTag[HEAD]) = {
+    train[HEAD](node, cls, 1, init, lossAugmented)
   }
 
-  def apply[HEAD <: AnyRef](node: Node[HEAD], cls: List[ConstrainedClassifier[_, HEAD]], it: Int, init: Boolean)(implicit headTag: ClassTag[HEAD]) = {
-    train[HEAD](node, cls, it, init)
+  def apply[HEAD <: AnyRef](node: Node[HEAD], cls: List[ConstrainedClassifier[_, HEAD]], it: Int, init: Boolean, lossAugmented: Boolean = false)(implicit headTag: ClassTag[HEAD]) = {
+    train[HEAD](node, cls, it, init, lossAugmented)
   }
 
   @scala.annotation.tailrec
-  def train[HEAD <: AnyRef](node: Node[HEAD], cls: List[ConstrainedClassifier[_, HEAD]], it: Int, init: Boolean)(implicit headTag: ClassTag[HEAD]): Unit = {
+  def train[HEAD <: AnyRef](node: Node[HEAD], cls: List[ConstrainedClassifier[_, HEAD]], it: Int, init: Boolean, lossAugmented: Boolean = false)(implicit headTag: ClassTag[HEAD]): Unit = {
     // forall members in collection of the head (dm.t) do
     logger.info("Training iteration: " + it)
     if (init) ClassifierUtils.InitializeClassifiers(node, cls: _*)
@@ -43,19 +43,24 @@ object JointTrainSparseNetwork {
             if (idx % 5000 == 0)
               logger.info(s"Training: $idx examples inferred.")
 
-            cls.foreach {
-              case classifier: ConstrainedClassifier[_, HEAD] =>
-                val typedClassifier = classifier.asInstanceOf[ConstrainedClassifier[_, HEAD]]
-                val oracle = typedClassifier.onClassifier.getLabeler
+            if (lossAugmented)
+              cls.foreach { cls_i =>
+                cls_i.onClassifier.classifier.setLossFlag()
+                cls_i.onClassifier.classifier.setCandidates(cls_i.getCandidates(h).size * cls.size)
+              }
 
-                typedClassifier.getCandidates(h) foreach {
+            cls.foreach {
+              currentClassifier: ConstrainedClassifier[_, HEAD] =>
+                val oracle = currentClassifier.onClassifier.getLabeler
+                val baseClassifier = currentClassifier.onClassifier.classifier.asInstanceOf[SparseNetworkLearner]
+                currentClassifier.getCandidates(h) foreach {
                   candidate =>
                     {
                       def trainOnce() = {
-                        val result = typedClassifier.classifier.discreteValue(candidate)
+
+                        val result = currentClassifier.classifier.discreteValue(candidate)
                         val trueLabel = oracle.discreteValue(candidate)
-                        val ilearner = typedClassifier.onClassifier.classifier.asInstanceOf[SparseNetworkLearner]
-                        val lLexicon = typedClassifier.onClassifier.getLabelLexicon
+                        val lLexicon = currentClassifier.onClassifier.getLabelLexicon
                         var LTU_actual: Int = 0
                         var LTU_predicted: Int = 0
                         for (i <- 0 until lLexicon.size()) {
@@ -69,26 +74,26 @@ object JointTrainSparseNetwork {
                         // and the LTU of the predicted class should be demoted.
                         if (!result.equals(trueLabel)) //equals("true") && trueLabel.equals("false")   )
                         {
-                          val a = typedClassifier.onClassifier.getExampleArray(candidate)
+                          val a = currentClassifier.onClassifier.getExampleArray(candidate)
                           val a0 = a(0).asInstanceOf[Array[Int]] //exampleFeatures
                           val a1 = a(1).asInstanceOf[Array[Double]] // exampleValues
                           val exampleLabels = a(2).asInstanceOf[Array[Int]]
                           val label = exampleLabels(0)
-                          var N = ilearner.getNetwork.size
+                          var N = baseClassifier.getNetwork.size
 
-                          if (label >= N || ilearner.getNetwork.get(label) == null) {
-                            val conjugateLabels = ilearner.isUsingConjunctiveLabels | ilearner.getLabelLexicon.lookupKey(label).isConjunctive
-                            ilearner.setConjunctiveLabels(conjugateLabels)
+                          if (label >= N || baseClassifier.getNetwork.get(label) == null) {
+                            val conjugateLabels = baseClassifier.isUsingConjunctiveLabels | baseClassifier.getLabelLexicon.lookupKey(label).isConjunctive
+                            baseClassifier.setConjunctiveLabels(conjugateLabels)
 
-                            val ltu: LinearThresholdUnit = ilearner.getBaseLTU
-                            ltu.initialize(ilearner.getNumExamples, ilearner.getNumFeatures)
-                            ilearner.getNetwork.set(label, ltu)
+                            val ltu: LinearThresholdUnit = baseClassifier.getBaseLTU.clone().asInstanceOf[LinearThresholdUnit]
+                            ltu.initialize(baseClassifier.getNumExamples, baseClassifier.getNumFeatures)
+                            baseClassifier.getNetwork.set(label, ltu)
                             N = label + 1
                           }
 
                           // test push
-                          val ltu_actual = ilearner.getLTU(LTU_actual).asInstanceOf[LinearThresholdUnit]
-                          val ltu_predicted = ilearner.getLTU(LTU_predicted).asInstanceOf[LinearThresholdUnit]
+                          val ltu_actual = baseClassifier.getLTU(LTU_actual).asInstanceOf[LinearThresholdUnit]
+                          val ltu_predicted = baseClassifier.getLTU(LTU_predicted).asInstanceOf[LinearThresholdUnit]
 
                           if (ltu_actual != null)
                             ltu_actual.promote(a0, a1, 0.1)
@@ -100,8 +105,13 @@ object JointTrainSparseNetwork {
                       trainOnce()
                     }
                 }
+
             }
           }
+          if (lossAugmented)
+            cls.foreach { cls_i =>
+              cls_i.onClassifier.classifier.unsetLossFlag()
+            }
       }
       train(node, cls, it - 1, false)
     }

saul-core/src/main/scala/edu/illinois/cs/cogcomp/saul/classifier/infer/InitSparseNetwork.scala

@@ -33,7 +33,7 @@ object InitSparseNetwork {
               if (label >= N || iLearner.getNetwork.get(label) == null) {
                 val isConjunctiveLabels = iLearner.isUsingConjunctiveLabels | iLearner.getLabelLexicon.lookupKey(label).isConjunctive
                 iLearner.setConjunctiveLabels(isConjunctiveLabels)
-                val ltu: LinearThresholdUnit = iLearner.getBaseLTU
+                val ltu: LinearThresholdUnit = iLearner.getBaseLTU.clone().asInstanceOf[LinearThresholdUnit]
                 ltu.initialize(iLearner.getNumExamples, iLearner.getNumFeatures)
                 iLearner.getNetwork.set(label, ltu)
               }

saul-core/src/test/scala/edu/illinois/cs/cogcomp/saul/classifier/JoinTrainingTests/IntializeSparseNetwork.scala

@@ -1,3 +1,9 @@
+/** This software is released under the University of Illinois/Research and Academic Use License. See
+  * the LICENSE file in the root folder for details. Copyright (c) 2016
+  *
+  * Developed by: The Cognitive Computations Group, University of Illinois at Urbana-Champaign
+  * http://cogcomp.cs.illinois.edu/
+  */
 package edu.illinois.cs.cogcomp.saul.classifier.JoinTrainingTests
 
 import edu.illinois.cs.cogcomp.infer.ilp.OJalgoHook
@@ -71,7 +77,7 @@ class InitializeSparseNetwork extends FlatSpec with Matchers {
     val wv1After = clNet1.getNetwork.get(0).asInstanceOf[LinearThresholdUnit].getWeightVector
     val wv2After = clNet2.getNetwork.get(0).asInstanceOf[LinearThresholdUnit].getWeightVector
 
-    wv1After.size() should be(5)
+    wv1After.size() should be(6)
     wv2After.size() should be(12)
   }
 

saul-examples/src/main/java/edu/illinois/cs/cogcomp/saulexamples/Badge/BadgeReader.java

@@ -0,0 +1,33 @@
+/** This software is released under the University of Illinois/Research and Academic Use License. See
+  * the LICENSE file in the root folder for details. Copyright (c) 2016
+  *
+  * Developed by: The Cognitive Computations Group, University of Illinois at Urbana-Champaign
+  * http://cogcomp.cs.illinois.edu/
+  */
+package edu.illinois.cs.cogcomp.saulexamples.Badge;
+
+import java.io.BufferedReader;
+import java.io.FileInputStream;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.List;
+
+public class BadgeReader {
+	public List<String> badges;
+	// int currentBadge;
+
+	public BadgeReader(String dataFile) {
+		badges = new ArrayList<String>();
+
+		try {
+			BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(dataFile)));
+
+			String str;
+			while ((str = br.readLine()) != null) {
+				badges.add(str);
+			}
+
+			br.close();
+		}catch (Exception e) {}
+	}
+}

saul-examples/src/main/scala/edu/illinois/cs/cogcomp/saulexamples/Badge/BadgeClassifiers.scala

@@ -0,0 +1,39 @@
+/** This software is released under the University of Illinois/Research and Academic Use License. See
+  * the LICENSE file in the root folder for details. Copyright (c) 2016
+  *
+  * Developed by: The Cognitive Computations Group, University of Illinois at Urbana-Champaign
+  * http://cogcomp.cs.illinois.edu/
+  */
+package edu.illinois.cs.cogcomp.saulexamples.Badge
+
+import edu.illinois.cs.cogcomp.lbjava.learn.{ SparseNetworkLearner, SparsePerceptron }
+
+/** Created by Parisa on 9/13/16.
+  */
+
+object BadgeClassifiers {
+  import BadgeDataModel._
+  import edu.illinois.cs.cogcomp.saul.classifier.Learnable
+  object BadgeClassifier extends Learnable[String](badge) {
+    def label = BadgeLabel
+    override lazy val classifier = new SparsePerceptron()
+    override def feature = using(BadgeFeature1)
+  }
+  object BadgeOppositClassifier extends Learnable[String](badge) {
+    def label = BadgeOppositLabel
+    override lazy val classifier = new SparsePerceptron()
+    override def feature = using(BadgeFeature1)
+  }
+
+  object BadgeClassifierMulti extends Learnable[String](badge) {
+    def label = BadgeLabel
+    override lazy val classifier = new SparseNetworkLearner()
+    override def feature = using(BadgeFeature1)
+  }
+
+  object BadgeOppositClassifierMulti extends Learnable[String](badge) {
+    def label = BadgeOppositLabel
+    override lazy val classifier = new SparseNetworkLearner()
+    override def feature = using(BadgeFeature1)
+  }
+}

saul-examples/src/main/scala/edu/illinois/cs/cogcomp/saulexamples/Badge/BadgeConstraintClassifiers.scala

@@ -0,0 +1,43 @@
+/** This software is released under the University of Illinois/Research and Academic Use License. See
+  * the LICENSE file in the root folder for details. Copyright (c) 2016
+  *
+  * Developed by: The Cognitive Computations Group, University of Illinois at Urbana-Champaign
+  * http://cogcomp.cs.illinois.edu/
+  */
+package edu.illinois.cs.cogcomp.saulexamples.Badge
+
+import edu.illinois.cs.cogcomp.infer.ilp.OJalgoHook
+import edu.illinois.cs.cogcomp.saul.classifier.ConstrainedClassifier
+import edu.illinois.cs.cogcomp.saul.constraint.ConstraintTypeConversion._
+import edu.illinois.cs.cogcomp.saulexamples.Badge.BadgeClassifiers.{ BadgeOppositClassifierMulti, BadgeClassifierMulti, BadgeClassifier, BadgeOppositClassifier }
+
+/** Created by Parisa on 11/1/16.
+  */
+object BadgeConstraintClassifiers {
+
+  val binaryConstraint = ConstrainedClassifier.constraint[String] {
+    x: String =>
+      (BadgeClassifier on x is "negative") ==> (BadgeOppositClassifier on x is "positive")
+  }
+
+  object badgeConstrainedClassifier extends ConstrainedClassifier[String, String](BadgeClassifier) {
+    def subjectTo = binaryConstraint
+    override val solver = new OJalgoHook
+  }
+
+  object oppositBadgeConstrainedClassifier extends ConstrainedClassifier[String, String](BadgeOppositClassifier) {
+    def subjectTo = binaryConstraint
+    override val solver = new OJalgoHook
+  }
+
+  object badgeConstrainedClassifierMulti extends ConstrainedClassifier[String, String](BadgeClassifierMulti) {
+    def subjectTo = binaryConstraint
+    override val solver = new OJalgoHook
+  }
+
+  object oppositBadgeConstrainedClassifierMulti extends ConstrainedClassifier[String, String](BadgeOppositClassifierMulti) {
+    def subjectTo = binaryConstraint
+    override val solver = new OJalgoHook
+  }
+
+}

saul-examples/src/main/scala/edu/illinois/cs/cogcomp/saulexamples/Badge/BadgeDataModel.scala

@@ -0,0 +1,46 @@
+/** This software is released under the University of Illinois/Research and Academic Use License. See
+  * the LICENSE file in the root folder for details. Copyright (c) 2016
+  *
+  * Developed by: The Cognitive Computations Group, University of Illinois at Urbana-Champaign
+  * http://cogcomp.cs.illinois.edu/
+  */
+package edu.illinois.cs.cogcomp.saulexamples.Badge
+
+import edu.illinois.cs.cogcomp.saul.datamodel.DataModel
+
+/** Created by Parisa on 9/13/16.
+  */
+object BadgeDataModel extends DataModel {
+
+  val badge = node[String]
+
+  val BadgeFeature1 = property(badge) {
+    x: String =>
+      {
+        val tokens = x.split(" ")
+        tokens(1).charAt(1).toString
+      }
+  }
+
+  val BadgeLabel = property(badge)("true", "false") {
+    x: String =>
+      {
+        val tokens = x.split(" ")
+        if (tokens(0).equals("+"))
+          "true"
+        else
+          "false"
+      }
+  }
+
+  val BadgeOppositLabel = property(badge)("true", "false") {
+    x: String =>
+      {
+        val tokens = x.split(" ")
+        if (tokens(0).equals("+"))
+          "false"
+        else
+          "true"
+      }
+  }
+}

saul-examples/src/main/scala/edu/illinois/cs/cogcomp/saulexamples/Badge/BagesApp.scala

@@ -0,0 +1,72 @@
+/** This software is released under the University of Illinois/Research and Academic Use License. See
+  * the LICENSE file in the root folder for details. Copyright (c) 2016
+  *
+  * Developed by: The Cognitive Computations Group, University of Illinois at Urbana-Champaign
+  * http://cogcomp.cs.illinois.edu/
+  */
+package edu.illinois.cs.cogcomp.saulexamples.Badge
+
+/** Created by Parisa on 9/13/16.
+  */
+
+import edu.illinois.cs.cogcomp.saul.classifier.{ JointTrain, JointTrainSparseNetwork }
+import edu.illinois.cs.cogcomp.saulexamples.Badge.BadgeClassifiers.{ BadgeOppositClassifier, BadgeClassifier }
+import edu.illinois.cs.cogcomp.saulexamples.Badge.BadgeConstraintClassifiers.{ badgeConstrainedClassifier, badgeConstrainedClassifierMulti, oppositBadgeConstrainedClassifier, oppositBadgeConstrainedClassifierMulti }
+import edu.illinois.cs.cogcomp.saulexamples.Badge.BadgeDataModel._
+
+import scala.collection.JavaConversions._
+object BadgesApp {
+
+  val allNamesTrain = new BadgeReader("data/badges/badges.train").badges
+  val allNamesTest = new BadgeReader("data/badges/badges.test").badges
+
+  badge.populate(allNamesTrain)
+  badge.populate(allNamesTest, false)
+
+  val cls = List(badgeConstrainedClassifierMulti, oppositBadgeConstrainedClassifierMulti)
+
+  object BadgeExperimentType extends Enumeration {
+    val JoinTrainSparsePerceptron, JointTrainSparseNetwork, JointTrainSparseNetworkLossAugmented = Value
+  }
+
+  def main(args: Array[String]): Unit = {
+
+    /** Choose the experiment you're interested in by changing the following line */
+    val testType = BadgeExperimentType.JointTrainSparseNetworkLossAugmented
+
+    testType match {
+      case BadgeExperimentType.JoinTrainSparsePerceptron => JoinTrainSparsePerceptron()
+      case BadgeExperimentType.JointTrainSparseNetwork => JoinTrainSparseNetwork()
+      case BadgeExperimentType.JointTrainSparseNetworkLossAugmented => LossAugmentedJoinTrainSparseNetwork()
+    }
+  }
+
+  /*Test the join training with SparsePerceptron*/
+  def JoinTrainSparsePerceptron(): Unit = {
+    BadgeClassifier.test()
+    BadgeOppositClassifier.test()
+    JointTrain.train(BadgeDataModel.badge, List(badgeConstrainedClassifier, oppositBadgeConstrainedClassifier), 5)
+    oppositBadgeConstrainedClassifier.test()
+    badgeConstrainedClassifier.test()
+    BadgeClassifier.test()
+  }
+
+  /*Test the joinTraining with SparseNetwork*/
+  def JoinTrainSparseNetwork(): Unit = {
+
+    JointTrainSparseNetwork.train(badge, cls, 5, init = true)
+
+    badgeConstrainedClassifierMulti.test()
+    oppositBadgeConstrainedClassifierMulti.test()
+  }
+
+  /*Test the joinTraining with SparseNetwork and doing loss augmented inference*/
+  def LossAugmentedJoinTrainSparseNetwork(): Unit = {
+
+    JointTrainSparseNetwork.train(badge, cls, 5, init = true, lossAugmented = true)
+
+    badgeConstrainedClassifierMulti.test()
+    oppositBadgeConstrainedClassifierMulti.test()
+  }
+
+}

saul-examples/src/test/scala/edu/illinois/cs/cogcomp/saulexamples/nlp/EntityRelation/EntityRelationTests.scala

@@ -92,14 +92,12 @@ class EntityRelationTests extends FlatSpec with Matchers {
 
     ClassifierUtils.TrainClassifiers(1, cls_base)
 
-    PerConstrainedClassifier.onClassifier.classifier.asInstanceOf[SparseNetworkLearner].getNetwork.get(0).asInstanceOf[LinearThresholdUnit].getWeightVector.size() should be(1660)
+    PerConstrainedClassifier.onClassifier.classifier.asInstanceOf[SparseNetworkLearner].getNetwork.get(0).asInstanceOf[LinearThresholdUnit].getWeightVector.size() should be(1654)
 
-    val jointTrainIteration = 1
-    JointTrainSparseNetwork.train[ConllRelation](
-      pairs, cls, jointTrainIteration, init = true
-    )
+    val jointTrainIteration = 2
+    JointTrainSparseNetwork.train[ConllRelation](pairs, cls, jointTrainIteration, init = true)
 
-    PerConstrainedClassifier.onClassifier.classifier.asInstanceOf[SparseNetworkLearner].getNetwork.get(0).asInstanceOf[LinearThresholdUnit].getWeightVector.size() should be(50)
+    PerConstrainedClassifier.onClassifier.classifier.asInstanceOf[SparseNetworkLearner].getNetwork.get(0).asInstanceOf[LinearThresholdUnit].getWeightVector.size() should be(81)
 
   }
 }