Output format: training-output to build supervised models

assembly/src/main/scala/org/clulab/reach/assembly/AssemblyManager.scala

@@ -2,18 +2,20 @@ package org.clulab.reach.assembly
 
 import com.typesafe.scalalogging.LazyLogging
 import org.clulab.reach.assembly.representations._
-import collection.Map
-import collection.immutable
+
+import collection.{Map, immutable, mutable}
 import org.clulab.odin._
 import org.clulab.reach.mentions.{CorefMention, MentionOps}
+
+import scala.collection.mutable.ListBuffer
 // used to differentiate AssemblyModifications from Modifications on mentions
 import org.clulab.reach.mentions
 import java.io.File
 
 
 /**
   * Stores precedence information for two distinct [[EntityEventRepresentation]]
-  * @param before the [[EntityEventRepresentation] that precedes [[PrecedenceRelation.after]]
+  * @param before the [[EntityEventRepresentation]] that precedes [[PrecedenceRelation.after]]
   * @param after the [[EntityEventRepresentation]] that follows [[PrecedenceRelation.before]]
   * @param evidence the mentions that serve as evidence for this precedence relation
   * @param foundBy the name of the Sieve which found this relation
@@ -69,6 +71,7 @@ class AssemblyManager(
 
   import AssemblyManager._
 
+  private val nonAssemblyMentions = new mutable.ListBuffer[Mention]()
   // Because modifications don't feature into the hashcode,
   // a mention's identify at assembly consists of both the mention and its mods (i.e., the "state" of the mention)
   private var mentionStateToID: immutable.Map[MentionState, IDPointer] = m2id.toMap
@@ -90,6 +93,8 @@ class AssemblyManager(
   // initialize to size of LUT 2
   private var nextID: IDPointer = idToEER.size
 
+  def getNonAssemblyMentions:Iterable[Mention] = nonAssemblyMentions.toList
+
   /**
     * Retrieve the set of mentions currently tracked by the manager
     */
