public void LearningDuplicateLinesAreIgnored()
{
var model = new StringMarkov();
model.Learn(ExampleData);
model.Learn(ExampleData);
Assert.AreEqual(ExampleData.Count(), model.SourcePhrases.Count);
Assert.That(ExampleData.ToList(), Is.EquivalentTo(model.SourcePhrases));
Assert.That(model.SourcePhrases, Is.Unique);
}
public void CanLearnLinesWithTrainedModel()
{
var model = new StringMarkov();
model.Learn(ExampleData);
Assert.AreEqual(ExampleData.Count(s => s.Split(' ').Length > model.Level), model.SourceLines.Count);
CollectionAssert.AreEquivalent(ExampleData.Where(s => s.Split(' ').Length > model.Level), model.SourceLines);
model.Learn("I do not like green eggs and hams");
Assert.AreEqual(ExampleData.Count() + 1, model.SourceLines.Count);
}
public void CanLearnDuplicatesDoesNotAddDupeSourceLinesAddsDupeTransitions()
{
var model = new StringMarkov();
model.Learn("Testing the model");
model.Learn("Testing the model");
CollectionAssert.AreEquivalent(new List <string> {
"Testing the model"
}, model.SourceLines);
Assert.AreEqual(1, model.SourceLines.Count);
Assert.AreEqual(8, model.Model.Sum(x => x.Value.Count));
Assert.That(model.SourceLines, Is.Unique);
}
private static async Task InitMarkovAsync(BotArguments args)
{
var chat = await File.ReadAllLinesAsync(args.SourceText);
_model = new StringMarkov(5);
_model.Learn(chat);
}
static KillUser()
{
KillsUsed = new List <int>();
Killgen = new StringMarkov();
Kills = FileHandler.LoadStringListFromFile(FileHandler.StringListFileType.Kills);
Killgen.Learn(Kills);
}
static void Main(string[] args)
{
var model = new StringMarkov(2);
var jArray = JArray.Parse(File.ReadAllText(@"pokemon.json"));
var source = jArray.Select(x => x.Value <string>()).ToList();
var names = source;
for (int i = 0; i < names.Count; i++)
{
var name = names[i];
int insertIndex = name.Length / 2;
var charArray = name.ToCharArray().ToList();
//charArray.Insert(insertIndex, ' ');
names[i] = string.Join(" ", charArray);
}
model.Learn(names);
//GeneratorFacade gen = new GeneratorFacade(new MarkovGenerator(File.ReadAllText("book.txt")));
while (true)
{
Console.ReadLine();
var output = model.Walk().First();
output = output.Replace(" ", "");
//var output = gen.GenerateSentence(10);
var result = output;
if (source.Any(x => x == output))
{
result = "did not change";
}
Console.WriteLine(result);
}
}
private void MessageBus_Received(object sender, MessageReceivedEventArgs e)
{
if (string.IsNullOrEmpty(e.Message.Text?.Trim()) || e.Message.Text.IsCommand())
{
return;
}
IChannel channel = e.Context?.Channel;
IEntity entity = e.Context?.User as IEntity;
if (channel != null)
{
if (e.Context.User?.Name != e.Context.OriginClient.Username)
{
if (_models.ContainsKey(e.Context.Channel.Name))
{
_models[channel.Name].Learn(e.Message.Text);
}
}
}
if (entity != null)
{
if (_userModels.ContainsKey(entity.ID))
{
_userModels[entity.ID].Learn(e.Message.Text);
}
else
{
StringMarkov markov = new StringMarkov();
_userModels.TryAdd(entity.ID, markov);
markov.Learn(e.Message.Text);
}
}
}
public ActionResult Train()
{
string requestData;
using (Stream req = Request.InputStream)
{
req.Seek(0, SeekOrigin.Begin);
requestData = new StreamReader(req).ReadToEnd();
}
var deserialisedRequestData = JsonConvert.DeserializeObject <TrainingRequest>(requestData);
var model = new StringMarkov(deserialisedRequestData.ModelLevel ?? 1);
var lines = deserialisedRequestData.TrainingData.Split(new char[] { '\n', '.', '!', '?' }, StringSplitOptions.RemoveEmptyEntries);
model.Learn(lines);
Session["Model"] = model;
return(new JsonResult()
{
Data = new
{
Message = $"Learnt {lines.Count()} lines of training data using level {model.Level}",
Error = null as object
},
JsonRequestBehavior = JsonRequestBehavior.AllowGet
});
}
public void SentenceSmallerThanLevelIsNotAddedToSourceLines()
{
var model = new StringMarkov(5);
model.Learn("A short sentence");
CollectionAssert.AreEquivalent(new List <string>(), model.SourceLines);
}
public void SentenceSmallerThanLevelIsNotAddedToModel()
{
var model = new StringMarkov(5);
model.Learn("A short sentence");
Assert.AreEqual(0, model.Model.Count, string.Join(", ", model.Model.Select(a => string.Join(" ", a))));
}
public void LinesAreAddedToModelOnLearn()
{
var model = new StringMarkov();
model.Learn(ExampleData);
Assert.AreEqual(ExampleData.Count(), model.SourceLines.Count);
CollectionAssert.AreEquivalent(ExampleData, model.SourceLines);
}
public void GetFit_DirectMatch()
{
var model = new StringMarkov();
model.Learn(ExampleData);
var testValue = "prepared for the great ordeal of meeting me";
var result = model.GetFit(testValue);
}
public void RetrainingSetsCorrectDictionaryKeyLength(int retrainDepth)
{
var model = new StringMarkov();
model.Learn(ExampleData);
model.Retrain(retrainDepth);
Assert.AreEqual(retrainDepth, model.Chain.ChainDictionary.Max(a => a.Key.Ngrams.Length));
}
public void GetFit_DirectNonMatch()
{
var model = new StringMarkov();
model.Learn(ExampleData);
var testValue = "prepared NON for NON the NON great NON ordeal NON of NON meeting NON me";
var result = model.GetFit(testValue);
}
public void WalkOnTrainedModelGeneratesCorrectNumberOfLines(int lineCount)
{
var model = new StringMarkov();
model.Learn(ExampleData);
var result = model.Walk(lineCount);
Assert.AreEqual(lineCount, result.Count());
}
public void RetrainingSetsCorrectLevel(int retrainDepth)
{
var model = new StringMarkov();
model.Learn(ExampleData);
Assert.AreEqual(2, model.Level);
model.Retrain(retrainDepth);
Assert.AreEqual(retrainDepth, model.Level);
}
public void RetrainValueMustBePositiveInteger(int retrainDepth)
{
var model = new StringMarkov();
model.Learn(ExampleData);
var ex = Assert.Throws <ArgumentException>(() => model.Retrain(retrainDepth));
Assert.AreEqual("Invalid argument - retrain level must be a positive integer\r\nParameter name: newLevel", ex.Message);
}
public void SourceLinesAreSameAfterRetrained(int retrainDepth)
{
var model = new StringMarkov();
model.Learn(ExampleData);
var oldLines = new List <string>(model.SourcePhrases);
model.Retrain(retrainDepth);
CollectionAssert.AreEquivalent(oldLines, model.SourcePhrases);
}
public void LearnEmptyStringDoesNotAddToSourceLinesOrModel()
{
var model = new StringMarkov();
model.Learn("");
CollectionAssert.AreEquivalent(new List <string>(), model.SourcePhrases);
Assert.AreEqual(0, model.SourcePhrases.Count);
Assert.AreEqual(0, model.Chain.ChainDictionary.Sum(x => x.Value.Count));
}
public void BasicWalkOnTrainedModelGeneratesCorrectNumberOfLines()
{
var model = new StringMarkov();
model.Learn(ExampleData);
var result = model.Walk(1);
Assert.AreEqual(1, result.Count());
Logger.Info(result.First());
}
public void LearnNullStringDoesNotAddToSourceLinesOrModel()
{
var model = new StringMarkov();
model.Learn(null);
CollectionAssert.AreEquivalent(new List <string>(), model.SourceLines);
Assert.AreEqual(0, model.SourceLines.Count);
Assert.AreEqual(0, model.Model.Sum(x => x.Value.Count));
}
public void LevelCorrectWhenModelIsLoadedUsingValue()
{
var model = new StringMarkov(3);
model.Learn(ExampleData);
model.Save(ModelFileName);
var loaded = model.Load <StringMarkov>(ModelFileName, 2);
Assert.AreEqual(2, loaded.Level);
}
public void CanWalkWithUniqueOutput()
{
var model = new StringMarkov();
model.Learn(ExampleData);
model.EnsureUniqueWalk = true;
var results = model.Walk(500);
Assert.AreEqual(results.Count(), results.Distinct().Count());
}
public void CanSaveTrainedModel()
{
var model = new StringMarkov();
model.Learn(ExampleData);
model.Save(ModelFileName);
var forLoading = new StringMarkov().Load <StringMarkov>(ModelFileName, model.Level);
Assert.AreEqual(model.Level, forLoading.Level);
Assert.AreEqual(model.SourceLines, forLoading.SourceLines);
}
public void SavedFileDoesntContainModelDictionary()
{
var model = new StringMarkov();
model.Learn(ExampleData);
model.Save(ModelFileName);
string fileContents = File.ReadAllText(ModelFileName);
dynamic loaded = JsonConvert.DeserializeObject <dynamic>(fileContents);
Assert.IsNull(loaded.Model);
}
private static void StringWalk(string[] sourceText, int level = 1)
{
StringMarkov model = new StringMarkov(level);
model.Learn(sourceText);
string format = model.Walk().First();
while (format.Trim() == String.Empty)
{
format = model.Walk().First();
}
Console.WriteLine(format);
}
public void SavedFileContainsLevel()
{
var model = new StringMarkov();
model.Learn(ExampleData);
model.Save(ModelFileName);
string fileContents = File.ReadAllText(ModelFileName);
dynamic loaded = JsonConvert.DeserializeObject <dynamic>(fileContents);
Assert.IsNotNull(loaded.Level);
Assert.AreEqual(2, (int)loaded.Level);
}
public void CanWalkUsingSeed()
{
var model = new StringMarkov();
model.Learn(ExampleData);
var results = model.Walk(100, "This is a line");
Assert.AreEqual(100, results.Count());
foreach (var result in results)
{
Assert.That(result, Is.StringStarting("This is a line"));
}
}
public void GenerateQuotes(int n)
{
int numeroCadenas = 4;
var model = new StringMarkov(n);
Console.WriteLine("\nTraining ...");
model.Learn(lines);
Console.WriteLine("============================================");
for (int i = 0; i < numeroCadenas; i++)
{
Console.WriteLine("[" + i + "]: " + model.Walk().First());
}
}
public void CanLoadWithGivenLevel(int newLevel)
{
var model = new StringMarkov(1);
model.Learn(ExampleData);
model.Save(ModelFileName);
var forLoading = new StringMarkov().Load <StringMarkov>(ModelFileName, newLevel);
Assert.AreEqual(newLevel, forLoading.Level);
Assert.AreEqual(model.SourceLines, forLoading.SourceLines);
Assert.AreEqual(newLevel, forLoading.Model.Max(a => a.Key.Before.Length));
}