!7

static Guesser best;

static double bestScore;

sS key = "verb";

concept Sentence {

  S text;

  SS data;

  S get(S s) { ret data.get(s); }

  S subject() { ret get("subject"); }

  S verb() { ret get(key); }

}

sclass Input {

  L<S> tok;

  IntRange subject;

  *() {}

  *(L<S> *tok, IntRange *subject) {}

}

Input > Example {

  new L<IntRange> verbs;

  *() {}

  *(L<S> *tok, IntRange *subject, L<IntRange> *verbs) {}

  toString {

    ret quote(joinWithSpaces(tok)) + " => " + map(verbs, func(IntRange r) { joinWithSpaces(subList(tok, r.start, r.end)) });

  }

}

abstract sclass GuesserBase {

  void learn(L<Example> material) {

    for (Example e : material) learn(e);

  }

  void learn(Example e) {}

}

abstract sclass Guesser extends GuesserBase {

  abstract L<IntRange> getVerbTokens(Input input);

}

Guesser > GWordAfterSubject {

  L<IntRange> getVerbTokens(Input input) {

    IntRange r = input.subject;

    ret r == null ? null : ll(intRange(r.end, r.end+1));

  }

}

p {

  loadConceptsFrom(#1008692);

  L<Example> material = learningMaterial();

  pnlStruct(material);

  // This yields the empty learner

  Pair<Guesser, Double> p = bestLearner(material, 

    ll(new GWordAfterSubject),

    50, 3, true);

  // Now we train it with all data for in-program use

  if (p.a != null) p.a.learn(material);

  // Print and store

  print("Best learner: " + formatDouble(p.b, 1) + "% - " + struct(p.a));

  best = p.a;

  bestScore = p.b;

}

sbool printDetails, printSuccesses;

static double checkGuesser(L<Example> testMaterial, Guesser g) {

  print();

  int score = 0, n = 0;

  for (final Example e : testMaterial) {

    L<IntRange> r = cast pcall(g, "getVerbTokens", e.tok);

    bool ok = eq(r, e.verbs);

    if (ok) ++score;

    ++n;

    if (printDetails || ok && printSuccesses)

      if (ok)

        print("OK " + e);

      else

        print("FAIL " + (r == null ? "-" : map(r, func(IntRange r) { joinWithSpaces(subList(e.tok, r)) })) + " for " + e);

  }

  printScore(shortClassName(g), score, n);

  ret ratioToPercent(score, n);

}

static double checkGuesserAfterRandomizedPartialLearn(L<Example> testMaterial, Guesser g, double percentToLearn, bool hardMode) {

  Pair<L<Example>> p = getRandomPercent2(testMaterial, percentToLearn);

  g.learn(p.a);

  ret checkGuesser(hardMode ? p.b : testMaterial, g);

}

// best learner with randomized x% training material

// returns guesser, percentage solved

// hardMode = only count scores on untrained examples

static Pair<Guesser, Double> bestLearner(final L<Example> material, L<? extends Guesser> guessers, final double percent, int repetitions, final bool hardMode) {

  new Best<Guesser> best;

  for (final Guesser g : guessers)

    best.put(g, repeatAndAdd_double(repetitions, func {

      checkGuesserAfterRandomizedPartialLearn(material, cloneObject(g), percent, hardMode)

    })/repetitions);

  ret best.pair();

}

static L<Example> learningMaterial() {

  L<Example> out = new L;

  for (Sentence s) {

    if (s.verb() == null) continue;

    L<IntRange> r = ai_parseVerbAction(s.verb());

    if (r != null) {

      L<S> tok = nlTok5(s.text);

      IntRange subject = ai_parseSubjectAction(s.subject());

      subject = charRangeToCodeTokens(tok, subject);

      r = charRangeToCodeTokens(tok, r);

      tok = codeTokens(tok);

      out.add(Example(tok, subject, r));

    }

  }

  ret out;

}

// to be called from applications - works on character level

static void callGuesser(Guesser g, S sentence, SS data) {

  L<S> tok = nlTok5(sentence);

  L<IntRange> r = g.getVerbTokens(new Input(codeTokens(tok),

    charRangeToCodeTokens(tok, ai_parseAction(data.get("subject")))));

  if (r == null) ret;

  data.put(key, ai_renderAction(sentence, codeTokenRangeToChars(tok, first/*XX*/(r))));

}