| public Arcs ( Intarray ids, Intarray targets, Intarray outputs, Floatarray costs, int from ) : void | ||
| ids | Intarray | |
| targets | Intarray | |
| outputs | Intarray | |
| costs | Floatarray | |
| from | int | |
| return | void | |
/// <summary>
/// Copy one FST to another, preserving only lowest-cost arcs.
/// This is useful for visualization.
/// </summary>
/// <param name="dst">The destination. Will be cleared before copying.</param>
/// <param name="src">The FST to copy.</param>
public static void fst_copy_best_arcs_only(IGenericFst dst, IGenericFst src)
{
dst.Clear();
int n = src.nStates();
for (int i = 0; i < n; i++)
dst.NewState();
dst.SetStart(src.GetStart());
for(int i = 0; i < n; i++)
{
dst.SetAccept(i, src.GetAcceptCost(i));
Intarray targets = new Intarray(), outputs = new Intarray(), inputs = new Intarray();
Floatarray costs = new Floatarray();
src.Arcs(inputs, targets, outputs, costs, i);
int inlen = inputs.Length();
if (inlen != targets.Length())
throw new Exception("ASSERT: inputs.length() == targets.length()");
if (inlen != outputs.Length())
throw new Exception("ASSERT: inputs.length() == outputs.length()");
if (inlen != costs.Length())
throw new Exception("ASSERT: inputs.length() == costs.length()");
Dictionary< int, int > hash = new Dictionary<int,int>();
for(int j = 0; j < n; j++) {
int t = targets[j];
int best_so_far = -1;
if (hash.ContainsKey(t))
best_so_far = hash[t];
if(best_so_far == -1 || costs[j] < costs[best_so_far])
hash[t] = j;
}
Intarray keys = new Intarray();
//hash.keys(keys);
keys.Clear();
foreach (int key in hash.Keys)
{
keys.Push(key);
}
for(int k = 0; k < keys.Length(); k++) {
int j = hash[keys[k]];
dst.AddTransition(i, targets[j], outputs[j], costs[j], inputs[j]);
}
}
}
/// <summary>
/// Copy one FST to another.
/// </summary>
/// <param name="dst">The destination. Will be cleared before copying.</param>
/// <param name="src">The FST to copy.</param>
public static void fst_copy(IGenericFst dst, IGenericFst src)
{
dst.Clear();
int n = src.nStates();
for (int i = 0; i < n; i++)
dst.NewState();
dst.SetStart(src.GetStart());
for (int i = 0; i < n; i++)
{
dst.SetAccept(i, src.GetAcceptCost(i));
Intarray targets = new Intarray(), outputs = new Intarray(), inputs = new Intarray();
Floatarray costs = new Floatarray();
src.Arcs(inputs, targets, outputs, costs, i);
int inlen = inputs.Length();
if (inlen != targets.Length())
throw new Exception("ASSERT: inputs.length() == targets.length()");
if (inlen != outputs.Length())
throw new Exception("ASSERT: inputs.length() == outputs.length()");
if (inlen != costs.Length())
throw new Exception("ASSERT: inputs.length() == costs.length()");
for (int j = 0; j < inputs.Length(); j++)
dst.AddTransition(i, targets.At1d(j), outputs.At1d(j), costs.At1d(j), inputs.At1d(j));
}
}
protected static void write_node(BinaryWriter writer, IGenericFst fst, int index)
{
Intarray inputs = new Intarray();
Intarray targets = new Intarray();
Intarray outputs = new Intarray();
Floatarray costs = new Floatarray();
fst.Arcs(inputs, targets, outputs, costs, index);
int narcs = targets.Length();
write_float(writer, fst.GetAcceptCost(index));
write_int64_LE(writer, narcs);
for (int i = 0; i < narcs; i++)
{
write_int32_LE(writer, inputs[i]);
write_int32_LE(writer, outputs[i]);
write_float(writer, costs[i]);
write_int32_LE(writer, targets[i]);
}
}
/// <summary>
/// Randomly sample an FST, assuming any input.
/// </summary>
/// <param name="result">The array of output symbols, excluding epsilons.</param>
/// <param name="fst">The FST.</param>
/// <param name="max">The maximum length of the result.</param>
/// <returns>total cost</returns>
public static double fst_sample(Intarray result, IGenericFst fst, int max=1000)
{
double total_cost = 0;
int current = fst.GetStart();
for (int counter = 0; counter < max; counter++)
{
Intarray inputs = new Intarray();
Intarray outputs = new Intarray();
Intarray targets = new Intarray();
Floatarray costs = new Floatarray();
fst.Arcs(inputs, targets, outputs, costs, current);
// now we need to deal with the costs uniformly, so:
costs.Push(fst.GetAcceptCost(current));
int choice = sample_by_costs(costs);
if (choice == costs.Length() - 1)
break;
result.Push(outputs[choice]);
total_cost += costs[choice];
current = targets[choice];
}
return total_cost + fst.GetAcceptCost(current);
}
/// <summary>
/// Reverse the FST's arcs, adding a new start vertex (former accept).
/// </summary>
public static void fst_copy_reverse(IGenericFst dst, IGenericFst src, bool no_accept = false)
{
dst.Clear();
int n = src.nStates();
for (int i = 0; i <= n; i++)
dst.NewState();
if (!no_accept)
dst.SetAccept(src.GetStart());
dst.SetStart(n);
for (int i = 0; i < n; i++)
{
dst.AddTransition(n, i, 0, src.GetAcceptCost(i), 0);
Intarray targets = new Intarray(), outputs = new Intarray(), inputs = new Intarray();
Floatarray costs = new Floatarray();
src.Arcs(inputs, targets, outputs, costs, i);
if (inputs.Length() != targets.Length())
throw new Exception("ASSERT: inputs.length() == targets.length()");
if (inputs.Length() != outputs.Length())
throw new Exception("ASSERT: inputs.length() == outputs.length()");
if (inputs.Length() != costs.Length())
throw new Exception("ASSERT: inputs.length() == costs.length()");
for (int j = 0; j < inputs.Length(); j++)
dst.AddTransition(targets.At1d(j), i, outputs.At1d(j), costs.At1d(j), inputs.At1d(j));
}
}
