public RegressionWindow(PlotModel plotModel, LearningResult learningResult, string identifier)
{
InitializeComponent();
RegressionPlot.Model = plotModel;
this.Title = string.Format("{0}: TS Dir {1} TS Err {2}", identifier,
learningResult.MPVer1.ToString("E2"), learningResult.TestSetError.ToString("E2"));
}
private void startEvaluatorButton_Click(object sender, RoutedEventArgs e)
{
FieldDataAnalyzerDBEntities db = new FieldDataAnalyzerDBEntities();
DateTime dateFrom = new DateTime(), dateTo = new DateTime();
if (allDataCheckBox.IsChecked == true)
{
dateFrom = db.wells_measurements.Min(x => x.measure_date);
dateTo = db.wells_measurements.Max(x => x.measure_date);
}
else
{
if ((fromDatePicker.SelectedDate == null) || (toDatePicker.SelectedDate == null))
{
MessageBox.Show("Не выбран период расчета.");
return;
}
dateFrom = (DateTime)fromDatePicker.SelectedDate;
dateTo = (DateTime)toDatePicker.SelectedDate;
}
Evaluator evaluator = new Evaluator(graph, fieldDescription, coefsProgressBar);
results = evaluator.Calc(dateFrom, dateTo);
finalGatherPointGrid.ItemsSource = results.GPResults;
finalGatherPointGrid.SelectedIndex = 0;
Coef_P_Label.Content = String.Format("Давление (Kp): {0}", results.Coef_P);
Coef_T_Label.Content = String.Format("Температура (Kt): {0}", results.Coef_T);
}
public void CreateAutomatedMappings()
{
//Arrange
var crudRepo = new EfRepository <EntityMapping>(_db, _authAdapter);
var logger = new InMemoryLogger();
var repo = new EntityMappingRepository(crudRepo, logger, null, null);
var trainingData = new List <Mapping>
{
new Mapping
{
Source = "Commodity",
Destination = "commodity"
}
};
repo.CreateMapping(new ManualMapping
{
Mappings = trainingData,
SourceId = _sourceSystemId,
DestinationId = _destinationSystemId
});
var learntMappings = new List <LearntMapping>
{
new LearntMapping {
Mapping = new Mapping
{
Source = "Variety",
Destination = "variety"
}
},
new LearntMapping
{
Mapping = new Mapping
{
Source = "Farm",
Destination = "farm"
}
}
};
var learningResult = new LearningResult(learntMappings);
//Act
var result = repo.CreateMapping(new AutomatedMapping
{
LearningResult = learningResult,
SourceId = _sourceSystemId,
DestinationId = _destinationSystemId
});
//Assert
Assert.AreEqual(learntMappings.Count, result);
}
private void DisplayResults(PlotModel regressionPlot, PlotModel errorPlot, LearningResult learningResult, string identifier)
{
Window errorWindow = new NetworkErrorWindow(errorPlot, identifier);
errorWindow.Show();
Window regressionWindow = new RegressionWindow(regressionPlot, learningResult, identifier);
regressionWindow.Show();
}
private static void WriteSeedVectors(TextWriter writer, LearningResult learningResult)
{
writer.WriteLine("################ Seed Accepted Vectors ################");
var seedAcceptedVectors =
learningResult.EncodingResult.SeedAcceptedVector2GroupPath.Keys;
foreach (var vector in seedAcceptedVectors)
{
writer.WriteLine("--------------------------------------");
if (learningResult.EncodingResult.Vector2Node != null)
{
writer.WriteLine(learningResult.EncodingResult.Vector2Node[vector].Code);
writer.WriteLine(GetGoodAncestorNode(
learningResult.EncodingResult.Vector2Node[vector]).Code);
}
var features = learningResult.FeatureEncoder.GetFeatureStringsByVector(vector);
foreach (var feature in features)
{
if (feature.Contains("Requires") || feature.Contains("Contract"))
{
writer.WriteLine(Beautify(feature));
}
}
writer.WriteLine();
}
writer.WriteLine("################ Seed Rejected Vectors ################");
var seedRejectedVectors =
learningResult.EncodingResult.SeedAcceptedVector2GroupPath.Keys;
foreach (var vector in seedRejectedVectors)
{
writer.WriteLine("--------------------------------------");
if (learningResult.EncodingResult.Vector2Node != null)
{
writer.WriteLine(learningResult.EncodingResult.Vector2Node[vector].Code);
writer.WriteLine(GetGoodAncestorNode
(learningResult.EncodingResult.Vector2Node[vector]).Code);
}
var features = learningResult.FeatureEncoder.GetFeatureStringsByVector(vector);
foreach (var feature in features)
{
if (learningResult.EncodingResult.Vector2Node != null)
{
writer.WriteLine(learningResult.EncodingResult.Vector2Node[vector].Code);
}
if (feature.Contains("Requires") || feature.Contains("Contract"))
{
writer.WriteLine(Beautify(feature));
}
}
writer.WriteLine();
}
}
private static void PrintWrongResults(
ClassificationResult classificationResult, LearningResult learningResult)
{
var nodeAndVectors = new[] {
classificationResult.WronglyAcceptedNodes
.Zip(classificationResult.WronglyAcceptedVectors, Tuple.Create),
classificationResult.WronglyRejectedNodes
.Zip(classificationResult.WronglyRejectedVectors, Tuple.Create)
};
var titles = new[] {
"WronglyAcceptedNodes", "WronglyRejectedNodes"
};
for (int i = 0; i < nodeAndVectors.Length; i++)
{
Console.WriteLine("--------------- " + titles[i] + " ---------------");
foreach (var nodeAndVector in nodeAndVectors[i])
{
var node = nodeAndVector.Item1;
var vector = nodeAndVector.Item2;
Console.WriteLine(node.Code);
Console.WriteLine(GetGoodAncestorNode(node).Code);
var groupPath = learningResult.FeatureEncoder.GetGroupPathFromNode(node);
var groupIndex = learningResult.Classifier.GetGroupIndex(groupPath);
Console.WriteLine("Group: " + (groupIndex + 1) + " (" + groupPath + ")");
Console.WriteLine("IsAccepted: "
+ learningResult.Classifier.IsAccepted(vector, groupIndex));
Console.WriteLine("IsRejected: "
+ learningResult.Classifier.IsRejected(vector, groupIndex));
var featureStrings =
learningResult.FeatureEncoder.GetFeatureStringsByVector(vector);
foreach (var featureString in featureStrings)
{
Console.WriteLine(Beautify(featureString));
}
if (i == 1)
{
Console.WriteLine("------------- Rejcting Features -------------");
var negativeVector = vector
& learningResult.Classifier.Units[groupIndex].Rejecting;
featureStrings =
learningResult.FeatureEncoder.GetFeatureStringsByVector(
negativeVector);
foreach (var featureString in featureStrings)
{
Console.WriteLine(Beautify(featureString));
}
}
Console.WriteLine("---------------------------------------------");
}
}
}
private string GetResultInfo(LearningSettings settings, LearningResult result, List <int> neuronCounts, INetwork network, DateTime now)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine(settings.ToString());
sb.Append(now.ToLongDateString());
sb.Append(" ");
sb.AppendLine(now.ToLongTimeString());
sb.AppendLine(System.IO.Path.GetFileName(eid.DataSetName));
sb.AppendFormat("Layer counts: {0}\r\n", string.Join("-", neuronCounts));
sb.AppendLine(result.ToString());
return(sb.ToString());
}
private void StartButtonClick(object sender, RoutedEventArgs e)
{
var layers = LayersTextBox.Text.Split(new string[] { ",", " ", "-", "_", "." }, StringSplitOptions.RemoveEmptyEntries);
List <int> layersVal = new List <int>();
foreach (var layer in layers)
{
layersVal.Add(int.Parse(layer));
}
YesNo bias = (YesNo)BiasCombobox.SelectedItem;
ActivationFunction activation = (ActivationFunction)ActivationCombobox.SelectedItem;
int iterations = int.Parse(Iterations.Text);
double learningRate = LearningRateSlider.Value;
double momentum = MomentumSlider.Value;
BackpropagationRunMode runMode = (BackpropagationRunMode)RunCombobox.SelectedItem;
ProblemType problem = (ProblemType)ProblemCombobox.SelectedItem;
CasesData trainingCases;
CasesData testCases;
YesNo appendTestFile = (YesNo)AppendTestCombobox.SelectedItem;
int input = testData.First().Count();
int output = trainingData.First().Count() - input;
CasesData.InitializeAllData(trainingData, testData, problem, out trainingCases, out testCases);
layersVal.Insert(0, input);
layersVal.Add((problem == ProblemType.Regression) ? output : trainingCases.ClassCount);
NeuralNetwork network = new NeuralNetwork(
(activation == ActivationFunction.Bipolar) ? (IActivation) new BipolarTanhActivation() : new UnipolarSigmoidActivation(),
bias == YesNo.Yes, layersVal.ToArray());
LearningResult learningResult = BackpropagationManager.Run(network, trainingCases, testCases,
runMode, iterations, learningRate, momentum);
if (appendTestFile == YesNo.Yes)
{
AppendCSVile(testDataPath, testCases);
}
ShowNetworkErrorWindow(learningResult);
if (problem == ProblemType.Regression)
{
ShowRegressionWindow(network, trainingCases, testCases);
}
else if (problem == ProblemType.Classification)
{
ShowClassificationWindow(network, trainingCases, testCases);
}
}
public LearningResult Run(ILearningStrategy learningStrategy,
LearningSettings lSettings, IStatusReporter statusHolder)
{
//AssertArguments(trainData, testData, learningRate); // TODO: write assertions
if (!network.IsInitialized)
{
network.Initialize(CreationModes.RandomizeWeights);
}
LearningResult learningResult = new LearningResult();
learningResult.MSEHistory = learningStrategy.Train(network, trainSet, statusHolder);
learningResult.TestSetError = AnswerTestSet();
learningResult.DirectionGuessRate = CalculateDirectionGuessed(DirectionGuess.NetworkToNetwork);
learningResult.DirectionGuessVer2 = CalculateDirectionGuessed(DirectionGuess.IdealToNetwork);
learningResult.TimeTaken = learningStrategy.TimeTaken;
learningResult.GotStuck = learningStrategy.GotStuck;
return(learningResult);
}
public void SaveModel(LearningResult learningResult)
{
if (learningResult == null)
{
throw new ArgumentNullException(nameof(learningResult));
}
var filename = _fileSystem.Path.Combine(_outputDir,
$"{learningResult.Name}_{DateTime.Now.ToString(_dateFormat)}");
var jsonFile = $"{filename}.json";
var modelPath = $"{filename}.zip";
var json = JsonConvert.SerializeObject(learningResult, Formatting.Indented);
_fileSystem.File.WriteAllText(jsonFile, json);
_mlContext.Model.Save(learningResult.Model, learningResult.Schema, modelPath);
using (var stream = _fileSystem.FileStream.Create(modelPath, FileMode.Create))
{
_mlContext.Model.Save(learningResult.Model, learningResult.Schema, stream);
}
}
public SingleRunReport(INetwork net, DateTime time, LearningResult lres, IDataSet train, IDataSet test)
: this(net, time, lres)
{
TrainSet = train;
TestSet = test;
}
public SingleRunReport(INetwork net, DateTime time, LearningResult lres)
{
LearningResult = lres;
Network = net;
Time = time;
}
private void ShowNetworkErrorWindow(LearningResult result)
{
Window errorWindow = new NetworkErrorWindow(result.MSEHistory);
errorWindow.Show();
}
private static void PrintWrongResults(
ClassificationResult classificationResult, LearningResult learningResult) {
var nodeAndVectors = new[] {
classificationResult.WronglyAcceptedNodes
.Zip(classificationResult.WronglyAcceptedVectors, Tuple.Create),
classificationResult.WronglyRejectedNodes
.Zip(classificationResult.WronglyRejectedVectors, Tuple.Create)
};
var titles = new[] {
"WronglyAcceptedNodes", "WronglyRejectedNodes"
};
for (int i = 0; i < nodeAndVectors.Length; i++) {
Console.WriteLine("--------------- " + titles[i] + " ---------------");
foreach (var nodeAndVector in nodeAndVectors[i]) {
var node = nodeAndVector.Item1;
var vector = nodeAndVector.Item2;
Console.WriteLine(node.Code);
Console.WriteLine(GetGoodAncestorNode(node).Code);
var groupPath = learningResult.FeatureEncoder.GetGroupPathFromNode(node);
var groupIndex = learningResult.Classifier.GetGroupIndex(groupPath);
Console.WriteLine("Group: " + (groupIndex + 1) + " (" + groupPath + ")");
Console.WriteLine("IsAccepted: "
+ learningResult.Classifier.IsAccepted(vector, groupIndex));
Console.WriteLine("IsRejected: "
+ learningResult.Classifier.IsRejected(vector, groupIndex));
var featureStrings =
learningResult.FeatureEncoder.GetFeatureStringsByVector(vector);
foreach (var featureString in featureStrings) {
Console.WriteLine(Beautify(featureString));
}
if (i == 1) {
Console.WriteLine("------------- Rejcting Features -------------");
var negativeVector = vector
& learningResult.Classifier.Units[groupIndex].Rejecting;
featureStrings =
learningResult.FeatureEncoder.GetFeatureStringsByVector(
negativeVector);
foreach (var featureString in featureStrings) {
Console.WriteLine(Beautify(featureString));
}
}
Console.WriteLine("---------------------------------------------");
}
}
}
private static void WriteSeedVectors(TextWriter writer, LearningResult learningResult) {
writer.WriteLine("################ Seed Accepted Vectors ################");
var seedAcceptedVectors =
learningResult.EncodingResult.SeedAcceptedVector2GroupPath.Keys;
foreach (var vector in seedAcceptedVectors) {
writer.WriteLine("--------------------------------------");
if (learningResult.EncodingResult.Vector2Node != null) {
writer.WriteLine(learningResult.EncodingResult.Vector2Node[vector].Code);
writer.WriteLine(GetGoodAncestorNode(
learningResult.EncodingResult.Vector2Node[vector]).Code);
}
var features = learningResult.FeatureEncoder.GetFeatureStringsByVector(vector);
foreach (var feature in features) {
if (feature.Contains("Requires") || feature.Contains("Contract")) {
writer.WriteLine(Beautify(feature));
}
}
writer.WriteLine();
}
writer.WriteLine("################ Seed Rejected Vectors ################");
var seedRejectedVectors =
learningResult.EncodingResult.SeedAcceptedVector2GroupPath.Keys;
foreach (var vector in seedRejectedVectors) {
writer.WriteLine("--------------------------------------");
if (learningResult.EncodingResult.Vector2Node != null) {
writer.WriteLine(learningResult.EncodingResult.Vector2Node[vector].Code);
writer.WriteLine(GetGoodAncestorNode
(learningResult.EncodingResult.Vector2Node[vector]).Code);
}
var features = learningResult.FeatureEncoder.GetFeatureStringsByVector(vector);
foreach (var feature in features) {
if (learningResult.EncodingResult.Vector2Node != null) {
writer.WriteLine(learningResult.EncodingResult.Vector2Node[vector].Code);
}
if (feature.Contains("Requires") || feature.Contains("Contract")) {
writer.WriteLine(Beautify(feature));
}
}
writer.WriteLine();
}
}
