[DUCK] 修复“去年上半年”的“上半年”结合错误 (#257)

Author: du00cs

duckling-fork-chinese/core/src/main/scala/com/xiaomi/duckling/dimension/time/Rules.scala

@@ -276,7 +276,7 @@ trait Rules extends DimRules {
     name = "recent/last/next <duration>",
     pattern = List(RecentPattern.regex, or(isNotLatentDuration, isFuzzyNotLatentDuration).predicate),
     prod = tokens {
-      case Token(_, GroupMatch(_ :: g1 :: g2 :: _)) :: Token(Duration, DurationData(v, g, _, fuzzy, _)) :: _ =>
+      case Token(_, GroupMatch(_ :: g1 :: g2 :: _)) :: Token(Duration, DurationData(v, g, _, fuzzy, half, _)) :: _ =>
         val s = if (StringUtils.isBlank(g1)) g2 else g1
         // 月必须是x个月
         s match {
@@ -291,7 +291,7 @@ trait Rules extends DimRules {
                 cycleN(notImmediate = false, Day, 30)
               }
               // = 1 已经在 this <cycle> 中定义过了
-              else if (s == "下" && (g == Day || v == 1)) None
+              else if (s == "下" && (g == Day || v == 1 || half)) None
               else {
                 val td1 = cycleN(notImmediate = false, g, v)
                 g match {
@@ -311,7 +311,7 @@ trait Rules extends DimRules {
               cycleN(notImmediate = false, Day, 7 * v).map(t => tt(t.at(Hint.Recent)))
             } else tt(cycleNth(g, 0))
           case "上" | "前" | "之前" | "往前"  | "向前" | "过去" | "过去" =>
-            if (s == "上" && (g == Day || g == Year)) None
+            if (s == "上" && (g == Day || g == Year || half)) None
             else if (s == "过去" && fuzzy) None
             else if (v > 1) tt(cycleN(notImmediate = true, g, -v).at(Hint.Recent))
             else tt(cycleNth(g, -1).at(Hint.Recent))
@@ -327,7 +327,7 @@ trait Rules extends DimRules {
     name = "n <cycle> next/last 1: <duration> 之后",
     pattern = List(isNotLatentDuration.predicate, "((之|以)?(后|前))|过后".regex),
     prod = optTokens {
-      case (options: Options, Token(Duration, DurationData(v, grain, false, _, _)) :: Token(_, GroupMatch(s :: _)) :: _) =>
+      case (options: Options, Token(Duration, DurationData(v, grain, false, _, _, _)) :: Token(_, GroupMatch(s :: _)) :: _) =>
         val offset = if (s.endsWith("后")) v else -v
         val roundGrain = if (options.timeOptions.inheritGrainOfDuration) grain else NoGrain
         tt(finalRule(cycleNth(grain, offset, roundGrain)))
@@ -341,7 +341,7 @@ trait Rules extends DimRules {
     name = "n <cycle> next/last: 过 <duration>",
     pattern = List("过".regex, isNotLatentDuration.predicate),
     prod = optTokens {
-      case (options: Options, _ :: Token(Duration, DurationData(v, grain, _, _, _)) :: _ ) =>
+      case (options: Options, _ :: Token(Duration, DurationData(v, grain, _, _, _, _)) :: _ ) =>
         val roundGrain = if (options.timeOptions.inheritGrainOfDuration) grain else NoGrain
         tt(finalRule(cycleNth(grain, v, roundGrain)))
     }
@@ -354,7 +354,7 @@ trait Rules extends DimRules {
     name = "n <cycle> next/last 3:过 <duration> 之后",
     pattern = List("过".regex, isNotLatentDuration.predicate, "之?(后|前)".regex),
     prod = optTokens {
-      case (options: Options, _ :: Token(Duration, DurationData(v, grain, _, _, _)) :: _ ) =>
+      case (options: Options, _ :: Token(Duration, DurationData(v, grain, _, _, _, _)) :: _ ) =>
         val roundGrain = if (options.timeOptions.inheritGrainOfDuration) grain else NoGrain
         tt(finalRule(cycleNth(grain, v, roundGrain)))
     }
@@ -367,7 +367,7 @@ trait Rules extends DimRules {
     name = "<duration> before/after <time>",
     pattern = List(isNotLatentDuration.predicate, "之?(前|后)的?".regex, isNotLatent.predicate),
     prod = tokens {
-      case Token(Duration, DurationData(v, g, _, _, _)) :: Token(_, GroupMatch(_ :: s :: _)) ::
+      case Token(Duration, DurationData(v, g, _, _, _, _)) :: Token(_, GroupMatch(_ :: s :: _)) ::
         Token(Time, td: TimeData) :: _ =>
         if (g > td.timeGrain) {
           val sign = if (s == "前") -1 else 1
@@ -407,7 +407,7 @@ trait Rules extends DimRules {
     name = "<time> before/after 2",
     pattern = List(and(isADayOfMonth, isNotLatent).predicate, "的".regex, isNotLatentDuration.predicate, "[之以]?([前后])".regex),
     prod = tokens {
-      case Token(Time, td: TimeData) :: _ :: Token(Duration, DurationData(v, g, _, _, _)) :: Token(_, GroupMatch(_ :: d :: _)) :: _ =>
+      case Token(Time, td: TimeData) :: _ :: Token(Duration, DurationData(v, g, _, _, _, _)) :: Token(_, GroupMatch(_ :: d :: _)) :: _ =>
         val dv = if (d == "前") -v else v
         val dg = if (g <= Day) g else Day
 
@@ -420,7 +420,7 @@ trait Rules extends DimRules {
     name = "<time> before/after 3",
     pattern = List(and(isADayOfMonth, isNotLatent).predicate, isNotLatentDuration.predicate, "[之以]?([前后])".regex),
     prod = tokens {
-      case Token(Time, td: TimeData) :: Token(Duration, DurationData(v, g, _, _, _)) :: Token(_, GroupMatch(_ :: d :: _)) :: _ =>
+      case Token(Time, td: TimeData) :: Token(Duration, DurationData(v, g, _, _, _, _)) :: Token(_, GroupMatch(_ :: d :: _)) :: _ =>
         val dv = if (d == "前") -v else v
         val dg = if (g <= Day) g else Day
 
@@ -433,7 +433,7 @@ trait Rules extends DimRules {
     name = "<time> after duration",
     pattern = List(isADayOfMonth.predicate, "(再?过|往后(数|推)|后面?的第?)".regex, isNotLatentDuration.predicate),
     prod = tokens {
-      case Token(Time, td: TimeData) :: _ :: Token(Duration, DurationData(v, g, _, _, _)) :: _ =>
+      case Token(Time, td: TimeData) :: _ :: Token(Duration, DurationData(v, g, _, _, _, _)) :: _ =>
         val dv = v
         val dg = if (g <= Day) g else Day
 
@@ -446,7 +446,7 @@ trait Rules extends DimRules {
     name = "<time> before duration",
     pattern = List(isADayOfMonth.predicate, "(往前(数|推)|前面?的第?)".regex, isNotLatentDuration.predicate),
     prod = tokens {
-      case Token(Time, td: TimeData) :: _ :: Token(Duration, DurationData(v, g, _, _, _)) :: _ =>
+      case Token(Time, td: TimeData) :: _ :: Token(Duration, DurationData(v, g, _, _, _, _)) :: _ =>
         val dv = -v
         val dg = if (g <= Day) g else Day
 
@@ -513,7 +513,7 @@ trait Rules extends DimRules {
     name = "in a <duration>",
     pattern = List(isNotLatentDuration.predicate, "[之以]?内".regex),
     prod = tokens {
-      case Token(Duration, DurationData(value, grain, _, _, _)) :: _ =>
+      case Token(Duration, DurationData(value, grain, _, _, _, _)) :: _ =>
         val (g, v) = grain match {
           case Month => (Day, value * 30)
           case Week => (Day, value * 7)
@@ -598,7 +598,7 @@ trait Rules extends DimRules {
       List(isHint(RecentNominal).predicate, "(往|向|之)?(前|后)的?".regex, isNotLatentDuration.predicate),
     prod = optTokens {
       case (options, Token(_, td1: TimeData) :: Token(_, GroupMatch(_ :: s :: _)) ::
-        Token(_, DurationData(value, grain, latent, _, _)) :: _)
+        Token(_, DurationData(value, grain, latent, _, _, _)) :: _)
         if options.timeOptions.sequence && td1.timeGrain == grain =>
         val sign = if (s == "前") -1 else 1
         val td2 = cycleN(notImmediate = false, grain, sign * value)

duckling-fork-chinese/core/src/main/scala/com/xiaomi/duckling/dimension/time/date/Rules.scala

@@ -257,7 +257,7 @@ trait Rules extends DimRules {
     name = "date - <ordinal> <quarter>",
     pattern = List("第".regex, isAQuarterOfYear.predicate),
     prod = {
-      case (options, _ :: Token(Duration, DurationData(value, _, _, _, _)) :: _) =>
+      case (options, _ :: Token(Duration, DurationData(value, _, _, _, _, _)) :: _) =>
         for (td <- interval(Closed, month(3 * value - 2), month(3 * value), options.timeOptions.beforeEndOfInterval)) yield {
           Token(Date, td.copy(reset = (Grain.resetTo(Quarter), 0)))
         }

duckling-fork-chinese/core/src/main/scala/com/xiaomi/duckling/dimension/time/duration/Duration.scala

@@ -41,7 +41,8 @@ case object Duration extends Dimension with Rules {
   * @param latent 是否是潜在时间
   * @param fuzzy  是否是模糊时间（几天）
   */
-case class DurationData(value: Int, grain: Grain, latent: Boolean = false, fuzzy: Boolean = false, override val schema: Option[String] = None)
+case class DurationData(value: Int, grain: Grain, latent: Boolean = false, fuzzy: Boolean = false, half: Boolean = false,
+                        override val schema: Option[String] = None)
     extends ResolvedValue
     with Resolvable {
 

duckling-fork-chinese/core/src/main/scala/com/xiaomi/duckling/dimension/time/duration/Rules.scala

@@ -149,7 +149,7 @@ trait Rules extends DimRules {
     pattern = List("半个?".regex, isDimension(TimeGrain).predicate),
     prod = tokens {
       case _ :: Token(TimeGrain, GrainData(grain, _, _)) :: _ =>
-        for (d <- timesOneAndAHalf(grain, 0)) yield Token(Duration, d)
+        for (d <- timesOneAndAHalf(grain, 0)) yield Token(Duration, d.copy(half = true))
     }
   )
 
@@ -187,7 +187,7 @@ trait Rules extends DimRules {
     pattern =
       List(isDimension(Duration).predicate, isDimension(Duration).predicate),
     prod = tokens {
-      case Token(_, b@DurationData(v, g, _, _, _)) :: Token(_, a@DurationData(_, dg, _, _, _)) :: _ if g > dg =>
+      case Token(_, b@DurationData(v, g, _, _, _, _)) :: Token(_, a@DurationData(_, dg, _, _, _, _)) :: _ if g > dg =>
         // ❌ 两年三月
         // ✅ 一分三十秒
         if (!b.latent && g != Month && (!a.latent || dg != Hour) || (b.latent && g == Minute)) Token(Duration, b + a)
@@ -207,7 +207,7 @@ trait Rules extends DimRules {
       isNotLatentDuration.predicate
     ),
     prod = tokens {
-      case t1 :: Token(TimeGrain, GrainData(g, _, _)) :: _ :: Token(_, dd@DurationData(_, dg, _, _, _)) :: _
+      case t1 :: Token(TimeGrain, GrainData(g, _, _)) :: _ :: Token(_, dd@DurationData(_, dg, _, _, _, _)) :: _
         if g > dg && g != Month =>
         for (i <- getIntValue(t1)) yield Token(Duration, DurationData(i.toInt, g, schema = durationSchema(i.toInt.toString, g)) + dd)
     }

duckling-fork-chinese/core/src/main/scala/com/xiaomi/duckling/dimension/time/duration/package.scala

@@ -64,11 +64,11 @@ package object duration {
   }
 
   def isNotLatentDuration: Predicate = {
-    case Token(Duration, DurationData(_, _, latent, _, _)) => !latent
+    case Token(Duration, DurationData(_, _, latent, _, _, _)) => !latent
   }
 
   def isFuzzyNotLatentDuration: Predicate = {
-    case Token(Duration, DurationData(_, _, _, fuzzy, _)) => fuzzy
+    case Token(Duration, DurationData(_, _, _, fuzzy, _, _)) => fuzzy
   }
 
   def isNotLatentGrain: Predicate = {

duckling-fork-chinese/core/src/main/scala/com/xiaomi/duckling/dimension/time/predicates.scala

@@ -249,7 +249,7 @@ object predicates {
   }
 
   val isAQuarterOfYear: Predicate = {
-    case Token(Duration, DurationData(value, grain, _, _, _)) =>
+    case Token(Duration, DurationData(value, grain, _, _, _, _)) =>
       grain == Quarter && value >= 1 && value <= 4
   }
 
@@ -302,7 +302,7 @@ object predicates {
   }
 
   val isDurationAmountGt1: Predicate = {
-    case Token(Duration, DurationData(value, _, _, _, _)) => value > 1
+    case Token(Duration, DurationData(value, _, _, _, _, _)) => value > 1
   }
 
   val isGrainGeDay: Predicate = {

duckling-fork-chinese/learning/src/main/scala/com/xiaomi/duckling/dimension/time/Examples.scala

@@ -126,6 +126,14 @@ object Examples extends DimExamples {
       ),
       List("上半年")
     ),
+    (
+      localDateTimeInterval(
+        LocalDateTime.of(2012, 1, 1, 0, 0, 0),
+        LocalDateTime.of(2012, 7, 1, 0, 0, 0),
+        Month
+      ),
+      List("去年上半年")
+    ),
     (
         localDateTimeInterval(
           LocalDateTime.of(2014, 2, 4, 0, 0, 0),

duckling-fork-chinese/learning/src/main/scala/com/xiaomi/duckling/dimension/time/duration/Examples.scala

@@ -36,15 +36,16 @@ object Examples extends DimExamples {
     (DurationData(3, Quarter, schema = Some("P3Q")), List("3个季度")),
     (DurationData(2, Year, schema = Some("P2Y")), List("两年", "2年")),
     (DurationData(2000, Year, schema = Some("P2000Y")), List("两千年")),
-    (DurationData(30, Minute, schema = Some("PT0H30M")), List("半小时")),
+    (DurationData(30, Minute, schema = Some("PT0H30M"), half = true), List("半小时")),
     (DurationData(30, Minute, schema = Some("PT30M")), List("0.5小时")),
     (DurationData(90, Minute, schema = Some("PT90M")), List("1.5小时", "1.50小时", "一点五小时", "一点五零小时")),
-    (DurationData(30, Minute, schema = Some("PT30M")), List("30分钟", "半个钟头")),
-    (DurationData(12, Hour, schema = Some("P0DT12H")), List("半天")),
+    (DurationData(30, Minute, schema = Some("PT30M")), List("30分钟")),
+    (DurationData(30, Minute, schema = Some("PT30M"), half = true), List("半个钟头")),
+    (DurationData(12, Hour, schema = Some("P0DT12H"), half = true), List("半天")),
     (DurationData(90, Minute, schema = Some("PT1H30M")), List("一个半小时", "一小时30分钟", "一个小时30分钟")),
     (DurationData(2, Hour, schema = Some("PT2H")), List("两个小时整")),
     (DurationData(45, Day, schema = Some("P1M15D")), List("一个半月")),
-    (DurationData(15, Day, schema = Some("P0M15D")), List("半个月")),
+    (DurationData(15, Day, schema = Some("P0M15D"), half = true), List("半个月")),
     (DurationData(27, Month, schema = Some("P2Y3M")), List("两年零三个月","两年外加三个月", "两年加上三个月", "两年加三个月", "两年三个月")),
     (DurationData(31719604, Second, schema = Some("P1Y2DT3H4S")), List("1年两天3小时四秒"))
   )

duckling-fork-chinese/learning/src/main/scala/com/xiaomi/duckling/task/NaiveBayesDebug.scala

@@ -18,7 +18,6 @@ package com.xiaomi.duckling.task
 
 import org.apache.commons.lang3.time.StopWatch
 import org.json4s.jackson.Serialization.write
-
 import com.xiaomi.duckling.Api
 import com.xiaomi.duckling.Api.formatToken
 import com.xiaomi.duckling.JsonSerde._
@@ -27,6 +26,8 @@ import com.xiaomi.duckling.dimension.FullDimensions
 import com.xiaomi.duckling.ranking.Ranker
 import com.xiaomi.duckling.ranking.Testing.testContext
 
+import java.time.ZonedDateTime
+
 object NaiveBayesDebug {
   private val context = testContext // .copy(referenceTime = ZonedDateTime.now())
 
@@ -49,7 +50,7 @@ object NaiveBayesDebug {
     val targets = FullDimensions.convert(dim.split(","))
     val options = Options(targets = targets, withLatent = false, full = true)
     options.rankOptions.setRanker(Some(Ranker.NaiveBayes))
-    options.rankOptions.setWinnerOnly(true)
+    options.rankOptions.setWinnerOnly(false)
     options.rankOptions.setCombinationRank(false)
     options.rankOptions.setRangeRankAhead(false)
     options.timeOptions.setResetTimeOfDay(false)

duckling-fork-chinese/server/src/main/scala/com/xiaomi/duckling/TokenVisualization.scala

@@ -76,7 +76,7 @@ object TokenVisualization {
           case SimpleValue(instant) => instant.grain.name()
           case _ => ""
         }
-      case DurationData(_, grain, _, _, _) => grain.name()
+      case DurationData(_, grain, _, _, _, _) => grain.name()
       case _ => ""
     }
     val node = answer.token.node