/// See <see cref="IDiffService.SaveDataItemAsync(int, DiffItemSide, string)"/> for more information.
public async Task <int> SaveDataItemAsync(int diffId, DiffItemSide itemSide, string encodedData)
{
// Assumption: We do not want to save invalid or empty data.
if (!EncodingHelper.IsValidBase64Data(encodedData))
{
throw new ArgumentException("The input data is in incorrect format", nameof(encodedData));
}
DataItem item;
bool doDiffExists = await _differenceRepository.AnyAsync(d => d.Id == diffId);
if (!doDiffExists)
{
item = DataItemFactory.CreateDataItem(itemSide, encodedData);
Difference diff = DifferenceFactory.CreateDifference(diffId, item);
await _differenceRepository.CreateAsync(diff);
await _differenceRepository.SaveChangesAsync();
}
else
{
// Assumption: If an item on the same side already exists, the code throws an error.
bool doItemExists = await _dataItemRepository.AnyAsync(di => di.DifferenceId == diffId && di.Side == itemSide);
if (doItemExists)
{
throw new InvalidOperationException($"Diff with ID {diffId} already contains {itemSide.ToString().ToLower()} data item.");
}
item = DataItemFactory.CreateDataItem(diffId, itemSide, encodedData);
await _dataItemRepository.CreateAsync(item);
await _dataItemRepository.SaveChangesAsync();
}
return(item.Id);
}
/// <summary>
/// Parser data.
/// </summary>
/// <param name="context"></param>
public void ParseData(IParserContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (context.Header.MajorVersion != MajorVersion)
{
throw new InvalidFileVersionException(MajorVersion, context.Header.MajorVersion);
}
Context = context;
Context.Header.DirectoryEntries.ForEach(
entry =>
{
IAb1DataItem item = DataItemFactory.TryCreateDataItem(entry);
if (item == null)
{
return;
}
item.Accept(this);
});
}
static void Main()
{
Console.WriteLine("Создание нейронной сети...");
DataItem data = DataItemFactory.GetNumericData();
int inputCount = data.Input.First().Length;
var neuronCount = new[] { 10 };
IActivationFunction function = new BipolarSigmoidFunction();
double learningRate = 0.1;
double momentum = 0;
int maxEpochNumber = 1000000;
double minErrorChange = 0.000001;
double minError = 0.001;
var network = MultilayerNeuralNetwork.CreateNetwork(neuronCount, inputCount, function);
network.Randomize();
Console.WriteLine("Создание нейронной сети завершено.");
var teacher = new PerceptronLearning(network)
{
LearningRate = learningRate
};
int epochNumber = 1;
double lastError = double.MaxValue;
double error;
double errorChange;
Console.WriteLine("Start learning...");
do
{
DateTime dtStart = DateTime.Now;
error = teacher.RunEpoch(data.Input, data.Output) / data.Input.Length;
Console.WriteLine(
$"Epoch #{epochNumber} finished; " +
$"current error is {error}; " +
$"it takes: {(DateTime.Now - dtStart).Duration()}");
errorChange = Math.Abs(lastError - error);
lastError = error;
epochNumber++;
}while (epochNumber < maxEpochNumber &&
error > minError &&
errorChange > minErrorChange);
for (int i = 0; i < data.Input.Length; i++)
{
double[] outputs = network.Compute(data.Input[i]);
string strIn = "";
foreach (var input in data.Output[i])
{
strIn += $"{input},";
}
string strOut = "";
foreach (var output in outputs)
{
strOut += $"{Math.Abs(output):0.00},";
}
Console.WriteLine($"{i}. Expected {strIn} Actual {strOut}");
}
}
