public void TrainerShouldNotHaveAnyPokemonLeftToBattle()
{
ITrainer trainer = TrainerFactory.CreateTrainer <Player>();
trainer?.PokemonTeam?.ForEach(pkmn => pkmn?.SetAsFainted());
Assert.False(trainer?.HasAvailablePokemon());
}
public void TestPerceptronOnPrepAttachDataWithStepSizeDecrease()
{
var trainParams = new TrainingParameters();
trainParams.Set(Parameters.Algorithm, Parameters.Algorithms.Perceptron);
trainParams.Set(Parameters.Cutoff, "1");
trainParams.Set(Parameters.Iterations, "500");
trainParams.Set(Parameters.StepSizeDecrease, "0.06");
var trainer = TrainerFactory.GetEventTrainer(trainParams, null, null);
var model = trainer.Train(PrepAttachDataUtility.CreateTrainingStream());
/*
* The java test gives an error too, soo.... for now i'll assume that is correct :P
*
* java.lang.AssertionError: expected:<0.7756870512503095> but was:<0.7766773953948998>
* at org.junit.Assert.fail(Assert.java:91)
* at org.junit.Assert.failNotEquals(Assert.java:645)
* at org.junit.Assert.assertEquals(Assert.java:441)
* at org.junit.Assert.assertEquals(Assert.java:510)
*/
//PrepAttachDataUtility.TestModel(model, 0.7756870512503095); < OpenNLP value
PrepAttachDataUtility.TestModel(model, 0.77742015350334237);
}
public void ShouldSetChosenPokemonAsCurrent()
{
ITrainer trainer = TrainerFactory.CreateTrainer <Blue>();
trainer?.PokemonTeam?.FirstOrDefault()?.SetAsCurrent();
Assert.True(trainer.PokemonTeam?.FirstOrDefault()?.Current);
}
/// <summary>
/// Trains a parser model with the given parameters.
/// </summary>
/// <param name="monitor">
/// A evaluation monitor that can be used to listen the messages during the training or it can cancel the training operation.
/// This argument can be a <c>null</c> value.
/// </param>
/// <param name="languageCode">The language code.</param>
/// <param name="samples">The data samples.</param>
/// <param name="rules">The head rules.</param>
/// <param name="parameters">The machine learnable parameters.</param>
/// <returns>The trained <see cref="ParserModel" /> object.</returns>
public static ParserModel Train(
Monitor monitor,
string languageCode,
IObjectStream <Parse> samples,
AbstractHeadRules rules,
TrainingParameters parameters)
{
var dict = BuildDictionary(samples, rules, parameters);
samples.Reset();
var manifestInfoEntries = new Dictionary <string, string>();
// build
//System.err.println("Training builder");
var bes = new ParserEventStream(samples, rules, ParserEventTypeEnum.Build, dict);
var buildReportMap = new Dictionary <string, string>();
var buildTrainer = TrainerFactory.GetEventTrainer(parameters.GetNamespace("build"), buildReportMap, monitor);
var buildModel = buildTrainer.Train(bes);
MergeReportIntoManifest(manifestInfoEntries, buildReportMap, "build");
samples.Reset();
// tag
var posTaggerParams = parameters.GetNamespace("tagger");
if (!posTaggerParams.Contains(Parameters.BeamSize))
{
posTaggerParams.Set(Parameters.BeamSize, "10");
}
var posModel = POSTaggerME.Train(languageCode, new PosSampleStream(samples),
parameters.GetNamespace("tagger"), new POSTaggerFactory());
samples.Reset();
// chunk
var chunkModel = ChunkerME.Train(languageCode,
new ChunkSampleStream(samples),
parameters.GetNamespace("chunker"),
new ParserChunkerFactory());
samples.Reset();
// check
//System.err.println("Training checker");
var kes = new ParserEventStream(samples, rules, ParserEventTypeEnum.Check);
var checkReportMap = new Dictionary <string, string>();
var checkTrainer = TrainerFactory.GetEventTrainer(parameters.GetNamespace("check"), checkReportMap, monitor);
var checkModel = checkTrainer.Train(kes);
MergeReportIntoManifest(manifestInfoEntries, checkReportMap, "check");
return(new ParserModel(languageCode, buildModel, checkModel, posModel, chunkModel, rules, manifestInfoEntries));
}
//Restore button
private void restoreToolStripMenuItem_Click(object sender, EventArgs e)
{
if (MessageBox.Show("Do you really want to restore data from XML? Almost all online data will be lost.", "Restore",
MessageBoxButtons.YesNo) == DialogResult.Yes)
{
LockerFactory lockerFactory = new LockerFactory();
LockerGateway <Locker> lg = (LockerGateway <Locker>)lockerFactory.GetLocker();
TrainingFactory trainingFactory = new TrainingFactory();
TrainingGateway <Training> tg = (TrainingGateway <Training>)trainingFactory.GetTraining();
PurchaseFactory purchaseFactory = new PurchaseFactory();
PurchaseGateway <Purchase> pg = (PurchaseGateway <Purchase>)purchaseFactory.GetPurchase();
TrainerFactory trainerFactory = new TrainerFactory();
TrainerGateway <Trainer> trainerg = (TrainerGateway <Trainer>)trainerFactory.GetTrainer();
TrainerRatingFactory trainerRatingFactory = new TrainerRatingFactory();
TrainerRatingGateway <TrainerRating> tr = (TrainerRatingGateway <TrainerRating>)trainerRatingFactory.GetTrainerRating();
TicketFactory ticketFactory = new TicketFactory();
TicketGateway <Ticket> ticketg = (TicketGateway <Ticket>)ticketFactory.GetTicket();
tg.Delete();
pg.Delete();
tr.Delete();
trainerg.Delete();
lg.Delete();
ticketg.Delete();
foreach (var locker in lg.Select())
{
lg.Insert(locker);
}
foreach (var ticket in TicketXMLGateway <Ticket> .Instance.Select())
{
TicketXMLGateway <Ticket> .Instance.Insert(ticket);
}
foreach (var trainer in TrainerXMLGateway <Trainer> .Instance.Select())
{
TrainerXMLGateway <Trainer> .Instance.Insert(trainer);
}
foreach (var purchase in PurchaseXMLGateway <Purchase> .Instance.Select())
{
PurchaseXMLGateway <Purchase> .Instance.Insert(purchase);
}
foreach (var training in TrainingXMLGateway <Training> .Instance.Select())
{
TrainingXMLGateway <Training> .Instance.Insert(training);
}
foreach (var rating in TrainerRatingXMLGateway <TrainerRating> .Instance.Select())
{
TrainerRatingXMLGateway <TrainerRating> .Instance.Insert(rating);
}
MessageBox.Show("Data restored!");
}
}
/// <summary>
/// Trains a name finder model with the given parameters.
/// </summary>
/// <param name="languageCode">The language of the training data.</param>
/// <param name="type">Overrides the type parameter in the provided samples. This value can be null.</param>
/// <param name="samples">The training samples.</param>
/// <param name="parameters">The machine learning train parameters.</param>
/// <param name="factory">The name finder factory.</param>
/// <param name="monitor">
/// A evaluation monitor that can be used to listen the messages during the training or it can cancel the training operation.
/// This argument can be a <c>null</c> value.</param>
/// <returns>the newly <see cref="TokenNameFinderModel"/> trained model.</returns>
public static TokenNameFinderModel Train(string languageCode, string type, IObjectStream <NameSample> samples, TrainingParameters parameters, TokenNameFinderFactory factory, Monitor monitor)
{
var beamSize = parameters.Get(Parameters.BeamSize, DefaultBeamSize);
var manifestInfoEntries = new Dictionary <string, string>();
var trainerType = TrainerFactory.GetTrainerType(parameters);
IMaxentModel meModel = null;
ML.Model.ISequenceClassificationModel <string> scModel = null;
switch (trainerType)
{
case TrainerType.EventModelTrainer:
var eventStream = new NameFinderEventStream(samples, type, factory.CreateContextGenerator(),
factory.CreateSequenceCodec());
var nfTrainer = TrainerFactory.GetEventTrainer(parameters, manifestInfoEntries, monitor);
meModel = nfTrainer.Train(eventStream);
break;
case TrainerType.EventModelSequenceTrainer:
var sampleStream = new NameSampleSequenceStream(samples, factory.CreateContextGenerator());
var nsTrainer = TrainerFactory.GetEventModelSequenceTrainer(parameters, manifestInfoEntries, monitor);
meModel = nsTrainer.Train(sampleStream);
break;
case TrainerType.SequenceTrainer:
var sequenceStream = new NameSampleSequenceStream(samples, factory.CreateContextGenerator());
var sqTrainer = TrainerFactory.GetSequenceModelTrainer(parameters, manifestInfoEntries, monitor);
scModel = sqTrainer.Train(sequenceStream);
break;
default:
throw new InvalidOperationException("Unexpected trainer type!");
}
if (scModel != null)
{
return(new TokenNameFinderModel(
languageCode,
scModel,
factory.FeatureGenerator,
factory.Resources,
manifestInfoEntries,
factory.SequenceCodec));
}
return(new TokenNameFinderModel(
languageCode,
meModel,
beamSize,
factory.FeatureGenerator,
factory.Resources,
manifestInfoEntries,
factory.SequenceCodec));
}
public void PlayerShouldNotHaveDialogues()
{
ITrainer player = TrainerFactory.CreateTrainer <Player>();
Assert.Throws <NotImplementedException>(() => player?.ShowTrainerDialogue());
Assert.Throws <NotImplementedException>(() => player?.ShowFinalDialogueForLoss());
Assert.Throws <NotImplementedException>(() => player?.ShowFinalDialogueForVictory());
}
public void Setup()
{
mlParams = new TrainingParameters();
mlParams.Set(Parameters.Algorithm, Parameters.Algorithms.MaxEnt);
mlParams.Set(Parameters.Iterations, "10");
mlParams.Set(Parameters.Cutoff, "5");
TrainerFactory.RegisterTrainer("Dummy", typeof(DummyTrainer));
}
/// <summary>
/// Trains document categorizer model with the given parameters.
/// </summary>
/// <param name="languageCode">The language code.</param>
/// <param name="samples">The data samples.</param>
/// <param name="parameters">The machine learnable parameters.</param>
/// <param name="factory">The document categorizer factory.</param>
/// <param name="monitor">
/// A evaluation monitor that can be used to listen the messages during the training or it can cancel the training operation.
/// This argument can be a <c>null</c> value.
/// </param>
/// <returns>The trained <see cref="DocumentCategorizerModel"/> model.</returns>
public static DocumentCategorizerModel Train(string languageCode, IObjectStream <DocumentSample> samples, TrainingParameters parameters, DocumentCategorizerFactory factory, Monitor monitor)
{
var manifestInfoEntries = new Dictionary <string, string>();
var eventStream = new DocumentCategorizerEventStream(samples, factory.FeatureGenerators);
var trainer = TrainerFactory.GetEventTrainer(parameters, manifestInfoEntries, monitor);
var model = trainer.Train(eventStream);
return(new DocumentCategorizerModel(languageCode, model, manifestInfoEntries, factory));
}
public void TestQnOnPrepAttachDataWithParamsDefault()
{
var trainParams = new TrainingParameters();
trainParams.Set(Parameters.Algorithm, Parameters.Algorithms.MaxEntQn);
var trainer = TrainerFactory.GetEventTrainer(trainParams, null, null);
var model = trainer.Train(PrepAttachDataUtility.CreateTrainingStream());
TestModel(model, 0.8115870264917059);
}
/// <summary>
/// Trains a model for the <see cref="TokenizerME"/>.
/// </summary>
/// <param name="samples">The samples used for the training.</param>
/// <param name="factory">A <see cref="TokenizerFactory"/> to get resources from.</param>
/// <param name="parameters">The machine learning train parameters.</param>
/// <param name="monitor">
/// A evaluation monitor that can be used to listen the messages during the training or it can cancel the training operation.
/// This argument can be a <c>null</c> value.
/// </param>
/// <returns>The trained <see cref="TokenizerModel"/>.</returns>
public static TokenizerModel Train(IObjectStream <TokenSample> samples, TokenizerFactory factory, TrainingParameters parameters, Monitor monitor)
{
var manifestInfoEntries = new Dictionary <string, string>();
var eventStream = new TokSpanEventStream(samples, factory.UseAlphaNumericOptimization,
factory.AlphaNumericPattern, factory.ContextGenerator);
var trainer = TrainerFactory.GetEventTrainer(parameters, manifestInfoEntries, monitor);
var model = trainer.Train(eventStream);
return(new TokenizerModel(model, manifestInfoEntries, factory));
}
public void TestMaxentOnPrepAttachDataWithParamsDefault()
{
var reportMap = new Dictionary <string, string>();
var trainParams = new TrainingParameters();
trainParams.Set(Parameters.Algorithm, Parameters.Algorithms.MaxEnt);
var trainer = TrainerFactory.GetEventTrainer(trainParams, reportMap, null);
var model = trainer.Train(PrepAttachDataUtility.CreateTrainingStream());
PrepAttachDataUtility.TestModel(model, 0.8086159940579352d);
}
static void Main()
{
try
{
ITrainer player = TrainerFactory.CreateTrainer <Player>();
var mainStory = new MainStory(player);
mainStory.BeginStory();
}
catch (Exception ex)
{
Console.WriteLine($"Something bad happened in the game! Please report the error. Error: {ex.Message} \n Error's StackTrace: {ex.StackTrace}");
}
}
public void TestPerceptronOnPrepAttachDataWithSkippedAveraging()
{
var trainParams = new TrainingParameters();
trainParams.Set(Parameters.Algorithm, Parameters.Algorithms.Perceptron);
trainParams.Set(Parameters.Cutoff, "1");
trainParams.Set(Parameters.UseSkippedAveraging, "true");
var trainer = TrainerFactory.GetEventTrainer(trainParams, null, null);
var model = trainer.Train(PrepAttachDataUtility.CreateTrainingStream());
PrepAttachDataUtility.TestModel(model, 0.773706362961129);
}
public void TestQnOnPrepAttachDataInParallel()
{
var trainParams = new TrainingParameters();
trainParams.Set(Parameters.Algorithm, Parameters.Algorithms.MaxEntQn);
//trainParams.Set(Parameters.Iterations, "100");
trainParams.Set(Parameters.Threads, "2");
var trainer = TrainerFactory.GetEventTrainer(trainParams, null, null);
var model = trainer.Train(PrepAttachDataUtility.CreateTrainingStream());
TestModel(model, 0.8115870264917059);
}
public void TestPerceptronOnPrepAttachDataWithTolerance()
{
var trainParams = new TrainingParameters();
trainParams.Set(Parameters.Algorithm, Parameters.Algorithms.Perceptron);
trainParams.Set(Parameters.Cutoff, "1");
trainParams.Set(Parameters.Iterations, "500");
trainParams.Set(Parameters.Tolerance, "0.0001");
var trainer = TrainerFactory.GetEventTrainer(trainParams, null, null);
var model = trainer.Train(PrepAttachDataUtility.CreateTrainingStream());
PrepAttachDataUtility.TestModel(model, 0.7677642980935875);
}
public void TestMaxentOnPrepAttachDataWithParams()
{
var reportMap = new Dictionary <string, string>();
var trainParams = new TrainingParameters();
trainParams.Set(Parameters.Algorithm, Parameters.Algorithms.MaxEnt);
trainParams.Set(Parameters.DataIndexer, Parameters.DataIndexers.TwoPass);
trainParams.Set(Parameters.Cutoff, "1");
var trainer = TrainerFactory.GetEventTrainer(trainParams, reportMap, null);
var model = trainer.Train(PrepAttachDataUtility.CreateTrainingStream());
PrepAttachDataUtility.TestModel(model, 0.7997028967566229d);
}
/// <summary>
/// Trains a lemmatizer model with the given parameters.
/// </summary>
/// <param name="languageCode">The language code.</param>
/// <param name="samples">The data samples.</param>
/// <param name="parameters">The machine learnable parameters.</param>
/// <param name="factory">The sentence detector factory.</param>
/// <param name="monitor">
/// A evaluation monitor that can be used to listen the messages during the training or it can cancel the training
/// operation.
/// This argument can be a <c>null</c> value.
/// </param>
/// <returns>The trained <see cref="LemmatizerModel" /> object.</returns>
/// <exception cref="System.InvalidOperationException">The trainer was not specified.</exception>
/// <exception cref="System.NotSupportedException">Trainer type is not supported.</exception>
public static LemmatizerModel Train(string languageCode, IObjectStream <LemmaSample> samples, TrainingParameters parameters, LemmatizerFactory factory, Monitor monitor)
{
var manifestInfoEntries = new Dictionary <string, string>();
var beamSize = parameters.Get(Parameters.BeamSize, DefaultBeamSize);
var cg = factory.GetContextGenerator();
var trainerType = TrainerFactory.GetTrainerType(parameters);
if (!trainerType.HasValue)
{
throw new InvalidOperationException("The trainer was not specified.");
}
IMaxentModel model = null;
ML.Model.ISequenceClassificationModel <string> seqModel = null;
switch (trainerType)
{
case TrainerType.EventModelTrainer:
var s1 = new LemmaSampleEventStream(samples, cg);
var t1 = TrainerFactory.GetEventTrainer(parameters, manifestInfoEntries, monitor);
model = t1.Train(s1);
break;
case TrainerType.EventModelSequenceTrainer:
var s2 = new LemmaSampleSequenceStream(samples, cg);
var t2 = TrainerFactory.GetEventModelSequenceTrainer(parameters, manifestInfoEntries, monitor);
model = t2.Train(s2);
break;
case TrainerType.SequenceTrainer:
var s3 = new LemmaSampleSequenceStream(samples, cg);
var t3 = TrainerFactory.GetSequenceModelTrainer(parameters, manifestInfoEntries, monitor);
seqModel = t3.Train(s3);
break;
default:
throw new NotSupportedException("Trainer type is not supported.");
}
return(model != null
? new LemmatizerModel(languageCode, model, beamSize, manifestInfoEntries, factory)
: new LemmatizerModel(languageCode, seqModel, manifestInfoEntries, factory));
}
/// <summary>
/// Trains sentence detection model with the given parameters.
/// </summary>
/// <param name="languageCode">The language code.</param>
/// <param name="samples">The data samples.</param>
/// <param name="factory">The sentence detector factory.</param>
/// <param name="parameters">The machine learnable parameters.</param>
/// <param name="monitor">
/// A evaluation monitor that can be used to listen the messages during the training or it can cancel the training operation.
/// This argument can be a <c>null</c> value.
/// </param>
/// <returns>The trained <see cref="SentenceModel"/> object.</returns>
public static SentenceModel Train(string languageCode, IObjectStream <SentenceSample> samples, SentenceDetectorFactory factory, TrainingParameters parameters, Monitor monitor)
{
var manifestInfoEntries = new Dictionary <string, string>();
// TODO: Fix the EventStream to throw exceptions when training goes wrong
var eventStream = new SentenceEventStream(
samples,
factory.GetContextGenerator(),
factory.GetEndOfSentenceScanner());
var trainer = TrainerFactory.GetEventTrainer(parameters, manifestInfoEntries, monitor);
var model = trainer.Train(eventStream);
return(new SentenceModel(languageCode, model, manifestInfoEntries, factory));
}
/// <summary>
/// Trains a Part of Speech model with the given parameters.
/// </summary>
/// <param name="languageCode">The language code.</param>
/// <param name="samples">The data samples.</param>
/// <param name="parameters">The machine learnable parameters.</param>
/// <param name="factory">The sentence detector factory.</param>
/// <param name="monitor">
/// A evaluation monitor that can be used to listen the messages during the training or it can cancel the training operation.
/// This argument can be a <c>null</c> value.
/// </param>
/// <returns>The trained <see cref="POSModel"/> object.</returns>
/// <exception cref="System.NotSupportedException">Trainer type is not supported.</exception>
public static POSModel Train(string languageCode, IObjectStream <POSSample> samples, TrainingParameters parameters, POSTaggerFactory factory, Monitor monitor)
{
//int beamSize = trainParams.Get(Parameters.BeamSize, NameFinderME.DefaultBeamSize);
var contextGenerator = factory.GetPOSContextGenerator();
var manifestInfoEntries = new Dictionary <string, string>();
var trainerType = TrainerFactory.GetTrainerType(parameters);
IMaxentModel posModel = null;
ML.Model.ISequenceClassificationModel <string> seqPosModel = null;
switch (trainerType)
{
case TrainerType.EventModelTrainer:
var es = new POSSampleEventStream(samples, contextGenerator);
var trainer = TrainerFactory.GetEventTrainer(parameters, manifestInfoEntries, monitor);
posModel = trainer.Train(es);
break;
case TrainerType.EventModelSequenceTrainer:
var ss = new POSSampleSequenceStream(samples, contextGenerator);
var trainer2 = TrainerFactory.GetEventModelSequenceTrainer(parameters, manifestInfoEntries, monitor);
posModel = trainer2.Train(ss);
break;
case TrainerType.SequenceTrainer:
var trainer3 = TrainerFactory.GetSequenceModelTrainer(parameters, manifestInfoEntries, monitor);
// TODO: This will probably cause issue, since the feature generator uses the outcomes array
var ss2 = new POSSampleSequenceStream(samples, contextGenerator);
seqPosModel = trainer3.Train(ss2);
break;
default:
throw new NotSupportedException("Trainer type is not supported.");
}
if (posModel != null)
{
return(new POSModel(languageCode, posModel, manifestInfoEntries, factory));
}
return(new POSModel(languageCode, seqPosModel, manifestInfoEntries, factory));
}
public void TestQnOnPrepAttachDataWithL2Params()
{
var trainParams = new TrainingParameters();
trainParams.Set(Parameters.Algorithm, Parameters.Algorithms.MaxEntQn);
trainParams.Set(Parameters.DataIndexer, Parameters.DataIndexers.TwoPass);
trainParams.Set(Parameters.Cutoff, "1");
trainParams.Set(Parameters.L1Cost, "0");
trainParams.Set(Parameters.L2Cost, "1.0");
var trainer = TrainerFactory.GetEventTrainer(trainParams, null, null);
var model = trainer.Train(PrepAttachDataUtility.CreateTrainingStream());
TestModel(model, 0.8227283981183461);
}
/// <summary>
/// Trains a chunker model with the given parameters.
/// </summary>
/// <param name="languageCode">The language code.</param>
/// <param name="samples">The data samples.</param>
/// <param name="parameters">The machine learnable parameters.</param>
/// <param name="factory">The sentence detector factory.</param>
/// <param name="monitor">
/// A evaluation monitor that can be used to listen the messages during the training or it can cancel the training operation.
/// This argument can be a <c>null</c> value.</param>
/// <returns>The trained <see cref="ChunkerModel"/> object.</returns>
/// <exception cref="System.InvalidOperationException">The trainer was not specified.</exception>
/// <exception cref="System.NotSupportedException">Trainer type is not supported.</exception>
public static ChunkerModel Train(string languageCode, IObjectStream <ChunkSample> samples, TrainingParameters parameters, ChunkerFactory factory, Monitor monitor)
{
var trainerType = TrainerFactory.GetTrainerType(parameters);
if (!trainerType.HasValue)
{
throw new InvalidOperationException("The trainer was not specified.");
}
var manifestInfoEntries = new Dictionary <string, string>();
IMaxentModel chunkerModel = null;
ML.Model.ISequenceClassificationModel <string> seqChunkerModel = null;
switch (trainerType)
{
case TrainerType.SequenceTrainer:
var st = TrainerFactory.GetSequenceModelTrainer(parameters, manifestInfoEntries, monitor);
// TODO: This will probably cause issue, since the feature generator uses the outcomes array
var ss = new ChunkSampleSequenceStream(samples, factory.GetContextGenerator());
seqChunkerModel = st.Train(ss);
break;
case TrainerType.EventModelTrainer:
var es = new ChunkerEventStream(samples, factory.GetContextGenerator());
var et = TrainerFactory.GetEventTrainer(parameters, manifestInfoEntries, monitor);
chunkerModel = et.Train(es);
break;
default:
throw new NotSupportedException("Trainer type is not supported.");
}
var beamSize = parameters.Get(Parameters.BeamSize, DefaultBeamSize);
return(chunkerModel != null
? new ChunkerModel(languageCode, chunkerModel, beamSize, manifestInfoEntries, factory)
: new ChunkerModel(languageCode, seqChunkerModel, manifestInfoEntries, factory));
}
public void firstInitialize()
{
ClientFactory clientFactory = new ClientFactory();
ClientGateway <Client> cg = (ClientGateway <Client>)clientFactory.GetClient();
TrainerFactory trainerFactory = new TrainerFactory();
TrainerGateway <Trainer> trainerg = (TrainerGateway <Trainer>)trainerFactory.GetTrainer();
LockerFactory lockerFactory = new LockerFactory();
LockerGateway <Locker> lg = (LockerGateway <Locker>)lockerFactory.GetLocker();
clients = cg.SelectForTrainingStartEnd(true);
trainers = trainerg.Select();
lockers = lg.Select();
Collection <string> clientNames = new Collection <string>();
foreach (Client c in clients)
{
clientNames.Add(c.ToString());
}
comboClient.DataSource = clientNames;
Collection <Locker> filteredLockers = new Collection <Locker>();
Collection <string> lockerNames = new Collection <string>();
foreach (Locker l in lockers)
{
if (l.Status != "taken")
{
filteredLockers.Add(l);
}
}
foreach (Locker l in filteredLockers)
{
lockerNames.Add(l.ToString());
}
comboLocker.DataSource = lockerNames;
Collection <string> trainerNames = new Collection <string>();
foreach (Trainer t in trainers)
{
trainerNames.Add(t.ToString());
}
comboTrainer.DataSource = trainerNames;
}
public void TestNaiveBayesOnPrepAttachDataUsingTrainUtilWithCutoff5()
{
var parameters = TrainingParameters.DefaultParameters();
parameters.Set(Parameters.Algorithm, Parameters.Algorithms.NaiveBayes);
parameters.Set(Parameters.Cutoff, "5");
var trainer = TrainerFactory.GetEventTrainer(parameters, null, null);
Assert.NotNull(trainer);
Assert.IsInstanceOf <NaiveBayesTrainer>(trainer);
var model = trainer.Train(PrepAttachDataUtility.CreateTrainingStream());
Assert.NotNull(model);
PrepAttachDataUtility.TestModel(model, 0.7945035899975241);
}
protected void RefreshData()
{
TrainingFactory trainingFactory = new TrainingFactory();
TrainingGateway <Training> tg = (TrainingGateway <Training>)trainingFactory.GetTraining();
TicketFactory ticketFactory = new TicketFactory();
TicketGateway <Ticket> ticketg = (TicketGateway <Ticket>)ticketFactory.GetTicket();
ClientFactory clientFactory = new ClientFactory();
ClientGateway <Client> cg = (ClientGateway <Client>)clientFactory.GetClient();
TrainerFactory trainerFactory = new TrainerFactory();
TrainerGateway <Trainer> trainerg = (TrainerGateway <Trainer>)trainerFactory.GetTrainer();
Collection <Training> trainings = tg.Select();
Collection <TrainGrid> trainGrid = new Collection <TrainGrid>();
foreach (Training t in trainings)
{
TrainGrid tgrid = new TrainGrid();
tgrid.LockerId = t.LockerId;
tgrid.ToGender = t.ToGender;
tgrid.Start = t.TimeFrom;
tgrid.End = t.TimeTo;
// using factory to get data
Client c = cg.Select(t.ClientId);
tgrid.ClientName = c.Name + " " + c.Surname;
int tempId;
if (t.TrainerId.HasValue)
{
tempId = t.TrainerId.Value;
Trainer tr = trainerg.Select(tempId);
tgrid.TrainerName = tr.Name + " " + tr.Surname;
}
else
{
tgrid.TrainerName = "";
}
trainGrid.Add(tgrid);
}
BindingList <TrainGrid> bindingList = new BindingList <TrainGrid>(trainGrid);
trainingsGrid.AutoGenerateColumns = false;
trainingsGrid.DataSource = bindingList;
}
public ConnectionistFactory(ILinearAlgebraProvider lap, bool stochastic = true)
{
_lap = lap;
_stochastic = stochastic;
_trainer = new TrainerFactory(lap);
_weightUpdater = new UpdaterFactory(lap);
_activation.Add(ActivationType.Relu, new Relu());
_activation.Add(ActivationType.LeakyRelu, new LeakyRelu());
_activation.Add(ActivationType.Sigmoid, new Sigmoid());
_activation.Add(ActivationType.Tanh, new Tanh());
//_activation.Add(ActivationType.Softmax, new Softmax());
_activation.Add(ActivationType.None, null);
_weightInitialisation.Add(WeightInitialisationType.Gaussian, new Gaussian(stochastic));
_weightInitialisation.Add(WeightInitialisationType.Xavier, new Xavier(stochastic));
_weightInitialisation.Add(WeightInitialisationType.Identity, new Identity());
_weightInitialisation.Add(WeightInitialisationType.Identity1, new Identity(0.1f));
_weightInitialisation.Add(WeightInitialisationType.Identity01, new Identity(0.01f));
_weightInitialisation.Add(WeightInitialisationType.Identity001, new Identity(0.001f));
}
/// <summary>
/// Trains a parser model with the given parameters.
/// </summary>
/// <param name="languageCode">The language code.</param>
/// <param name="samples">The data samples.</param>
/// <param name="rules">The head rules.</param>
/// <param name="parameters">The machine learnable parameters.</param>
/// <param name="monitor">
/// A evaluation monitor that can be used to listen the messages during the training or it can cancel the training operation.
/// This argument can be a <c>null</c> value.
/// </param>
/// <returns>The trained <see cref="ParserModel"/> object.</returns>
/// <exception cref="System.NotSupportedException">Trainer type is not supported.</exception>
public static ParserModel Train(
string languageCode,
IObjectStream <Parse> samples,
AbstractHeadRules rules,
TrainingParameters parameters,
Monitor monitor)
{
var manifestInfoEntries = new Dictionary <string, string>();
System.Diagnostics.Debug.Print("Building dictionary");
var dictionary = BuildDictionary(samples, rules, parameters);
samples.Reset();
// tag
var posModel = POSTaggerME.Train(
languageCode,
new PosSampleStream(samples),
parameters.GetNamespace("tagger"),
new POSTaggerFactory(), monitor);
samples.Reset();
// chunk
var chunkModel = ChunkerME.Train(
languageCode,
new ChunkSampleStream(samples),
parameters.GetNamespace("chunker"),
new ChunkerFactory(), monitor);
samples.Reset();
// build
System.Diagnostics.Debug.Print("Training builder");
var bes = new ParserEventStream(samples, rules, ParserEventTypeEnum.Build, dictionary);
var buildReportMap = new Dictionary <string, string>();
var buildTrainer = TrainerFactory.GetEventTrainer(parameters.GetNamespace("build"), buildReportMap, monitor);
var buildModel = buildTrainer.Train(bes);
Chunking.Parser.MergeReportIntoManifest(manifestInfoEntries, buildReportMap, "build");
samples.Reset();
// check
System.Diagnostics.Debug.Print("Training checker");
var kes = new ParserEventStream(samples, rules, ParserEventTypeEnum.Check);
var checkReportMap = new Dictionary <string, string>();
var checkTrainer = TrainerFactory.GetEventTrainer(parameters.GetNamespace("check"), checkReportMap, monitor);
var checkModel = checkTrainer.Train(kes);
Chunking.Parser.MergeReportIntoManifest(manifestInfoEntries, checkReportMap, "check");
samples.Reset();
// attach
System.Diagnostics.Debug.Print("Training attacher");
var attachEvents = new ParserEventStream(samples, rules, ParserEventTypeEnum.Attach);
var attachReportMap = new Dictionary <string, string>();
var attachTrainer = TrainerFactory.GetEventTrainer(parameters.GetNamespace("attach"), attachReportMap, monitor);
var attachModel = attachTrainer.Train(attachEvents);
Chunking.Parser.MergeReportIntoManifest(manifestInfoEntries, attachReportMap, "attach");
return(new ParserModel(
languageCode,
buildModel,
checkModel,
attachModel,
posModel,
chunkModel,
rules,
ParserType.TreeInsert,
manifestInfoEntries));
}
public void TestCustomTrainer3()
{
Assert.Throws <InvalidOperationException> (() => {
TrainerFactory.RegisterTrainer("Nothing", typeof(object));
});
}
protected void Page_Load(object sender, EventArgs e)
{
TrainerFactory trainerFactory = new TrainerFactory();
TrainerGateway <Trainer> trainerg = (TrainerGateway <Trainer>)trainerFactory.GetTrainer();
if (Session["ID"] == null)
{
Response.Redirect("~/Login.aspx");
}
trainers = trainerg.Select();
Collection <string> trainerNames = new Collection <string>();
foreach (Trainer tr in trainers)
{
trainerNames.Add(tr.ToString());
}
starNumbers = new Collection <string> {
"1",
"2",
"3",
"4",
"5"
};
if (!IsPostBack)
{
trainerStars.DataSource = starNumbers;
trainerStars.DataBind();
trainerDropdownId.DataSource = trainerNames;
trainerDropdownId.DataBind();
}
if (Session["rated"] != null)
{
ratedTrainerText.Attributes.Add("class", "blocked");
ratedTrainer.Style.Add("display", "inline-block");
thankRating.Style.Add("display", "inline-block");
theDiv.Style.Add("display", "none");
averageRating.Style.Add("display", "inline-block");
averageRatingText.Style.Add("display", "inline-block");
clientsRatedTop.Style.Add("display", "inline-block");
ratedTrainer.Text = Session["ratedTrainer"].ToString();
var temp = trainerg.SelectAVG(int.Parse(Session["ratedTrainerId"].ToString()));
averageRating.Text = temp[0].ToString();
clientsRated.Text = temp[1].ToString();
Session["rated"] = null;
Session["ratedTrainer"] = null;
Session["ratedTrainerId"] = null;
}
else
{
ratedTrainerText.Style.Add("display", "none");
ratedTrainer.Style.Add("display", "none");
thankRating.Style.Add("display", "none");
averageRating.Style.Add("display", "none");
averageRatingText.Style.Add("display", "none");
clientsRatedTop.Style.Add("display", "none");
}
}
public void TestInvalidTrainer()
{
mlParams.Set(Parameters.Algorithm, "Nop");
Assert.False(TrainerFactory.IsValid(mlParams));
}
