protected void RunModel(int foldN, IModel <LblT, ModelExT> model,
ILabeledDataset <LblT, InputExT> trainSet, ILabeledDataset <LblT, ModelExT> mappedTrainSet,
ILabeledDataset <LblT, InputExT> testSet, ILabeledDataset <LblT, ModelExT> mappedTestSet, CrossValidationTimeProfile modelProfile)
{
// train
ILabeledDataset <LblT, ModelExT> usedTrainSet = BeforeTrain(foldN, model, trainSet, mappedTrainSet);
Train(foldN, model, usedTrainSet);
AfterTrain(foldN, model, usedTrainSet);
modelProfile.TrainEndTime = DateTime.Now;
// test
modelProfile.TestStartTime = DateTime.Now;
ILabeledDataset <LblT, ModelExT> usedTestSet = BeforeTest(foldN, model, testSet, mappedTestSet);
PerfMatrix <LblT> foldMatrix = GetPerfMatrix(GetModelName(model), foldN);
for (int i = 0; i < usedTestSet.Count; i++)
{
LabeledExample <LblT, ModelExT> le = usedTestSet[i];
Prediction <LblT> prediction = Predict(foldN, model, le);
if (AfterPrediction(foldN, model, testSet[i].Example, le, prediction) && prediction.Any())
{
foldMatrix.AddCount(le.Label, prediction.BestClassLabel);
}
}
modelProfile.TestEndTime = DateTime.Now;
AfterTest(foldN, model, usedTestSet);
}
public void Train(ILabeledExampleCollection <LblT, ExT> dataset)
{
Preconditions.CheckNotNull(dataset);
var trainDataset = new LabeledDataset <LblT, ExT>(dataset);
for (int i = 0; i < mInnerModels.Length; i++)
{
if (mInnerModels[i] == null)
{
mInnerModels[i] = CreateModel(i);
}
mInnerModels[i].Train(GetTrainSet(i, mInnerModels[i], trainDataset));
}
foreach (LabeledExample <LblT, ExT> le in trainDataset)
{
LabeledExample <LblT, ExT> le_ = le;
double[] scores = GetPredictionScores(mInnerModels.Select(m => m.Predict(le_.Example)).ToArray()).ToArray();
mTagDistrTable.AddCount(le.Label, scores);
}
mTagDistrTable.Calculate();
IsTrained = true;
}
public override IEnumerable <LabeledExample <SentimentLabel, T> > GetData <T>()
{
Preconditions.CheckArgument(typeof(T) == typeof(Tweet));
using (var parser = new TextFieldParser(FileName)
{
TextFieldType = FieldType.Delimited
})
{
PrepareParser(parser);
parser.SetDelimiters(Delimiters);
var result = new List <LabeledExample <SentimentLabel, Tweet> >();
while (!parser.EndOfData)
{
string[] fields = parser.ReadFields();
SentimentLabel label;
Tweet tweet;
if (LoadLabeledTweet(fields, out label, out tweet))
{
if (tweet == null && result.Any())
{
result.Last().Label = label;
}
else
{
var labeledTweet = new LabeledExample <SentimentLabel, Tweet>(label, tweet);
result.Add(labeledTweet);
}
}
}
mDataSize = result.Count;
return(result.Cast <LabeledExample <SentimentLabel, T> >());
}
}
public void Train(ILabeledExampleCollection <LblT, ExT> dataset)
{
Preconditions.CheckNotNull(dataset);
var trainDataset = new LabeledDataset <LblT, ExT>(dataset);
for (int i = 0; i < mInnerModels.Length; i++)
{
if (mInnerModels[i] == null)
{
mInnerModels[i] = CreateModel(i);
}
mInnerModels[i].Train(GetTrainSet(i, mInnerModels[i], trainDataset));
}
foreach (LabeledExample <LblT, ExT> le in trainDataset)
{
LabeledExample <LblT, ExT> le_ = le;
string key = StringOf(mInnerModels.Select(m => m.Predict(le_.Example).BestClassLabel));
VotingEntry votingEntry = mVotingEntries[key];
votingEntry.LabelCounts[le.Label]++;
}
foreach (VotingEntry entry in mVotingEntries.Values)
{
PerformVoting(entry);
}
IsTrained = true;
}
public void LabeledExample_ShouldCreateAnInstanceOfThisType_WhenProperArgument()
{
// Arrange
// Act
LabeledExample actual
= new LabeledExample(
ObjectMother.LabeledExample_Id1,
ObjectMother.LabeledExample_Label1,
ObjectMother.LabeledExample_Text1,
ObjectMother.LabeledExample_TextAsNGrams1
);
// Assert
Assert.IsInstanceOf <LabeledExample>(actual);
}
protected virtual bool AfterPrediction(int foldN, IModel <LblT, ModelExT> model, InputExT example,
LabeledExample <LblT, ModelExT> labeledExample, Prediction <LblT> prediction)
{
return(OnAfterPrediction == null || OnAfterPrediction(this, foldN, model, example, labeledExample, prediction));
}
protected virtual Prediction <LblT> Predict(int foldN, IModel <LblT, ModelExT> model, LabeledExample <LblT, ModelExT> le)
{
return(OnPredict != null?OnPredict(this, foldN, model, le) : model.Predict(le.Example));
}
