/// <summary>
        /// This method accepts the test data as input and determines the output for each sample of test data
        /// </summary>
        /// <param name="data">test data inputs</param>
        /// <param name="ctx">test data descriptions</param>
        /// <returns>double[]</returns>
        public override IResult Predict(double[][] data, IContext ctx)
        {
            double[][] calcuLatedOutput = new double[m_HiddenLayerNeurons.Length + 1][];

            double[][] weightedInputs = new double[m_HiddenLayerNeurons.Length + 1][];

            MLPerceptronResult result = new MLPerceptronResult()
            {
                results = new double[data.Length * m_OutputLayerNeurons],
            };

            for (int i = 0; i < data.Length; i++)
            {
                CalcFirstHiddenLayer(data[i], m_InpDims, out calcuLatedOutput[0], out weightedInputs[0]);

                CalcRemainingHiddenLayers(calcuLatedOutput[0], weightedInputs[0], m_InpDims, out calcuLatedOutput, out weightedInputs);

                CalculateResultatOutputlayer(calcuLatedOutput[m_HiddenLayerNeurons.Length - 1], m_InpDims, m_SoftMax, out calcuLatedOutput[m_HiddenLayerNeurons.Length], out weightedInputs[m_HiddenLayerNeurons.Length]);

                for (int j = 0; j < m_OutputLayerNeurons; j++)
                {
                    result.results[m_OutputLayerNeurons * i + j] = calcuLatedOutput[m_HiddenLayerNeurons.Length][j];
                }
            }

            return(result);
        }
        //[InlineData(new int[] { 6, 3 })]
        public void ImageRecognitionTest()
        {
            int size            = 64;
            int numberOfOutputs = 1;
            int numberOfInputs  = size * size;


            var context = getImgRecognitionDescriptor(numberOfInputs);

            LearningApi api = new LearningApi(context);

            api.UseActionModule <object, double[][]>((notUsed, ctx) =>
            {
                return(getImageData(size, $"{Directory.GetCurrentDirectory()}\\MLPerceptron\\TrainingImages"));
                //return getSomOtherData($"{Directory.GetCurrentDirectory()}\\MLPerceptron\\TestFiles\\TrainingData.csv");
            });

            // High number of hidden neurons in first layer brings network to constant result for everything.
            // var hiddenLayerNeurons = new int[] { size*size, 3 };

            var hiddenLayerNeurons = new int[] { 6000, 9, 3 };

            api.UseMLPerceptron(0.01, 6, 1, 1, hiddenLayerNeurons);

            Stopwatch sw = new Stopwatch();

            sw.Start();
            IScore score = api.Run() as IScore;

            sw.Stop();
            Trace.WriteLine($"Duration:{(double)(sw.ElapsedMilliseconds / 1000 / 60)} min");

            var testImageData = getImageData(size, $"{Directory.GetCurrentDirectory()}\\MLPerceptron\\TestingImages");
            //var testImageData= getSomOtherData($"{Directory.GetCurrentDirectory()}\\MLPerceptron\\TestFiles\\TestData.csv");

            MLPerceptronResult result = api.Algorithm.Predict(testImageData, api.Context) as MLPerceptronResult;

            // float accuracy = MLPHelpers.GetAccuracy(testImageData, result.results, numberOfOutputs);
        }