public unsafe void SubtractFloat32_Test()
{
const int size = 11;
const int size2 = 5;
float[] x1, x2, expres;
x1 = new float[size] {
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
};
x2 = new float[size2] {
1, 2, 3, 4, 5
};
expres = new float[size];
for (int i = 0; i < size; i++)
{
expres[i] = x1[i] - x2[i % size2];
}
Tensor expected_res = expres.ToDisposedTensor(new Shape(size));
Tensor t1, t2;
t1 = x1.ToDisposedTensor(new Shape(size));
t2 = x2.ToDisposedTensor(new Shape(size2));
Tensor myres = CpuKernels.SubtractFloat32(t1, t2);
Console.WriteLine(myres);
Console.WriteLine(expected_res);
Assert.AreEqual(expected_res.ToString(), myres.ToString());
myres.Dispose();
}
public unsafe override Tensor CalculateResult()
{
Tensor v = Terms[0].GetResult();
Tensor res = CpuKernels.ExpandFloat(v, this.Shape, Terms[0].Shape, Multiplier);
return(res);
}
public override Tensor CalculateResult()
{
var x1 = Terms[0].GetResult();
var x2 = Terms[1].GetResult();
return(CpuKernels.MatrixMultiplyFloat(x1, x2));
}
public void MultiplyRandom()
{
Tensor m1, m2, calculated, result;
float[] arr1, arr2, arr_expected;
(arr1, m1) = CreateRandomTensor();
(arr2, m2) = CreateRandomTensor();
arr_expected = new float[9];
//CpuKernels.MultiplyFloat32 already uses ElementWiseMultiplyAVX method. We should calculate the results manually.
for (int i = 0; i < arr_expected.Length; i++)
{
arr_expected[i] = arr1[i] * arr2[i];
}
//VectorizationFloat.ElementWiseMultiplyAVX(arr1, arr2, arr_expected, 9);
result = Tensor.ToDisposedTensor(arr_expected, new Shape(9), NumberType.Float32);
calculated = CpuKernels.MultiplyFloat32(m1, m2);
Console.WriteLine(calculated.ToString());
Console.WriteLine(result.ToString());
Assert.AreEqual(calculated.ToString(), result.ToString());
m1.Dispose();
m2.Dispose();
calculated.Dispose();
}
public void Add()
{
Tensor expected = new Tensor(new Shape(3, 3), TensorConfig.Host_Float32);
expected.SetValue(15);
Tensor calculated = new Tensor(new Shape(3, 3), TensorConfig.Host_Float32);
calculated.SetValue(0);
Tensor[] inputs = new Tensor[5];
for (int i = 0; i < 5; i++)
{
inputs[i] = new Tensor(new Shape(3, 3), TensorConfig.Host_Float32);
inputs[i].SetValue(3);
}
CpuKernels.AddFloat32(calculated, inputs);
Assert.AreEqual(expected.ToString(), calculated.ToString());
Tensor calculated2 = CpuKernels.AddFloat32(inputs);
Assert.AreEqual(expected.ToString(), calculated2.ToString());
expected.Dispose();
calculated.Dispose();
for (int i = 0; i < 5; i++)
{
inputs[i].Dispose();
}
}
public override Tensor CalculateResult()
{
Tensor v1 = Terms[0].GetResult();
Tensor v2 = Terms[1].GetResult();
Tensor res = CpuKernels.SubtractFloat(v1, v2);
return(res);
}
public override unsafe void CalculateDerivate(Tensor s)
{
if (Terms[0].ContainsTrainable)
{
Tensor combined = CpuKernels.ExpandFloat_GetGradient_0(s, this.Shape, Terms[0].Shape, Multiplier);
Terms[0].Derivate(combined);
combined.Dispose();
}
}
public unsafe override Tensor CalculateResult()
{
for (int i = 0; i < this.Terms.Length; i++)
{
tensors[i] = Terms[i].GetResult();
}
return(CpuKernels.AddFloat(tensors));
}
public override unsafe void CalculateDerivate(Tensor s)
{
if (Terms[0].ContainsTrainable)
{
Tensor sigmo = GetResult();
Tensor combined = CpuKernels.SigmoidFloat_GetGradient_0(s, sigmo);
Terms[0].Derivate(combined);
combined.Dispose();
}
}
public override void CalculateDerivate(Tensor s)
{
if (Terms[0].ContainsTrainable)
{
Terms[0].Derivate(s);
}
if (Terms[1].ContainsTrainable)
{
Tensor d2 = CpuKernels.SubtractFloat_GetGradient_1(s, Terms[0].GetResult(), Terms[1].GetResult());
Terms[1].Derivate(d2);
d2.Dispose();
}
}
public unsafe override Tensor CalculateResult()
{
Tensor res = Terms[0].GetResult();
if (PowerOf == 2)
{
return(CpuKernels.Power2Float(res));
}
else
{
throw new Exception("Unsupported Power factor!");
}
}
public override unsafe void CalculateDerivate(Tensor s)
{
if (Terms[0].ContainsTrainable)
{
var combinedleft = CpuKernels.MatrixMultiplyFloat_GetGradient_0(s, Terms[1].GetResult(), this.Shape, Terms[0].Shape, Terms[1].Shape);
Terms[0].Derivate(combinedleft);
combinedleft.Dispose();
}
if (Terms[1].ContainsTrainable)
{
var combinedright = CpuKernels.MatrixMultiplyFloat_GetGradient_1(s, Terms[0].GetResult(), this.Shape, Terms[0].Shape, Terms[1].Shape);
Terms[1].Derivate(combinedright);
combinedright.Dispose();
}
}
public override void CalculateDerivate(Tensor s)
{
Tensor a = Terms[0].GetResult(), b = Terms[1].GetResult();
if (Terms[0].ContainsTrainable)
{
Tensor g0 = CpuKernels.MultiplyFloat_GetGradient_0(s, a, b);
Terms[0].Derivate(g0);
g0.Dispose();
}
if (Terms[1].ContainsTrainable)
{
Tensor g1 = CpuKernels.MultiplyFloat_GetGradient_1(s, a, b);
Terms[1].Derivate(g1);
g1.Dispose();
}
}
public override unsafe void CalculateDerivate(Tensor s)
{
if (Terms[0].ContainsTrainable)
{
Tensor res = Terms[0].GetResult();
if (PowerOf == 2)//todo move this power check to the power kernel
{
Tensor combined = CpuKernels.Power2Float_GetGradient_0(s, res);
Terms[0].Derivate(combined);
combined.Dispose();
}
else
{
throw new Exception("Unsupported Power factor!");
}
}
}
public void AddRandom()
{
int arrSize = 5;
int tensorSize = 9;
// initialize test tensors
Tensor expected, calculated;
float[] expectedArr = new float[tensorSize];
(_, calculated) = CreateRandomTensor(tensorSize);
Tensor[] inputs = new Tensor[arrSize];
float[][] arrays = new float[arrSize][];
for (int i = 0; i < arrSize; i++)
{
(arrays[i], inputs[i]) = CreateRandomTensor(tensorSize);
for (int j = 0; j < tensorSize; j++)
{
expectedArr[j] += arrays[i][j];
}
}
// add tensors
expected = Tensor.ToDisposedTensor(expectedArr, new Shape(tensorSize), NumberType.Float32);
CpuKernels.AddFloat32(calculated, inputs);
Console.WriteLine(calculated.ToString());
Console.WriteLine(expected.ToString());
Assert.AreEqual(calculated.ToString(), expected.ToString());
//need to dipose tensors to remove them from memory
//we don't need to do this manually but better doing
calculated.Dispose();
for (int i = 0; i < arrSize; i++)
{
inputs[i].Dispose();
}
//expected.Dispose(); don't dispose expected tensor because it is already disposed tensor. line 72
}
public unsafe void ReluFloatCpu()
{
float[] vdata = new float[] { 0.1f, -0.2f, 2, 3, -1, 2, -5, -10, 9, -8 };
float[] graddata = new float[] { 0.1f, 0.1f, 0.1f, 0.1f, 0.1f, 0.1f, 0.1f, 0.1f, 0.1f, 0.1f };
fixed(float *ptr_v = vdata, ptr_grad = graddata)
{
Tensor v = Tensor.ToDisposedTensor(vdata, new Shape(vdata.Length), NumberType.Float32);
Tensor grad = Tensor.ToDisposedTensor(graddata, new Shape(graddata.Length), NumberType.Float32);
Tensor reluv = CpuKernels.ReluFloat32(v);
Tensor relugrad = CpuKernels.ReluFloat32_GetGradient_0(grad, v);
Console.WriteLine(v);
Console.WriteLine(grad);
Console.WriteLine(reluv);
Console.WriteLine(relugrad);
//todo make checks
reluv.Dispose();
relugrad.Dispose();
}
}
public override Tensor CalculateResult()
{
return(CpuKernels.MultiplyFloat(Terms[0].GetResult(), Terms[1].GetResult()));
}
public unsafe override Tensor CalculateResult()
{
Tensor v = Terms[0].GetResult();
return(CpuKernels.ShrinkFloat(v, this.Shape, Terms[0].Shape, Divisor));
}
public override unsafe Tensor CalculateResult()
{
Tensor v = Terms[0].GetResult();
return(CpuKernels.SigmoidFloat(v));
}
