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;
}
