public static List <Solution> DoIncremental(List <Literal> obs, Knowledgebase kb, int maxdepth, int n, int w, int b, bool sk)
{
var iteration = 1; // count for skolem constants
var window_start = 0;
var window_end = Math.Min(w * iteration, obs.Count);
var previous = new List <Solution>();
// first, interpret the first window as normal
var res = Etcetera.NBest(obs.GetRange(window_start, window_end - window_start), kb, maxdepth, b, false);
var pre = "$" + iteration.ToString() + ":";
foreach (Solution s in res)
{
previous.Add(skolemize_with_prefix(s, pre));
}
// then iterate through remaining windows
while (window_end < obs.Count) // some remain
{
iteration += 1; //advance
window_start = window_end;
window_end = Math.Min(w * iteration, obs.Count);
res = ContextualEtcAbduction(obs.GetRange(0, window_end), obs.GetRange(window_start, window_end - window_start), kb, previous, maxdepth, b, iteration);
previous = res;
}
if (previous.Count > n) // too many results
{
previous.RemoveRange(n, previous.Count - n); // truncate excess
}
return(previous);
}
public static List<Solution> DoAbduction(List<Literal> obs, Knowledgebase kb, int maxdepth, bool sk)
{
var list_of_lists = new List<List<Solution>>();
foreach (Literal c in obs)
{
var remaining = new List<Literal>() { c };
list_of_lists.Add(AndOrLeaflists(remaining, kb, maxdepth, new List<Literal>(), new List<Literal>()));
}
var combiner = new Combiner(list_of_lists);
var res = new List<Solution>();
foreach (Solution s in combiner)
{
foreach (Solution c in Crunch(s))
{
if (sk)
{
res.Add(skolemize(c));
}
else
{
res.Add(c);
}
}
}
return res.Distinct().ToList();
}
public static List <Solution> DoEtcAbduction(List <Literal> obs, Knowledgebase kb, int maxdepth, bool sk)
{
var solutions = Abduction.DoAbduction(obs, kb, maxdepth, sk);
solutions.Sort((x, y) => JointLnProbability(y).CompareTo(JointLnProbability(x))); // reverse
return(solutions);
}
// Pronoun classes define which pronouns an entity should use
// static HashSet<string> PronounClasses = new HashSet<string>{
// "Masculine", // he, him, his, his, himself
// "Feminine", // she, her, her, hers, herself
// "Neuter", // it, it, its, its, itself
// "Plural" // they, them, their, theirs, themselves
// };
// Text predicates are used in Text Knowledge Bases to direct text generation
// static HashSet<string> TextPredicates = new HashSet<string>{
// "proper_noun", // e.g. (proper_noun PERSON1 "Samantha")
// "pronouns", // e.g. (pronouns PERSON1 Feminine)
// "common_noun", // e.g. (common_noun PERSON1 "accountant")
// "text", // e.g. (text Subject ?x "paid the fare to" Object ?y)
// "texta", // e.g. (texta Subject ?x "asked" Object ?y "to pay the fare")
// "textc", // e.g. (textc Subject ?x "paid the fare")
// };
// Base class constructor is tied to specific knowledge base and temlate axioms
public TextGenerator(Knowledgebase kb, Knowledgebase tkb, List <Literal> tobs)
{
this.Kb = kb;
this.Tkb = tkb;
this.ProperNouns = new Dictionary <String, List <String> >();
this.Pronouns = new Dictionary <String, String>();
this.CommonNouns = new Dictionary <String, List <String> >();
foreach (Literal tob in tobs)
{
if (tob.Predicate == "proper_noun")
{
String key = tob.Terms[0].Text;
List <String> value = tob.Terms.Skip(1).Select(t => t.Text).ToList(); // terms, not strings.
this.ProperNouns.Add(key, value);
}
if (tob.Predicate == "pronouns")
{
String key = tob.Terms[0].Text;
String value = tob.Terms[1].Text;
this.Pronouns.Add(key, value);
}
if (tob.Predicate == "common_noun")
{
String key = tob.Terms[0].Text;
List <String> value = tob.Terms.Skip(1).Select(t => t.Text).ToList(); // terms, not strings.
this.CommonNouns.Add(key, value);
}
}
}
public static List <Solution> incremental_alternative(List <Literal> obs, Knowledgebase kb, int maxdepth, int n, int w, int b, bool sk)
{
var rt = new Realtime(kb, maxdepth, w, b);
foreach (Literal ob in obs)
{
rt.Observe(ob);
}
return(rt.FinalSolutions());
}
public static List <Entailment> Entailments(Knowledgebase kb, List <Literal> assumptions)
{
var stack = new Stack <Literal>(assumptions);
var productions = Production.FromKb(kb);
var entailed = new List <Entailment>();
while (stack.Count > 0)
{
var current = stack.Pop();
var new_productions = new List <Production>();
foreach (Production prod in productions)
{
for (int i = 0; i < prod.Antecedents.Count; i++)
{
var ant = prod.Antecedents[i];
var theta = Unify.unify(current, ant);
if (theta != null)
{
var new_consequent = prod.Consequent.Subst(theta);
var new_triggers = new List <Literal>(prod.Triggers); // deep!
new_triggers.Add(current);
if (prod.Antecedents.Count == 1) // last one
{
var new_entailment = new Entailment();
new_entailment.Entailed = new_consequent;
new_entailment.Triggers = new_triggers;
entailed.Add(new_entailment);
stack.Push(new_consequent);
}
else
{
var new_antecedents = new List <Literal>();
for (int j = 0; j < prod.Antecedents.Count; j++)
{
if (i != j) // skip matching antecedent.
{
new_antecedents.Add(prod.Antecedents[j].Subst(theta));
}
}
var new_production = new Production();
new_production.Antecedents = new_antecedents;
new_production.Consequent = new_consequent;
new_production.Triggers = new_triggers;
new_productions.Add(new_production);
}
}
}
}
foreach (Production p in new_productions)
{
productions.Add(p);
}
}
return(entailed);
}
public Realtime(Knowledgebase kb, int depth, int window, int beam)
{
this.knowledgebase = kb;
this.observables = new List <Literal>();
this.contexts = new List <Solution>();
this.current = 0;
this.cached = 0;
this.solutions = new List <Solution>();
this.depth = depth;
this.window = window;
this.beam = beam;
}
public static List <Production> FromKb(Knowledgebase kb)
{
var res = new List <Production>();
foreach (DefiniteClause c in kb.Axioms)
{
var one = new Production();
one.Antecedents = c.Antecedents;
one.Consequent = c.Consequent;
one.Triggers = new List <Literal>();
res.Add(one);
}
return(res);
}
private static List <List <Literal> > ContextualAndOrLeaflists(List <Literal> remaining, Knowledgebase kb, int depth, List <Literal> context, List <Literal> antecedents, List <Literal> assumptions)
{
if (depth == 0 && antecedents.Count > 0) // fail with empty list (!)
{
return(new List <Solution>());
}
else if (remaining.Count == 0) // done with this level
{
if (antecedents.Count == 0) // found one
{
return(new List <Solution>()
{
assumptions
}); // list of lists
}
else
{
return(ContextualAndOrLeaflists(antecedents, kb, depth - 1, context, new List <Literal>(), assumptions));
}
}
else // more to go on this level
{
var literal = remaining[0]; // pop pt 1
remaining.RemoveAt(0); // pop pt 2
var predicate = literal.Predicate;
if (!kb.IndexByConsequent.ContainsKey(predicate))
{
assumptions.Add(literal); // shift literal to assumptions
return(ContextualAndOrLeaflists(remaining, kb, depth, context, antecedents, assumptions));
}
else
{
var res = new List <Solution>();
var rules = kb.IndexByConsequent[predicate];
foreach (DefiniteClause rule in rules)
{
var consequent = rule.Consequent;
var theta = unify(literal, consequent);
if (theta != null) // unifies
{
if (depth == 0) // no depth for revision
{
return(new List <Solution>()); // (empty)
}
else
{
var new_remaining = new List <Literal>();
foreach (Literal c in remaining)
{
new_remaining.Add(c.Subst(theta));
}
var new_antecedents = new List <Literal>();
foreach (Literal c in rule.Antecedents)
{
new_antecedents.Add(c.Subst(theta));
}
new_antecedents = standardize(new_antecedents);
foreach (Literal c in antecedents)
{
new_antecedents.Add(c.Subst(theta));
}
var new_assumptions = new List <Literal>();
foreach (Literal c in assumptions)
{
new_assumptions.Add(c.Subst(theta)); // !!!! BUG
}
res.AddRange(ContextualAndOrLeaflists(new_remaining, kb, depth, context, new_antecedents, new_assumptions));
}
}
}
foreach (Literal context_literal in context)
{
var theta = unify(literal, context_literal);
if (theta != null) // unifies
{
var new_remaining = new List <Literal>();
foreach (Literal c in remaining)
{
new_remaining.Add(c.Subst(theta));
}
var new_antecedents = new List <Literal>();
foreach (Literal c in antecedents)
{
new_antecedents.Add(c.Subst(theta));
}
var new_assumptions = new List <Literal>();
foreach (Literal c in assumptions)
{
new_assumptions.Add(c.Subst(theta));
}
res.AddRange(ContextualAndOrLeaflists(new_remaining, kb, depth, context, new_antecedents, new_assumptions));
}
}
return(res);
}
}
}
public static List <Literal> GetContext(Solution solution, List <Literal> obs, Knowledgebase kb)
{
var res = new List <Literal>();
foreach (Entailment entailment in Entailments(kb, solution))
{
if (!obs.Contains(entailment.Entailed) && !res.Contains(entailment.Entailed))
{
res.Add(entailment.Entailed);
}
}
return(res);
}
public static List <Solution> ContextualEtcAbduction(List <Literal> obs, List <Literal> window, Knowledgebase kb, List <Solution> previous, int maxdepth, int beam, int iteration)
{
var ln_pr_to_beat = double.NegativeInfinity;
var n_best = new List <Solution>();
var n_best_ln_pr = new List <Double>();
foreach (Solution previous_solution in previous)
{
var previous_solution_jlpr = JointLnProbability(previous_solution);
var context = GetContext(previous_solution, obs, kb);
var list_of_lists = new List <List <Solution> >();
foreach (Literal c in window)
{
var remaining = new List <Literal>()
{
c
};
list_of_lists.Add(ContextualAndOrLeaflists(remaining, kb, maxdepth, context, new List <Literal>(), new List <Literal>()));
}
var combiner = new Combiner(list_of_lists);
foreach (Solution s in combiner)
{
if (BestCaseLnProbability(s) > ln_pr_to_beat) // maybe!
{
foreach (Solution solution in Abduction.Crunch(s))
{
var jlpr = JointLnProbability(solution) + previous_solution_jlpr; //add ln
if (jlpr > ln_pr_to_beat)
{
solution.AddRange(previous_solution); // important!
var insert_at = n_best_ln_pr.Count;
for (int i = 0; i < n_best_ln_pr.Count; i++)
{
if (n_best_ln_pr[i] > jlpr)
{
insert_at = i;
break;
}
}
n_best.Insert(insert_at, solution);
n_best_ln_pr.Insert(insert_at, jlpr);
if (n_best.Count > beam)
{
n_best.RemoveAt(0);
n_best_ln_pr.RemoveAt(0);
ln_pr_to_beat = n_best_ln_pr[0]; // second worst [0] is now lowest
}
}
}
}
}
}
n_best.Reverse(); // 0 is now highest;
var pre = "$" + iteration.ToString() + ":";
var res = new List <Solution>();
foreach (Solution c in n_best)
{
res.Add(skolemize_with_prefix(c, pre));
}
return(res);
}
public static List <Solution> NBest(List <Literal> obs, Knowledgebase kb, int maxdepth, int n, bool sk)
{
var ln_pr_to_beat = double.NegativeInfinity;
var n_best = new List <Solution>();
var n_best_ln_pr = new List <Double>();
var list_of_lists = new List <List <Solution> >();
foreach (Literal c in obs)
{
var remaining = new List <Literal>()
{
c
};
list_of_lists.Add(Abduction.AndOrLeaflists(remaining, kb, maxdepth, new List <Literal>(), new List <Literal>()));
}
var combiner = new Combiner(list_of_lists);
foreach (Solution s in combiner)
{
if (BestCaseLnProbability(s) > ln_pr_to_beat)
{
foreach (Solution solution in Abduction.Crunch(s))
{
var jpr = JointLnProbability(solution);
if (jpr > ln_pr_to_beat)
{
var insert_at = n_best_ln_pr.Count;
for (int i = 0; i < n_best_ln_pr.Count; i++)
{
if (n_best_ln_pr[i] > jpr)
{
insert_at = i;
break;
}
}
n_best.Insert(insert_at, solution);
n_best_ln_pr.Insert(insert_at, jpr);
if (n_best.Count > n)
{
n_best.RemoveAt(0);
n_best_ln_pr.RemoveAt(0);
//ln_pr_to_beat = jpr; // shouldn't this be the last item instead?
ln_pr_to_beat = n_best_ln_pr[0]; // second worst [0] is now lowest
}
}
}
}
}
n_best.Reverse(); // 0 is now highest;
if (sk) // skolemize here
{
var res = new List <Solution>();
foreach (Solution c in n_best)
{
res.Add(skolemize(c));
}
return(res);
}
else
{
return(n_best);
}
}
public static void Main(string[] cli_args)
{
var args = new TextGeneratorCli(cli_args);
if (args.Help_flag)
{
Console.WriteLine(HELP_MESSAGE);
System.Environment.Exit(1);
}
// read buffers
var buffer_i = "";
var buffer_k = "";
var buffer_t = "";
var buffer_s = "";
if (args.Input_path != null)
{
buffer_i = File.ReadAllText(args.Input_path);
}
else
{
if (Console.IsInputRedirected)
{
using (StreamReader reader = new StreamReader(Console.OpenStandardInput(), Console.InputEncoding))
{
buffer_i = reader.ReadToEnd();
}
}
}
if (args.Knowledge_path != null)
{
buffer_k = File.ReadAllText(args.Knowledge_path);
}
// create knowledgebase
var kb = new Knowledgebase();
var obs = kb.Add(buffer_i);
obs.AddRange(kb.Add(buffer_k));
// create templates knowledgebase
buffer_t = File.ReadAllText(args.Templates_path);
var tkb = new Knowledgebase();
var tobs = tkb.Add(buffer_t);
TextGenerator tg = new TextGenerator(kb, tkb, tobs);
// read the solution
buffer_s = File.ReadAllText(args.Solution_path);
var skb = new Knowledgebase();
var solution = skb.Add(buffer_s); // solution literals only
var result = "";
result = $"{String.Join(" || ",tg.Generate(solution, obs, ranker: args.Ranker ))}";
// output
if (args.Output_path != null)
{
using (StreamWriter file = new StreamWriter(args.Output_path))
{
file.WriteLine(result);
}
}
else
{
Console.WriteLine(result);
}
}
public static void Main(string[] cli_args)
{
var args = new Cli(cli_args);
if (args.Help_flag)
{
Console.WriteLine(HELP_MESSAGE);
System.Environment.Exit(1);
}
// read buffers
var buffer_i = "";
var buffer_k = "";
if (args.Input_path != null)
{
buffer_i = File.ReadAllText(args.Input_path);
}
else
{
if (Console.IsInputRedirected)
{
using (StreamReader reader = new StreamReader(Console.OpenStandardInput(), Console.InputEncoding))
{
buffer_i = reader.ReadToEnd();
}
}
}
if (args.Knowledge_path != null)
{
buffer_k = File.ReadAllText(args.Knowledge_path);
}
// create knowledgebase
var kb = new Knowledgebase();
var obs = kb.Add(buffer_i);
obs.AddRange(kb.Add(buffer_k));
// compose result
var result = "";
if (args.Parse_flag == true) // parse only
{
result = String.Join("\n", kb.Axioms.Select(dc => dc.Repr()));
}
else if (args.Forward_flag == true) // Forward chain
{
var entailments = Forward.Entailments(kb, obs);
if (args.Graph_flag == true) // dot format graph
{
result = Forward.Graph(obs, entailments, new List <Literal>());
}
else
{
result = String.Join("\n", entailments.Select(e => e.Repr()));
}
}
else // Abduction
{
var all_solutions = new List <List <Literal> >(); // void
if (args.All_flag) // All flag
{
all_solutions = Etcetera.DoEtcAbduction(obs, kb, args.Depth, true);
}
// else if incremental here
else if (args.Incremental_flag)
{
all_solutions = Incremental.DoIncremental(obs, kb, args.Depth, args.Nbest, args.Window, args.Beam, true);
//all_solutions = Realtime_Sidecar.incremental_alternative(obs, kb, args.Depth, args.Nbest, args.Window, args.Beam, true);
}
// else n-best
else
{
all_solutions = Etcetera.NBest(obs, kb, args.Depth, args.Nbest, true);
}
// Then decide what to output
if (args.Graph_flag)
{
var entailments = Forward.Entailments(kb, all_solutions[args.Solution - 1]);
result = Forward.Graph(all_solutions[args.Solution - 1], entailments, obs);
}
else if (all_solutions.Count == 0)
{
result = "0 solutions.";
}
else
{
var reslist = new List <String>();
if (args.EntailmentsFlag)
{
foreach (List <Literal> solution in all_solutions)
{
var entailed = Incremental.GetContext(solution, obs, kb);
if (entailed.Count == 0)
{
reslist.Add("none.");
}
else
{
reslist.Add($"({String.Join(" ",entailed.Select(e => e.Repr()))})");
}
}
}
else
{
foreach (List <Literal> solution in all_solutions)
{
var reprs = new List <String>();
foreach (Literal l in solution)
{
reprs.Add(l.Repr());
}
var reprstr = $"({String.Join(" ", reprs)})";
reslist.Add(reprstr);
}
}
result = $"{String.Join("\n",reslist)}\n{reslist.Count} solutions.";
}
}
// output
if (args.Output_path != null)
{
using (StreamWriter file = new StreamWriter(args.Output_path))
{
file.WriteLine(result);
}
}
else
{
Console.WriteLine(result);
}
}
