public void UpdateWeight(IMultipleLayer target, Array <FloatArray2D> dW)
{
for (int i = 0; i < target.ConectionsSize.Length; i++)
{
target.KnowlodgeMatrix[i] -= dW[i] * target.LearningRate;
}
}
public void CalculateParams(IMultipleLayer target)
{
mW = NumMath.Array(target.Size, target.ConectionsSize);
vW = NumMath.Array(target.Size, target.ConectionsSize);
mB = NumMath.Array(target.Size);
vB = NumMath.Array(target.Size);
}
public void CalculateParams(IMultipleLayer target)
{
AdaDeltaW = NumMath.Array(target.Size, target.ConectionsSize);
AdaDeltaW_v = NumMath.Array(target.Size, target.ConectionsSize);
AdaDeltaB = NumMath.Array(target.Size);
AdaDeltaB_v = NumMath.Array(target.Size);
}
public void UpdateWeight(IMultipleLayer target, Array <FloatArray2D> dW)
{
for (int i = 0; i < target.ConectionsSize.Length; i++)
{
gW[i] = ((v * gW[i]) + (m * (dW[i] * dW[i])));
target.KnowlodgeMatrix[i] -= ((target.LearningRate / (gW[i] + e).Sqrt()) * dW[i]);
}
}
public void UpdateBias(IMultipleLayer target, FloatArray dB)
{
AdaDeltaB = (v * AdaDeltaB) + (m * (dB * dB));
var mid = -1 * (((AdaDeltaB_v + e).Sqrt() / (AdaDeltaB + e).Sqrt()) * dB);
AdaDeltaB_v = (v * AdaDeltaB_v) + (m * (mid * mid));
target.BiasVector -= mid;
}
public void UpdateWeight(IMultipleLayer target, Array<FloatArray2D> dW)
{
for(int i = 0; i < target.ConectionsSize.Length; i++)
{
var update = dW[i] * target.CachedLearningRate;
var momentum = target.KnowlodgeMatrix[i] * target.CachedMomentum;
target.KnowlodgeMatrix[i] += (update + momentum);
}
}
public void UpdateBias(IMultipleLayer target, FloatArray dB)
{
mB = (b1 * mB) + ((1f - b1) * dB);
vB = (b2 * vB) + ((1f - b2) * (dB * dB));
var Adam_m_b_hat = mB / (1f - b1);
var Adam_v_b_hat = vB / (1f - b2);
target.BiasVector -= (target.LearningRate / ((Adam_v_b_hat).Sqrt() + e)) * Adam_m_b_hat;
}
public void UpdateWeight(IMultipleLayer target, Array <FloatArray2D> dW)
{
for (int i = 0; i < target.ConectionsSize.Length; i++)
{
AdaDeltaW[i] = (v * AdaDeltaW[i]) + (m * (dW[i] * dW[i]));
var mid = -1 * (((AdaDeltaW_v[i] + e).Sqrt() / (AdaDeltaW[i] + e).Sqrt()) * dW[i]);
AdaDeltaW_v[i] = (v * AdaDeltaW_v[i]) + (m * (mid * mid));
target.KnowlodgeMatrix[i] -= mid;
}
}
public void UpdateWeight(IMultipleLayer target, Array <FloatArray2D> dW)
{
for (int i = 0; i < target.ConectionsSize.Length; i++)
{
mW[i] = (b1 * mW[i]) + ((1f - b1) * dW[i]);
vW[i] = (b2 * vW[i]) + ((1f - b2) * (dW[i] * dW[i]));
var Adam_m_ws_hat = mW[i] / (1f - b1);
var Adam_v_ws_hat = vW[i] / (1f - b2);
target.KnowlodgeMatrix[i] -= (target.LearningRate / ((Adam_v_ws_hat).Sqrt() + e)) * Adam_m_ws_hat;
}
}
public void UpdateWeight(IMultipleLayer target, Array<FloatArray2D> dW)
{
//Parallel.For(0, target.ConectionsSize.Length, i =>
//{
// mW[i] += dW[i] * dW[i];
// target.KnowlodgeMatrix[i] -= ((target.LearningRate / (mW[i] + 1e-8f).Sqrt()) * dW[i]);
//});
for(int i = 0; i < target.ConectionsSize.Length; i++)
{
mW[i] += dW[i] * dW[i];
target.KnowlodgeMatrix[i] -= ((target.LearningRate / (mW[i] + 1e-8f).Sqrt()) * dW[i]);
}
}
public virtual void SetLayer(IMultipleLayer layer)
{
_target = layer;
_optimizerFunction.CalculateParams(_target);
}
public void UpdateBias(IMultipleLayer target, FloatArray dB)
{
var update = dB * target.CachedLearningRate;
var momentum = target.BiasVector * target.CachedMomentum;
target.BiasVector += (update + momentum);
}
public void CalculateParams(IMultipleLayer target)
{
}
public void UpdateBias(IMultipleLayer target, FloatArray dB)
{
target.BiasVector -= dB * target.LearningRate;
}
public void CalculateParams(IMultipleLayer target)
{
target.CachedMomentum = target.LearningRate * target.Momentum;
target.CachedLearningRate = target.LearningRate * (1 - target.Momentum);
}
public void UpdateBias(IMultipleLayer target, FloatArray dB)
{
bW = ((v * bW) + (m * (dB * dB)));
target.BiasVector -= ((target.LearningRate / (bW + e).Sqrt()) * dB);
}
public void UpdateBias(IMultipleLayer target, FloatArray dB)
{
mB += dB * dB;
target.BiasVector -= ((target.LearningRate / (mB + 1e-8f).Sqrt()) * dB);
}
