public void SharpLearning_Example()
        {
            // Load data
            var(observations, targets) = DataSetUtilities.LoadWinequalityWhite();

            // transform data for neural net
            var transform = new MinMaxTransformer(0.0, 1.0);

            transform.Transform(observations, observations);

            var featureCount = observations.ColumnCount;

            // define the neural net.
            var net = new NeuralNet();

            net.Add(new InputLayer(inputUnits: featureCount));
            net.Add(new DenseLayer(32, Activation.Relu));
            net.Add(new DenseLayer(32, Activation.Relu));
            net.Add(new SquaredErrorRegressionLayer());

            // using only 10 iteration to make the example run faster.
            // using square error as error metric. This is only used for reporting progress.
            var learner = new RegressionNeuralNetLearner(net, iterations: 10, loss: new SquareLoss(),
                                                         optimizerMethod: OptimizerMethod.Adam);

            var cv          = new RandomCrossValidation <double>(10, seed: 232);
            var predictions = cv.CrossValidate(learner, observations, targets);

            Trace.WriteLine(FormatErrorString(targets, predictions));
        }
        public void SharpLearning_With_Cntk_Example()
        {
            // Load data
            var(observations, targets) = DataSetUtilities.LoadWinequalityWhite();

            // transform data for neural net
            var transform = new MinMaxTransformer(0.0, 1.0);

            transform.Transform(observations, observations);

            var featureCount     = observations.ColumnCount;
            var observationCount = observations.RowCount;
            var targetCount      = 1;

            var inputShape  = new int[] { featureCount, 1 };
            var outputShape = new int[] { targetCount };

            // Convert data to float, and wrap as minibatch data.
            var observationsFloat = observations.Data().Select(v => (float)v).ToArray();
            var observationsData  = new MemoryMinibatchData(observationsFloat, inputShape, observationCount);
            var targetsFloat      = targets.Select(v => (float)v).ToArray();
            var targetsData       = new MemoryMinibatchData(targetsFloat, outputShape, observationCount);

            var dataType = DataType.Float;
            var device   = DeviceDescriptor.CPUDevice;

            // setup input and target variables.
            var inputVariable  = Layers.Input(inputShape, dataType);
            var targetVariable = Variable.InputVariable(outputShape, dataType);

            // setup name to variable
            var nameToVariable = new Dictionary <string, Variable>
            {
                { "observations", inputVariable },
                { "targets", targetVariable },
            };

            // Get cross validation folds.
            var sampler = new RandomIndexSampler <double>(seed: 24);
            var crossValidationIndexSets = CrossValidationUtilities
                                           .GetKFoldCrossValidationIndexSets(sampler, foldCount: 10, targets: targets);
            var predictions = new double[observationCount];

            // Run cross validation loop.
            foreach (var set in crossValidationIndexSets)
            {
                // setup data.
                var trainingNameToData = new Dictionary <string, MemoryMinibatchData>
                {
                    { "observations", observationsData.GetSamples(set.trainingIndices) },
                    { "targets", targetsData.GetSamples(set.trainingIndices) }
                };

                var validationNameToData = new Dictionary <string, MemoryMinibatchData>
                {
                    { "observations", observationsData.GetSamples(set.validationIndices) },
                    { "targets", targetsData.GetSamples(set.validationIndices) }
                };

                var trainSource      = new MemoryMinibatchSource(nameToVariable, trainingNameToData, seed: 232, randomize: true);
                var validationSource = new MemoryMinibatchSource(nameToVariable, validationNameToData, seed: 232, randomize: false);

                // Create model and fit.
                var model = CreateModel(inputVariable, targetVariable, targetCount, dataType, device);
                model.Fit(trainSource, batchSize: 128, epochs: 10);

                // Predict.
                var predictionsRaw     = model.Predict(validationSource);
                var currentPredictions = predictionsRaw.Select(v => (double)v.Single()).ToArray();

                // set cross-validation predictions
                var validationIndices = set.validationIndices;
                for (int i = 0; i < validationIndices.Length; i++)
                {
                    predictions[validationIndices[i]] = currentPredictions[i];
                }
            }

            Trace.WriteLine(FormatErrorString(targets, predictions));
        }