public abstract void CalcGrads(ILoss loss, Array <double> targets);
public Network(IOptimizer <U> optimizer, ILoss <U> loss, IAccuracy <U> accuracy) { this.optimizer = optimizer; this.loss = loss; this.accuracy = accuracy; }
public Network(IOptimizer <Type> optimizer, ILoss <Type> loss, (NDArray <Type>, NDArray <Type>) tests)
/// <summary> /// Neural net learner. Controls the learning process using mini-batch gradient descent. /// </summary> /// <param name="net">The neural net to learn</param> /// <param name="targetEncoder">Controls how the training targets should be decoded. /// This is different depending on if the net should be used for regression or classification.</param> /// <param name="loss">The loss measured and shown between each iteration</param> /// <param name="learningRate">Controls the step size when updating the weights. (Default is 0.001)</param> /// <param name="iterations">The maximum number of iterations before termination. (Default is 100)</param> /// <param name="batchSize">Batch size for mini-batch stochastic gradient descent. (Default is 128)</param> /// <param name="l1decay">L1 reguralization term. (Default is 0, so no reguralization)</param> /// <param name="l2decay">L2 reguralization term. (Default is 0, so no reguralization)</param> /// <param name="optimizerMethod">The method used for optimization (Default is RMSProp)</param> /// <param name="momentum">Momentum for gradient update. Should be between 0 and 1. (Defualt is 0.9)</param> /// <param name="rho">Squared gradient moving average decay factor (Default is 0.95)</param> /// <param name="beta1">Exponential decay rate for estimates of first moment vector, should be in range 0 to 1 (Default is 0.9)</param> /// <param name="beta2">Exponential decay rate for estimates of second moment vector, should be in range 0 to 1 (Default is 0.999)</param> public NeuralNetLearner(NeuralNet net, ITargetEncoder targetEncoder, ILoss loss, double learningRate = 0.001, int iterations = 100, int batchSize = 128, double l1decay = 0, double l2decay = 0, OptimizerMethod optimizerMethod = OptimizerMethod.RMSProp, double momentum = 0.9, double rho = 0.95, double beta1 = 0.9, double beta2 = 0.999) { if (net == null) { throw new ArgumentNullException("net"); } if (targetEncoder == null) { throw new ArgumentNullException("targetEncoder"); } if (loss == null) { throw new ArgumentNullException("loss"); } if (learningRate <= 0) { throw new ArgumentNullException("learning rate must be larger than 0. Was: " + learningRate); } if (iterations <= 0) { throw new ArgumentNullException("Iterations must be larger than 0. Was: " + iterations); } if (batchSize <= 0) { throw new ArgumentNullException("batchSize must be larger than 0. Was: " + batchSize); } if (l1decay < 0) { throw new ArgumentNullException("l1decay must be positive. Was: " + l1decay); } if (l2decay < 0) { throw new ArgumentNullException("l1decay must be positive. Was: " + l2decay); } if (momentum <= 0) { throw new ArgumentNullException("momentum must be larger than 0. Was: " + momentum); } if (rho <= 0) { throw new ArgumentNullException("ro must be larger than 0. Was: " + rho); } if (beta1 <= 0) { throw new ArgumentNullException("beta1 must be larger than 0. Was: " + beta1); } if (beta2 <= 0) { throw new ArgumentNullException("beta2 must be larger than 0. Was: " + beta2); } m_net = net; m_targetEncoder = targetEncoder; m_loss = loss; m_learningRate = learningRate; m_iterations = iterations; m_momentum = momentum; m_batchSize = batchSize; m_random = new Random(232); m_optimizer = new NeuralNetOptimizer(learningRate, batchSize, l1decay, l2decay, optimizerMethod, momentum, rho, beta1, beta2); SetupLinerAlgebraProvider(); }
/// <summary> /// Обучить нейронную сеть на накопленных исследованиях /// </summary> /// <param name="countLifes">На скольких жизней, начиная от последней, обучить модель</param> /// <param name="epochs">Количество эпох обучения. По умолчанию 1</param> /// <param name="learningRate">Норма обучения. По умолчанию 1e-3</param> /// <param name="trainType">Тип обучения. По умолчанию online</param> /// <param name="minLoss">ошибка, при которой обучение останавливается</param> /// <param name="optimizer">Оптимизатор. По умолчанию Adam</param> /// <param name="loss">Метрика ошибки. По умолчанию MSE</param> public void Train(int countLifes = 50, int epochs = 1, double learningRate = 1e-3, TrainType trainType = TrainType.Online, double minLoss = 0.0, IOptimizer optimizer = null, ILoss loss = null) { if (loss == null) { loss = new LossMeanSqrSqrt(); } if (optimizer == null) { optimizer = new Adam(); } int start = lifes.Count - countLifes; Vector rewards = GetRewards(start, lifes.Count); var inputs = new List <NNValue>(); var outputs = new List <NNValue>(); for (int i = 0; i < rewards.N; i++) { var conditions = lifes[start + i].GetConditions(); foreach (var condition in conditions) { var state = condition.Item1; var action = condition.Item2; inputs.Add(state.ToNNValue()); if (rewards[i] > 0) { outputs.Add(new NNValue(action.probabilities.MaxOutVector().TransformVector(x => (x == -1) ? 0 : 1))); } else { outputs.Add(new NNValue((1.0 - action.probabilities).MaxOutVector().TransformVector(x => (x == -1) ? 0 : 1))); } } } #region Shuffle for (int i = start; i < inputs.Count; i++) { var a = random.Next(start, inputs.Count); var b = random.Next(start, inputs.Count); var temp1 = inputs[a]; var temp2 = outputs[a]; inputs[a] = inputs[b]; outputs[a] = outputs[b]; inputs[b] = temp1; outputs[b] = temp2; } #endregion #region Train DataSetNoReccurent dataSetNoReccurent = new DataSetNoReccurent(inputs.ToArray(), outputs.ToArray(), loss); Trainer trainer = new Trainer(graphBackward, trainType, optimizer); trainer.Train(epochs, learningRate, model, dataSetNoReccurent, minLoss); #endregion }
public virtual void get_updates(object param, IWeightConstraint constraints, ILoss loss) { throw new NotImplementedException(); }
public Network(IOptimizer optimizer, ILoss loss, IAccuracy accuracy) { this.optimizer = optimizer; this.loss = loss; this.accuracy = accuracy; }
public List <Tensor> get_updates(List <Tensor> param, Dictionary <Tensor, IWeightConstraint> constraints, ILoss loss) { var grads = this.get_gradients(loss, param); this.updates = new List <Tensor>(); var lr = this.lr; if (this.initial_decay > 0) { lr = K.mul(lr, K.div(1.0, K.sum(1.0, K.mul(this.decay, this.iterations)))); this.updates.Add(K.update_add(this.iterations, 1)); } // momentum var shapes = param.Select(p => K.get_variable_shape(p)).ToList(); List <Tensor> moments = shapes.Select(s => K.get_variable_shape(s)).ToList(); this.weights = new[] { this.iterations }.Concat(moments).ToList(); for (int i = 0; i < param.Count; i++) { Tensor p = param[i]; Tensor g = grads[i]; Tensor m = moments[i]; Tensor v = K.subtract(K.mul(this.momentum, m), K.mul(lr, g)); // velocity this.updates.Add(K.update(m, v)); Tensor new_p; if (this.nesterov) { new_p = K.add(p, K.subtract(K.mul(this.momentum, v), K.mul(lr, g))); } else { new_p = K.add(p, v); } // apply constraints if (constraints.ContainsKey(p)) { var c = constraints[p]; new_p = c.Call(new_p); } updates.Add(K.update(p, new_p)); } return(this.updates); }
protected override void CalcGrads(ILoss loss, ShapedArray <double> targets) { OutputNode.CalcGrads(loss, targets); }
public Network(IOptimizer <Type> optimizer, ILoss <Type> loss) { this.optimizer = optimizer; lossFunction = loss; }