@@ -293,12 +298,16 @@ class AssemblyManager(
     * See [[isValidMention]] for details on validation check
     * @param m an Odin Mention
     */
-  def trackMention(m: Mention): Unit = isValidMention(m) match {
-    // do not store Sites, Activations, etc. in LUT 1
-    case true =>
-      // get or create an EntityEventRepresentation
-      val _ = getOrCreateEER(m)
-    case false => ()
+  def trackMention(m: Mention): Unit = if (isValidMention(m)) {
+    m match {
+      case statistic if statistic matches "Statistic" =>
+        nonAssemblyMentions += statistic
+      case _ =>
+        // get or create an EntityEventRepresentation
+        val _ = getOrCreateEER(m)
+    }
+  } else {
+    ()
   }
 
   /**
@@ -572,7 +581,7 @@ class AssemblyManager(
       new SimpleEntity(
         id,
         // TODO: decide whether or not we should use a richer representation for the grounding ID
-        e.nsId,
+        e.nsId(),
         // modifications relevant to assembly
         if (mods.isDefined) modifications ++ mods.get else modifications,
         // source mention
@@ -651,6 +660,59 @@ class AssemblyManager(
     */
   private def createComplex(m: Mention): Complex = createComplexWithID(m)._1
 
+
+  private def createAssociationEventWithID(m: Mention): (Association, IDPointer) = {
+    //
+    // handle dispatch
+    //
+
+    // check for coref
+    val assoc = getResolvedForm(m)
+
+    // get polarity
+    val polarity = getPolarityLabel(assoc)
+
+    // mention should be a Regulation
+    require(assoc matches "Association", "createAssociationEventWithID only handles Associations")
+    // mention's polarity should be either positive or negative
+//    require(polarity == AssemblyManager.positive || polarity == AssemblyManager.negative, "Polarity of Regulation must be positive or negative")
+//    // all controlled args must be simple events
+//    require(assoc.arguments("controlled").forall(_ matches "Event"), "The 'controlled' of any Regulation must be an Event")
+
+//    val controllers: Set[IDPointer] = {
+//      assoc.arguments("controller")
+//        .toSet[Mention]
+//        .map(c => getOrCreateEERwithID(c)._2)
+//    }
+
+    val themes: Set[IDPointer] = {
+      assoc.arguments("theme")
+        .toSet[Mention]
+        .map(c => getOrCreateEERwithID(c)._2)
+    }
+
+    // prepare id
+    val id = getOrCreateID(m)
+
+    // prepare Regulation
+
+    val eer =
+      Association(
+        id,
+        themes,
+        polarity,
+        Some(m),
+        this
+      )
+
+    // update LUTs
+    // use original mention for later lookup
+    updateLUTs(id, m, eer)
+
+    // eer and id pair
+    (eer, id)
+  }
+
   //
   // SimpleEvent creation
   //
@@ -761,7 +823,7 @@ class AssemblyManager(
             for (
               src <- hasSource.arguments(src).toSet[Mention]
             ) yield {
-              val gid = src.toBioMention.nsId
+              val gid = src.toBioMention.nsId()
               representations.Location(gid).asInstanceOf[AssemblyModification]
             }
           // no mods
@@ -796,7 +858,7 @@ class AssemblyManager(
             for (
               d <- hasSource.arguments(dest).toSet[Mention]
             ) yield {
-              val gid = d.toBioMention.nsId
+              val gid = d.toBioMention.nsId()
               representations.Location(gid)
             }
           // no mods
@@ -1145,13 +1207,11 @@ class AssemblyManager(
   private def getOrCreateEER(m: Mention): EER = {
     // ensure this mention should be stored in LUT 1
     require(isValidMention(m), s"mention with the label ${m.label} cannot be tracked by the AssemblyManager")
-    hasMention(m) match {
-      // if an ID already exists, retrieve the associated representation
-      case true =>
-        val id = mentionStateToID(getMentionState(m))
-        idToEER(id)
-      // create new representation
-      case false => createEER(m)
+    if (hasMention(m)) {
+      val id = mentionStateToID(getMentionState(m))
+      idToEER(id)
+    } else {
+      createEER(m)
     }
   }
 
@@ -1161,15 +1221,14 @@ class AssemblyManager(
     * @param m an Odin Mention
     * @return a tuple of ([[EntityEventRepresentation]], [[IDPointer]])
     */
-  private def getOrCreateEERwithID(m: Mention): (EER, IDPointer) = hasMention(m) match {
-    case true =>
-      val id = mentionStateToID(getMentionState(m))
-      val eer = getEER(id)
-      (eer, id)
-    case false =>
-      val eer = createEER(m)
-      val id = eer.uniqueID
-      (eer, id)
+  private def getOrCreateEERwithID(m: Mention): (EER, IDPointer) = if (hasMention(m)) {
+    val id = mentionStateToID(getMentionState(m))
+    val eer = getEER(id)
+    (eer, id)
+  } else {
+    val eer = createEER(m)
+    val id = eer.uniqueID
+    (eer, id)
   }
 
   /**
@@ -1188,6 +1247,7 @@ class AssemblyManager(
       case se if se matches "SimpleEvent" => createSimpleEventWithID(m)
       case regulation if regulation matches "Regulation" => createRegulationWithID(m)
       case activation if activation matches "ActivationEvent" => createActivationWithID(m)
+      case association if association matches "Association" => createAssociationEventWithID(m)
       case other => throw new Exception(s"createEERwithID failed for ${other.label}")
     }
   }
@@ -1758,9 +1818,9 @@ class AssemblyManager(
     s"Mention(label=${m.label}, text='${m.text}', modifications=${bio.modifications}, doc=$docRepr)"
   }
 
-  def summarizeMentionIndex: Unit = println(mentionIndexSummary.sorted.mkString("\n"))
+  def summarizeMentionIndex(): Unit = println(mentionIndexSummary.sorted.mkString("\n"))
 
-  def summarizeEntities: Unit = println(getSimpleEntities.map(_.summarize).toSeq.sorted.mkString("\n"))
+  def summarizeEntities(): Unit = println(getSimpleEntities.map(_.summarize).toSeq.sorted.mkString("\n"))
 
 
   //
@@ -1888,6 +1948,13 @@ object AssemblyManager {
             case event if event matches "Event" => isValidMention(event)
           }
 
+      // Assiciations must have two theme arguments
+      case association if association matches "Association" =>
+        (association.arguments contains "theme") && (association.arguments("theme").size == 2)
+
+      case significance if significance matches "Significance" =>
+        (significance.arguments contains "kind") && (significance.arguments contains "value")
+
       // assume invalid otherwise
       case _ => false
     }

assembly/src/main/scala/org/clulab/reach/assembly/export/AssemblyExporter.scala

@@ -26,7 +26,7 @@ class AssemblyExporter(val manager: AssemblyManager) extends LazyLogging {
   val ignoreMods = false
 
   // distinct EntityEventRepresentations
-  val distinctEERS = manager.distinctEERs
+  val distinctEERS: Set[EER] = manager.distinctEERs
 
   // LUT for retrieving IDs to distinct EERs
   // TODO: A better version of this should probably belong to the manager
@@ -121,9 +121,19 @@ class AssemblyExporter(val manager: AssemblyManager) extends LazyLogging {
     case se: SimpleEvent =>
       se.input.values.flatten.map(m => createInput(m, mods)).mkString(", ")
 
+    case assoc: Association =>
+      assoc.controlled.map{
+        // get IDs of any events
+        case event: Event => EERLUT.getOrElse(event.equivalenceHash(ignoreMods = ignoreMods), reportError(assoc, event))
+        // represent entities directly
+        case entity: Entity =>
+          createInput(entity, s"$mods")
+      }.mkString(", ")
+
+
     // inputs to an activation are entities
     case act: Activation =>
-      act.controlled.map {
+      act.controller.map {
         // get IDs of any events
         case event: Event => EERLUT.getOrElse(event.equivalenceHash(ignoreMods = ignoreMods), reportError(act, event))
         // represent entities directly
@@ -153,6 +163,15 @@ class AssemblyExporter(val manager: AssemblyManager) extends LazyLogging {
         case other => createInput(other, mods)
       }.mkString(", ")
 
+    case assoc: Association =>
+      assoc.controlled.map{
+        // get IDs of any events
+        case event: Event => EERLUT.getOrElse(event.equivalenceHash(ignoreMods = ignoreMods), reportError(assoc, event))
+        // represent entities directly
+        case entity: Entity =>
+          createInput(entity, s"$mods")
+      }.mkString(", ")
+
     // positive activations produce an activated output entity
     case posact: Activation if posact.polarity == AssemblyManager.positive =>
       posact.controlled.map(c => createInput(c, s"$mods.a")).mkString(", ")
@@ -238,10 +257,43 @@ class AssemblyExporter(val manager: AssemblyManager) extends LazyLogging {
           precededBy(event),
           event.negated,
           event.evidence,
-          event
+          Some(event)
         )
       }
-    rows.toSeq
+
+    val statisticRows: Set[AssemblyRow] = (manager.getNonAssemblyMentions collect {
+      case significance if significance matches "Significance" =>
+        AssemblyRow(
+          significance.arguments("kind").head.text,
+          significance.arguments("value").head.text,
+          NONE,
+          NONE,
+          NONE,
+          NONE,
+          significance.label,
+          Set.empty,
+          negated = false,
+          Set(significance),
+          None
+        )
+
+      case interval if interval matches "Confidence_interval" =>
+        AssemblyRow(
+          interval.arguments("start").head.text,
+          interval.arguments("end").head.text,
+          NONE,
+          NONE,
+          interval.arguments("degree").head.text,
+          NONE,
+          interval.label,
+          Set.empty,
+          negated = false,
+          Set(interval),
+          None
+        )
+    }).toSet
+
+    rows.toSeq ++ statisticRows.toSeq
   }
 
   /** for debugging purposes */
@@ -293,6 +345,7 @@ object AssemblyExporter {
   val ENTITY = "entity"
   val REGULATION = "Regulation"
   val ACTIVATION = "Activation"
+  val ASSOCIATION = "Association"
   val TRANSLOCATION = "Translocation"
 
   // context types
@@ -388,6 +441,7 @@ object AssemblyExporter {
   def getEventLabel(e: EntityEventRepresentation): String = e match {
     case reg: Regulation => s"$REGULATION (${reg.polarity})"
     case act: Activation => s"$ACTIVATION (${act.polarity})"
+    case assoc: Association => s"$ASSOCIATION (${assoc.polarity})"
     case se: SimpleEvent => se.label
     case ptm: SimpleEntity if ptm.modifications.exists(_.isInstanceOf[representations.PTM]) =>
       ptm.modifications.find(_.isInstanceOf[representations.PTM]).get.asInstanceOf[representations.PTM].label