/// <summary> /// Generates output predictions for the input samples. Computation is done in batches. /// </summary> /// <param name="x">The input data frame to run prediction.</param> /// <param name="batch_size">Size of the batch.</param> /// <returns></returns> public DataFrame Predict(DataFrame x, int batch_size) { DataFrameIter dataFrameIter = new DataFrameIter(x); List <float> predictions = new List <float>(); dataFrameIter.SetBatchSize(batch_size); while (dataFrameIter.Next()) { var data = dataFrameIter.GetBatchX(); SuperArray output = data; foreach (var layer in Layers) { if (layer.SkipPred) { continue; } layer.Forward(output); output = layer.Output; } predictions.AddRange(output.List <float>()); } DataFrame result = new DataFrame(); result.Load(predictions.ToArray()); return(result); }
/// <summary> /// Generates output predictions for the input samples. Computation is done in batches. /// </summary> /// <param name="x">The input data frame to run prediction.</param> /// <param name="batch_size">Size of the batch.</param> /// <returns></returns> public Tensor Predict(DataFrame x, int batch_size) { DataFrameIter dataFrameIter = new DataFrameIter(x); List <float> predictions = new List <float>(); dataFrameIter.SetBatchSize(batch_size); long[] outshape = null; while (dataFrameIter.Next()) { var data = dataFrameIter.GetBatchX(); Tensor output = data; foreach (var layer in Layers) { if (layer.SkipPred) { continue; } layer.Forward(output); output = layer.Output; } predictions.AddRange(output.ToArray().Cast <float>()); } return(K.CreateVariable(predictions.ToArray(), outshape)); }
/// <summary> /// Trains the model for a given number of epochs (iterations on a dataset). /// </summary> /// <param name="train">The train dataset which is an instance of DataFrame Iter.</param> /// <param name="epochs">Integer. Number of epochs to train the model. An epoch is an iteration over the entire x and y data provided. Note that in conjunction with initial_epoch, epochs is to be understood as "final epoch". The model is not trained for a number of iterations given by epochs, but merely until the epoch of index epochs is reached.</param> /// <param name="batchSize">Integer or None. Number of samples per gradient update. If unspecified, batch_size will default to 32.</param> /// <param name="val">The validation set of data to evaluate the model at every epoch.</param> public void Train(DataFrameIter train, int epochs, int batchSize, DataFrameIter val = null) { LearningHistory = new History(); Stopwatch trainWatch = new Stopwatch(); try { Stopwatch batchWatch = new Stopwatch(); long n = train.DataSize; trainWatch.Start(); train.SetBatchSize(batchSize); if (val != null) { val.SetBatchSize(batchSize); } for (int iteration = 1; iteration <= epochs; iteration++) { batchWatch.Restart(); OnEpochStart(iteration); RunEpoch(iteration, train, val); batchWatch.Stop(); long samplesSeen = n * 1000 / (batchWatch.ElapsedMilliseconds + 1); if (val == null) { OnEpochEnd(iteration, samplesSeen, train_losses.Average(), 0, train_metrics.Average(), 0, batchWatch.ElapsedMilliseconds); } else { OnEpochEnd(iteration, samplesSeen, train_losses.Average(), val_losses.Average(), train_metrics.Average(), val_metrics.Average(), batchWatch.ElapsedMilliseconds); } LearningHistory.Add(train_losses, train_metrics, val_losses, val_metrics); } } catch (Exception ex) { Console.WriteLine(ex.ToString()); } trainWatch.Stop(); OnTrainingEnd(LearningHistory, trainWatch.ElapsedMilliseconds); }