public void TrainXOR() { try { //Load train data float[,] testX = new float[, ] { { 0, 1 }, }; float[,] x = new float[, ] { { 0, 0 }, { 0, 1 }, { 1, 0 }, { 1, 1 } }; float[] y = new float[] { 0, 1, 1, 0 }; //Build sequential model var model = new Sequential(); model.Add(new Dense(32, activation: "relu", input_shape: new Shape(2))); model.Add(new Dense(32, activation: "relu")); model.Add(new Dropout(0.1d)); model.Add(new Dense(1, activation: "sigmoid")); //Compile and train var optimizer = new Adam(); model.Compile(optimizer: optimizer, loss: "mse", metrics: new string[] { "accuracy" }); model.Fit(x, y, batch_size: 2, epochs: 1000, verbose: 1); float[] predicts; predicts = model.Predict(x).GetData <float>(); predicts = model.PredictOnBatch(x).GetData <float>(); predicts = model.Predict(x).GetData <float>(); predicts = model.PredictOnBatch(x).GetData <float>(); predicts = model.Predict(x).GetData <float>(); predicts = model.PredictOnBatch(x).GetData <float>(); Stopwatch watch = new Stopwatch(); watch.Restart(); for (int i = 0; i < 5; ++i) { predicts = model.PredictOnBatch(testX).GetData <float>(); } watch.Stop(); string batchMs = watch.GetElapsedMilliseconds().ToString(); watch.Restart(); for (int i = 0; i < 5; ++i) { predicts = model.Predict(testX).GetData <float>(); } watch.Stop(); //MainWindow.Instance.Dispatcher.BeginInvoke(new Action(() => { // MainWindow.Instance.DebugTextBox.Text = batchMs + " / " + watch.GetElapsedMilliseconds().ToString(); //})); } catch (Exception ex) { //MainWindow.Instance.Dispatcher.BeginInvoke(new Action(() => { // MainWindow.Instance.DebugTextBox.Text = ex.ToString(); //})); } }
static void Main(string[] args) { SaveRateToFileTrainData("USD"); SaveRateToFileTestData("USD"); Global.UseEngine(SiaNet.Backend.ArrayFire.SiaNetBackend.Instance, DeviceType.CUDA, true); var train = PreparingExchangeRateData.LoadTrain(); var test = PreparingExchangeRateData.LoadTest(); var model = new Sequential(); model.EpochEnd += Model_EpochEnd; model.Add(new Dense(60, ActType.Sigmoid)); model.Add(new Dense(60, ActType.Sigmoid)); model.Add(new Dense(1, ActType.Linear)); //Compile with Optimizer, Loss and Metric model.Compile(OptimizerType.SGD, LossType.MeanSquaredError, MetricType.MSE); // Train for 1000 epoch with batch size of 2 model.Train(train, epochs: 1000, batchSize: 32); //Create prediction data to evaluate DataFrame2D predX = new DataFrame2D(2); predX.Load(0, 0, 0, 1, 1, 0, 1, 1); //Result should be 0, 1, 1, 0 var rawPred = model.Predict(test); Console.ReadLine(); }
static void Main(string[] args) { //Setup Engine Global.UseEngine(SiaNet.Backend.MxNetLib.SiaNetBackend.Instance, DeviceType.CPU); //Prep Data var(x, y) = PrepDataset(); x.Head(); DataFrameIter trainSet = new DataFrameIter(x, y); //Build model with simple fully connected layers var model = new Sequential(); model.EpochEnd += Model_EpochEnd; model.Add(new Dense(64, ActType.ReLU)); model.Add(new Dense(1, ActType.Sigmoid)); //Compile with Optimizer, Loss and Metric model.Compile(OptimizerType.SGD, LossType.MeanSquaredError, MetricType.BinaryAccurary); // Train for 100 epoch with batch size of 2 model.Train(trainSet, 1000, 2); //Create prediction data to evaluate DataFrame2D predX = new DataFrame2D(2); predX.Load(0, 0, 0, 1); //Result should be 0 and 1 var rawPred = model.Predict(predX); Console.ReadLine(); }
public NDarray Predict(string imgPath) { NDarray x = Utils.Normalize(imgPath); x = x.reshape(1, x.shape[0], x.shape[1], x.shape[2]); return(_model.Predict(x)); }
static (NDarray, NDarray) GenerateFakeGeneratorSamples(Sequential generatorModel, int latentDim, int sampleCount) { var xInput = GenerateLatentPoints(latentDim, sampleCount); var x = generatorModel.Predict(xInput); var y = np.zeros(new int[] { sampleCount, 1 }); return(x, y); }
/// <summary> /// Teaches an agent whose model is represented by a direct distribution network (non-recurrent). Used when the model operates only with the current state of the environment, not taking into account previous states. /// </summary> /// <param name="agent">Agent for training, a network of a given architecture</param> /// <param name="iterationCount">Number of learning iterations (eras)</param> /// <param name="rolloutCount">The number of runs (in the case of a game - passing the level until the end of the game <seealso cref="Environment.IsTerminated"/> ), which will be completed before the weights are updated. /// It can be interpreted as the amount of training data for one era.</param> /// <param name="minibatchSize">Minibatch size for training</param> /// <param name="actionPerIteration">The arbitrary action that each epoch requires. Allows you to interrupt the training process. Input parameters: era, loss error, evaluation error. /// Weekend: true - interrupt the training process, false - continue the training. /// Used for logging, displaying the learning process, saving intermediate model checkpoints, etc.</param> /// <param name="gamma">Reward attenuation coefficient (reward) when calculating Discounted reward</param> /// <returns></returns> public Sequential <T> Teach(Sequential <T> agent, int iterationCount, int rolloutCount, int minibatchSize, Func <int, double, double, bool> actionPerIteration = null, double gamma = 0.99) { for (int iteration = 0; iteration < iterationCount; iteration++) { var data = new LinkedList <(int rollout, int actionNumber, T[] state, T[] action, T reward)>(); for (int rolloutNumber = 0; rolloutNumber < rolloutCount; rolloutNumber++) { int actionNumber = 0; while (!Environment.IsTerminated) { var currentState = Environment.GetCurrentState <T>(); var action = agent.Predict(currentState, Device); var reward = Environment.PerformAction(action); data.AddLast((rolloutNumber, ++actionNumber, currentState, action, reward)); } Environment.Reset(); } var discountedRewards = new T[data.Count]; foreach (var rollout in data.GroupBy(p => p.rollout)) { var steps = rollout.ToList(); steps.Sort((a, b) => a.actionNumber > b.actionNumber ? 1 : a.actionNumber < b.actionNumber ? -1 : 0); //ascending actionNumber for (int i = 0; i < steps.Count; i++) { var remainingRewards = steps.GetRange(i, steps.Count - i) .Select(p => Environment.HasRewardOnlyForRollout ? steps[steps.Count - 1].reward : p.reward) .ToArray(); discountedRewards[i] = CalculateDiscountedReward(remainingRewards, gamma); } } var features = data.Select(p => p.state); var labels = data.Zip(discountedRewards, (d, reward) => Multiply(d.action, reward)); var dataset = features.Zip(labels, (f, l) => f.Concat(l).ToArray()).ToArray(); var inputDim = features.FirstOrDefault().Length; var fitResult = agent.Fit(dataset, inputDim, minibatchSize, GetLoss()[0], GetEvalLoss()[0], GetOptimizer()[0], 1, false, Device); data.Clear(); var needStop = actionPerIteration?.Invoke(iteration, fitResult.LossError, fitResult.EvaluationError); if (needStop.HasValue && needStop.Value) { break; } } return(agent); }
public int Classify(Bitmap bitmap) { if (_framework == "keras") { var pred = ClassFromNumpy(_model.Predict(np.array(ImagePixels(bitmap)))); return pred; } else { _trainer.Net.Forward(BuilderInstance.Volume.From(ImagePixels(bitmap), new Shape(80, 60, 1))); var predictedClass = _trainer.Net.GetPrediction(); return predictedClass[0]; } }
public static void Run() { var(x, y) = LoadTrain(); Sequential model = new Sequential(); model.Add(new Dense(32, activation: SuperNeuro.Engine.ActType.ReLU)); model.Add(new Dense(32, activation: SuperNeuro.Engine.ActType.ReLU)); model.Add(new Dense(1, activation: SuperNeuro.Engine.ActType.Sigmoid)); model.EpochEnd += Model_EpochEnd; model.Compile(SuperNeuro.Engine.OptimizerType.Adam, SuperNeuro.Engine.LossType.BinaryCrossEntropy, SuperNeuro.Engine.MetricType.BinaryAccurary); model.Train(new SuperNeuro.Data.DataFrameIter(x, y), 100, 32); var test = model.Predict(LoadTest()); test.Head(); }
static void Main(string[] args) { //Setup Engine Global.UseEngine(SiaNet.Backend.ArrayFire.SiaNetBackend.Instance, DeviceType.Default); var train = LoadTrain(); //Load train data var test = LoadTest(); //Load test data var model = new Sequential(); model.EpochEnd += Model_EpochEnd; model.Add(new Dense(128, ActType.ReLU)); model.Add(new Dense(64, ActType.ReLU)); model.Add(new Dense(1, ActType.Sigmoid)); //Compile with Optimizer, Loss and Metric model.Compile(OptimizerType.Adam, LossType.BinaryCrossEntropy, MetricType.BinaryAccurary); // Perform training with train and val dataset model.Train(train, epochs: 100, batchSize: 200); var prediction = model.Predict(test); }
/// <summary> /// Teaches an agent whose model is represented by a recurrent network. It is used when the model operates with a chain of environmental states. /// </summary> /// <param name="agent">Agent for training, a network of a given architecture</param> /// <param name="iterationCount">Number of learning iterations (eras)</param> /// <param name="rolloutCount">The number of runs (in the case of a game - passing the level until the end of the game <seealso cref="Environment.IsTerminated"/> ), which will be completed before the weights are updated. /// It can be interpreted as the amount of training data for one era.</param> /// <param name="minibatchSize">Minibatch size for training</param> /// <param name="sequenceLength">Sequence length: a chain of previous state environments on each action.</param> /// <param name="actionPerIteration">The arbitrary action that each epoch requires. Allows you to interrupt the training process. Input parameters: era, loss error, evaluation error. /// Weekend: true - interrupt the training process, false - continue the training. /// Used for logging, displaying the learning process, saving intermediate model checkpoints, etc.</param> /// <param name="gamma">Reward attenuation coefficient (reward) when calculating Discounted reward</param> /// <returns></returns> public Sequential <T> Teach(Sequential <T> agent, int iterationCount, int rolloutCount, int minibatchSize, int sequenceLength, Func <int, double, double, bool> actionPerIteration = null, double gamma = 0.99) { for (int iteration = 0; iteration < iterationCount; iteration++) { var data = new List <(int rollout, int actionNumber, T[] state, T[] action, T reward)>(); for (int rolloutNumber = 0; rolloutNumber < rolloutCount; rolloutNumber++) { int actionNumber = 0; while (!Environment.IsTerminated) { var currentState = Environment.GetCurrentState <T>(); var sequence = actionNumber < sequenceLength ? data.GetRange(data.Count - actionNumber, actionNumber) : data.GetRange(data.Count - sequenceLength - 1, sequenceLength - 1); var sequenceStates = sequence .Select(p => p.state) .ToList(); sequenceStates.Add(currentState); var action = agent.Predict(sequenceStates, Device); var reward = Environment.PerformAction(action); data.Add((rolloutNumber, ++actionNumber, currentState, action, reward)); } Environment.Reset(); } var discountedRewards = new T[data.Count]; foreach (var rollout in data.GroupBy(p => p.rollout)) { var steps = rollout.ToList(); for (int i = 0; i < steps.Count; i++) { var remainingRewards = steps.GetRange(i, steps.Count - i) .Select(p => Environment.HasRewardOnlyForRollout ? steps[steps.Count - 1].reward : p.reward) .ToArray(); discountedRewards[i] = CalculateDiscountedReward(remainingRewards, gamma); } } var features = new List <IList <T[]> >(); var labels = new List <T[]>(); var dataWithDiscountedReward = data.Zip(discountedRewards, (dat, reward) => (dat, reward)).GroupBy(p => p.dat.rollout); foreach (var rollout in dataWithDiscountedReward) { var steps = rollout.ToList(); steps.Sort((a, b) => a.dat.actionNumber > b.dat.actionNumber ? 1 : a.dat.actionNumber < b.dat.actionNumber ? -1 : 0); //ascending actionNumber for (int i = 0; i < steps.Count; i++) { if (i < sequenceLength) { features.Add(steps.GetRange(0, i + 1).Select(p => p.dat.state).ToArray()); } else { features.Add(steps.GetRange(i - sequenceLength, sequenceLength).Select(p => p.dat.state).ToArray()); } labels.Add(Multiply(steps[i].dat.action, steps[i].reward)); } } var fitResult = agent.Fit(features, labels, minibatchSize, GetLoss()[0], GetEvalLoss()[0], GetOptimizer()[0], 1, Device); data.Clear(); var needStop = actionPerIteration?.Invoke(iteration, fitResult.LossError, fitResult.EvaluationError); if (needStop.HasValue && needStop.Value) { break; } } return(agent); }