public DefaultWord(string value, DefaultGram gram, int id, string classType = null)
{
m_value = value;
m_gram = gram;
m_id = id;
m_class = classType;
}
public DefaultWord (string value, DefaultGram gram, int id, string classType = null )
{
m_value = value;
m_gram = gram;
m_id = id;
m_class = classType;
}
private void GenerateNGram()
{
if (blackBoard.ConfigUI.Config.HeiarchalEnabled)
{
grammar = NGramFactory.InitHierarchicalNGram(
blackBoard.ConfigUI.Config.N,
blackBoard.ConfigUI.Config.HeiarchalMemory);
simpleGrammar = NGramFactory.InitHierarchicalNGram(
blackBoard.ConfigUI.Config.N,
blackBoard.ConfigUI.Config.HeiarchalMemory);
}
else if (blackBoard.ConfigUI.Config.BackOffEnabled)
{
grammar = NGramFactory.InitHierarchicalNGram(
blackBoard.ConfigUI.Config.N,
blackBoard.ConfigUI.Config.BackOffMemory);
simpleGrammar = NGramFactory.InitHierarchicalNGram(
blackBoard.ConfigUI.Config.N,
blackBoard.ConfigUI.Config.BackOffMemory);
}
else
{
grammar = NGramFactory.InitGrammar(blackBoard.ConfigUI.Config.N);
simpleGrammar = NGramFactory.InitGrammar(blackBoard.ConfigUI.Config.N);
}
for (int i = 0; i <= blackBoard.ProgressIndex; ++i)
{
if (blackBoard.ConfigUI.Config.UsingTieredGeneration || blackBoard.ProgressIndex == i)
{
JsonObject tierInfo = blackBoard.GameFlow[i].AsJsonObject;
JsonArray tierLevels = tierInfo[FlowKeys.LevelNames].AsJsonArray;
foreach (string levelName in tierLevels)
{
List <string> columns = LevelParser.BreakMapIntoColumns(levelName);
columns.RemoveAt(columns.Count - 1); // remove flag at the end
List <string> simpleColumns = LevelParser.BreakColumnsIntoSimplifiedTokens(
columns,
blackBoard.ConfigUI.Config.Game);
levelColumns.Add(columns);
simplifiedLevelColumns.Add(simpleColumns);
NGramTrainer.Train(grammar, columns, skipFirst: true);
NGramTrainer.Train(simpleGrammar, simpleColumns, skipFirst: true);
if (blackBoard.ProgressIndex != i)
{
grammar.UpdateMemory(blackBoard.ConfigUI.Config.TieredGenerationMemoryUpdate);
levelColumns.Clear();
simplifiedLevelColumns.Clear();
}
}
}
}
}
private List <SimulationThread> GetSimulationThreads(string levelFlowPath, string name, Games game)
{
// We first get all the levels from the flow and then get the start
// input from the first level in the sequence. Note that the first
// we use the same start input but we don't want that to scew
// results. To get around this, we use a flag in the ngram generator
// which will not include the start output in the end result.
List <List <string> > levels = BuildSimulator.GetLevels(levelFlowPath);
List <string> startInput = levels[0].GetRange(0, 10);
List <SimulationThread> threads = new List <SimulationThread>();
for (int i = 1; i <= 6; ++i)
{
IGram gram = NGramFactory.InitGrammar(i);
foreach (List <string> level in levels)
{
NGramTrainer.Train(gram, level, skipFirst: true);
}
//threads.Add(BuildThread(gram, null, startInput, game, $"{name}_{Size}_ngram"));
if (i != 1)
{
gram = NGramFactory.InitHierarchicalNGram(i, 0.6f);
IGram simpleGram = NGramFactory.InitHierarchicalNGram(i, 0.6f);
IGram bgram = NGramFactory.InitBackOffNGram(i, 0.6f);
foreach (List <string> level in levels)
{
NGramTrainer.Train(gram, level, skipFirst: true);
NGramTrainer.Train(bgram, level, skipFirst: true);
NGramTrainer.Train(
simpleGram,
LevelParser.BreakColumnsIntoSimplifiedTokens(
level,
game),
skipFirst: true);
}
//threads.Add(BuildThread(gram, null, startInput, game, $"{name}_{Size}_heirarchical"));
threads.Add(BuildThread(gram, simpleGram, startInput, game, $"{name}_{Size}_simple_heirarchical"));
//threads.Add(BuildThread(bgram, null, startInput, game, $"{name}_{Size}_backoff"));
// threads.Add(BuildThread(bgram, simpleGram, startInput, game, $"{name}_{Size}_simple_backoff"));
}
}
return(threads);
}
public void AddGrammar(IGram gram)
{
Assert.IsTrue(gram.GetN() == N);
NGram ngram = (NGram)gram;
foreach (string key in ngram.Grammar.Keys)
{
if (Grammar.ContainsKey(key) == false)
{
Grammar[key] = new UniGram();
}
Grammar[key].AddGrammar(ngram.Grammar[key]);
}
}
public HierarchicalNGram(int n, float compiledMemoryUpdate)
{
Assert.IsTrue(compiledMemoryUpdate > 0);
Assert.IsTrue(compiledMemoryUpdate < 1);
Assert.IsTrue(n > 1);
CompiledMemoryUpdate = compiledMemoryUpdate;
N = n;
Grammars = new IGram[n];
Grammars[0] = new UniGram();
for (int grammarSize = 2; grammarSize <= n; ++grammarSize)
{
Grammars[grammarSize - 1] = new NGram(grammarSize);
}
}
private SimulationThread BuildThread(
IGram gram,
IGram simplifiedGram,
List <string> startInput,
Games game,
string extension)
{
return(new SimulationThread(
NumSimulations,
Size,
game,
basePath,
extension,
gram,
simplifiedGram,
startInput));
}
public void AddGrammar(IGram gram)
{
Assert.IsTrue(gram.GetN() == 1);
UniGram unigram = (UniGram)gram;
foreach (KeyValuePair <string, float> keyValue in unigram.Grammar)
{
if (Grammar.ContainsKey(keyValue.Key) == false)
{
Grammar[keyValue.Key] = keyValue.Value;
}
else
{
Grammar[keyValue.Key] += keyValue.Value;
}
}
}
public void AddGrammar(IGram gram)
{
HierarchicalNGram grammar = gram as HierarchicalNGram;
if (grammar != null)
{
Assert.AreEqual(N, grammar.N);
for (int grammarSize = 0; grammarSize < N; ++grammarSize)
{
Grammars[grammarSize].AddGrammar(grammar.Grammars[grammarSize]);
}
}
else
{
int n = gram.GetN();
Assert.IsTrue(n <= N);
Grammars[n - 1].AddGrammar(gram);
}
}
private Thread BuildThread(
IGram gram,
IGram simplifiedGram,
List <string> startInput,
Games game,
string extension)
{
SimulationThread simulation = new SimulationThread(
numSimulations,
size,
game,
basePath,
extension,
gram,
simplifiedGram,
startInput);
return(new Thread(new ThreadStart(simulation.Execute)));
}
public SimulationThread(
int numSimulations,
int size,
Games game,
string basePath,
string extension,
IGram gram,
IGram simplifiedGram,
List <string> startInput)
{
this.numSimulations = numSimulations;
this.size = size;
this.game = game;
this.basePath = basePath;
this.extension = extension;
this.gram = gram;
this.simplifiedGram = simplifiedGram;
this.startInput = startInput;
}
public GramController(IGram g)
{
grams = g;
}
/// <summary>
/// configures model and blob
/// </summary>
/// <param name="netGram"></param>
/// <param name="configuration"></param>
public ManageModel(IGram netGram, IConfiguration configuration)
{
_netGram = netGram;
BlobImage = new Blob(configuration);
}
public ManageModel(IGram gram, IConfiguration configuration)
{
_gram = gram;
//Blob Storage Account Reference
BlobImage = new Models.Util.Blob(configuration);
}
public IndexModel(IGram gram)
{
_gram = gram;
}
public IndexModel(IGram post)
{
_post = post;
}
public static void Initialize(IGram grams)
{
public ManageModel(IGram post, IConfiguration configuration)
{
_post = post;
//Blob Storage Account to be referenced
BlobImage = new Blob(configuration);
}
public IndexModel(IGram netGram)
{
_netGram = netGram;
}
