static void Main(string[] args)
{
Console.WriteLine("-- TEACHING MATRIX -- " + DateTime.Now.ToLongTimeString() + " -");
var teacher = new Teaching(100, 50, 1);
teacher.Progress = DrawProgress;
//умножение на 2 - работает до 7
var inpValues = new byte[] { 1, 2, 3, 4, 5, 6 };
var outValues = new byte[] { 2, 4, 6, 8, 10, 12 };
var res = teacher.Teach(inpValues, outValues, 1000);
Console.CursorTop += teacher.resList.Count > 0 ? teacher.resList[0].yHeight * 2 + 3 : 3;
if (res == TeachingResult.TeachingComplete)
{
Console.WriteLine("Завершено. Всего матриц " + teacher.resList.Count);
MatrixDraw.DrawMatrix(teacher.resList[0]);
}
else if (res == TeachingResult.MaxRowLimitReached)
{
Console.WriteLine("Превышен максимальный размер матрицы.");
Console.ReadKey();
return;
}
else if (res == TeachingResult.ContinueTeaching)
{
Console.WriteLine("Незавершено. Всего матриц: " + teacher.resList.Count);
if (teacher.resList.Count == 0)
{
Console.ReadKey();
return;
}
}
Console.WriteLine();
foreach (var m in teacher.resList)
{
Console.WriteLine("Тест на обучающей выборке");
CheckFoundMatrix(m, inpValues, outValues);
}
while (true)
{
Console.WriteLine("Проверить значение: ");
var read = Console.ReadLine();
if (String.IsNullOrWhiteSpace(read))
{
break;
}
byte intTemp = Convert.ToByte(read);
var matr = new iMatrixSpc.iMatrixByte(teacher.resList[0]);
var mRes = matr.Process(intTemp);
Console.WriteLine(intTemp + " => " + mRes);
}
}
private byte[] GetNextInputsAsOutputs(iMatrixByte m, byte[] teachingInput)
{
var nextOutputs = new List <byte>();
for (int i = 0; i < teachingInput.Length; i++)
{
var nextOut = m.Process(teachingInput[i]);
nextOutputs.Add(nextOut);
}
return(nextOutputs.ToArray());
}
private long ComputeCombinationMetrika(iMatrixByte m, byte[] teachingInput, byte[] teachingOutput, long localMetrika)
{
long combinationMetrika = 0;
for (int i = 0; i < teachingInput.Length; i++)
{
combinationMetrika += Math.Abs(m.Process(teachingInput[i]) - teachingOutput[i]);
if (combinationMetrika > localMetrika)
{
return(combinationMetrika);
}
}
return(combinationMetrika);
}
/// <summary>
///
/// </summary>
/// <param name="teachingInput"></param>
/// <param name="teachingOutput"></param>
/// <param name="matr"></param>
/// <param name="metrika"></param>
/// <param name="level">Высота матрицы (номер добавляемой строки)</param>
/// <param name="levelCount">Номер варианта матрицы на текущем уровне</param>
/// <param name="levelTotal">Всего вариантов матриц на уровне</param>
/// <returns></returns>
private TeachingResult TeachMatrixRow(
byte[] teachingInput,
byte[] teachingOutput,
iMatrix matr,
long metrika,
int level = 1,
int levelCount = 0,
int levelTotal = 1)
{
Debug.WriteLine(String.Format("Метрика {0}", metrika));
long localMetrika = metrika;
iMatrixByte m = new iMatrixByte();
List <iMatrix> localOptimizedList = new List <iMatrix>();
while (m.matrix.NextWallCombinationOnLastRow() != MatrixIncrement.LimitReached)
{
//вычисляем метрику для текущей комбинации
long combinationMetrika = ComputeCombinationMetrika(m, teachingInput, teachingOutput, localMetrika);
Progress?.Invoke(m.matrix, null, null, new DrawData
{
currentMetrika = (ulong)localMetrika,
level = level,
levelCount = levelCount + 1,
levelTotal = levelTotal
});
if (combinationMetrika > localMetrika)
{
continue;
}
if (combinationMetrika == 0) //найден результат
{
localOptimizedList.Clear();
var resMatr = ConcatRowToMatrix(matr, m.matrix);
resList.Add(resMatr);
localMetrika = 0;
Debug.WriteLine(String.Format("Метрика {0}", localMetrika));
if (resList.Count >= this.MaxMatrixFoundLimit)
{
Debug.WriteLine(String.Format("Достинут предел количества обученных матриц ({0}). Процесс завершен.", this.MaxMatrixFoundLimit));
return(TeachingResult.TeachingComplete);
}
}
else if (combinationMetrika < localMetrika) //найдена матрица с лучшей метрикой
{
//сбрасываем список лучших и включаем текущую (из одной строки) в него
localOptimizedList.Clear();
localOptimizedList.Add(m.matrix.Clone());
localMetrika = combinationMetrika;
Debug.WriteLine(String.Format("Метрика {0}", localMetrika));
}
else if (combinationMetrika == localMetrika) //найдена матрица для варианта оптимизации
{
if (localOptimizedList.Count < this.VariantsCountLimit)
{
localOptimizedList.Add(m.matrix.Clone());
//Debug.WriteLine(String.Format("Добавлена матрица. Метрика {0}", localMetrika));
}
}
}
if (level >= this.MaxRowLimit)
{
return(TeachingResult.MaxRowLimitReached);
}
var counter = 0;
var optMatrArray = GetLocalOptimizedArray(localOptimizedList);
//если нашли не все матрицы и есть оптимизированные, то продолжаем поиск
while (resList.Count < this.MaxMatrixFoundLimit && (counter < optMatrArray.Length))
{
var nextMatr = ConcatRowToMatrix(matr, optMatrArray[counter]);
var nextInputs = GetNextInputsAsOutputs(new iMatrixByte(optMatrArray[counter]), teachingInput);
var res = TeachMatrixRow(nextInputs, teachingOutput, nextMatr, localMetrika - 1, level + 1, counter, optMatrArray.Length);
if (res != TeachingResult.ContinueTeaching)
{
return(res);
}
else
{
counter++;
}
}
return(TeachingResult.ContinueTeaching);
}