/// <summary>
/// Нормализует тензор, деля на максимальное по модулю отклонение в каждом батче.
/// </summary>
/// <returns></returns>
public Tensor4 NormalizeAbs()
{
Tensor4 res = new Tensor4(width, height, deep, bs);
for (int i = 0; i < bs; i++)
{
var max = MaxAbs(i);
for (int j = 0; j < dhw; j++)
{
res.elements[i * dhw + j] = elements[i * dhw + j] / max;
}
}
return(res);
}
public Tensor4 VectorOnMatrix(Tensor4 matr)
{
//CLCalc.Program.Variable varA = new CLCalc.Program.Variable(a);
//CLCalc.Program.Variable varB = new CLCalc.Program.Variable(b);
//CLCalc.Program.Variable varC = new CLCalc.Program.Variable(c);
//la.MatrixSum(a, b);
//la.MatrixMultiply(a, b);
//syka = program.MatrixMultiply(a, b);
//CLCalc.CLPrograms.doubleLinearAlgebra list = new CLCalc.Program.MemoryObject();
//*
if (matr.deep != 1)
{
throw new Exception("I don't no.");
}
if (dhw != matr.height)
{
throw new Exception("Размерности не совпадают");
}
Tensor4 res = new Tensor4(matr.width, 1, 1, bs);
if (bs == 1)
{
//for (int d = 0; d < bs; d++)
Parallel.For(0, matr.width, c =>
{//for (int c = 0; c < matr.width; c++)
for (int x = 0; x < matr.height; x++)
{
res[0, 0, 0, c] += elements[x] * matr[0, 0, x, c];
}
});
}
else
{
Parallel.For(0, bs, d =>
{//for (int d = 0; d < bs; d++)
for (int c = 0; c < matr.width; c++)
{
for (int x = 0; x < matr.height; x++)
{
res[d, 0, 0, c] += elements[d * dhw + x] * matr[0, 0, x, c];
}
}
});
}
//*/
return(res);
}
public Tensor4 AverageOnBatch()
{
Tensor4 res = new Tensor4(width, height, deep, 1);
for (int x = 0; x < dhw; x++)
{
for (int d = 0; d < bs; d++)
{
res.elements[x] += elements[d * dhw + x];
}
res.elements[x] /= (double)bs;
}
return(res);
}
public static Tensor4 operator /(Tensor4 a, Tensor4 b)
{
if (a.bs != b.bs || a.deep != b.deep || a.height != b.height || a.width != b.width)
{
throw new Exception("Размерности не совпадают");
}
Tensor4 res = new Tensor4(a.width, a.height, a.deep, a.bs);
for (int x = 0; x < a.elements.Length; x++)
{
res.elements[x] = a.elements[x] / b.elements[x];
}
return(res);
}
public Tensor4 ToTensor4()
{
Tensor4 res = new Tensor4(width, height, deep, 1);
for (int z = 0; z < deep; z++)
{
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
res[0, z, y, x] = elements[z][y, x];
}
}
}
return(res);
}
public Tensor4 NormalizeTensor3(double degree)
{
Tensor4 res = new Tensor4(width, height, deep, bs);
for (int i = 0; i < bs; i++)
{
double sum = 0.0;
var offset = i * dhw;
for (int k = offset; k < offset + dhw; k++)
{
sum += Math.Pow(elements[k], degree);
}
sum = Math.Pow(sum, 1.0 / degree);
for (int k = offset; k < offset + dhw; k++)
{
res.elements[k] = elements[k] / sum;
}
}
return(res);
}
public Tensor4 MatrixOnVector(Tensor4 vector)
{
if (deep != 1)
{
throw new Exception("I don't no.");
}
if (vector.dhw != width)
{
throw new Exception("Размерности не совпадают");
}
Tensor4 res = new Tensor4(height, 1, 1, vector.bs);
if (vector.bs == 1)
{
//for (int d = 0; d < vector.bs; d++)
Parallel.For(0, height, c =>
{//for (int c = 0; c < height; c++)
for (int x = 0; x < width; x++)
{
res[0, 0, 0, c] += elements[c * width + x] * vector.elements[x];
}
});
}
else
{
Parallel.For(0, vector.bs, d =>
{//for (int d = 0; d < vector.bs; d++)
for (int c = 0; c < height; c++)
{
for (int x = 0; x < width; x++)
{
res[d, 0, 0, c] += elements[c * width + x] * vector.elements[d * vector.dhw + x];
}
}
});
}
return(res);
}
public Vector Distance(Tensor4 b)
{
if (bs != 1 || b.bs != 1 || deep != b.deep || width != b.width || height != b.height)
{
throw new Exception("Чет браток не то у тебя.");
}
Vector result = new Vector(deep);
for (int i = 0; i < deep; i++)
{
for (int j = 0; j < height; j++)
{
for (int k = 0; k < width; k++)
{
result[i] += Math.Abs(elements[getIndex(0, i, j, k)] - b[0, i, j, k]);
}
}
result[i] /= (double)hw;
}
return(result);
}
public Tensor4 ConvEuclid(Tensor4 b)
{
if (deep != b.deep)
{
throw new Exception("Глубины не совпадают.");
}
Tensor4 res = new Tensor4(width - b.width + 1, height - b.height + 1, b.bs, bs);
if (bs == 1)
{
Parallel.For(0, b.bs, s =>
{//for (int s = 0; s < b.bs; s++)
for (int y = 0; y < res.height; y++)
{
for (int x = 0; x < res.width; x++)
{
for (int z = 0; z < deep; z++)
{
for (int dy = 0; dy < b.height; dy++)
{
for (int dx = 0; dx < b.width; dx++)
{
res[0, s, y, x] += Math.Pow(elements[z * hw + (y + dy) * width + x + dx] - b[s, z, dy, dx], 2.0);
}
}
}
res[0, s, y, x] /= b.hw;
}
}
});
}
else
{
Parallel.For(0, bs, d =>
{//for (int d = 0; d < bs; d++)
for (int s = 0; s < b.bs; s++)
{
for (int y = 0; y < res.height; y++)
{
for (int x = 0; x < res.width; x++)
{
for (int z = 0; z < deep; z++)
{
for (int dy = 0; dy < b.height; dy++)
{
for (int dx = 0; dx < b.width; dx++)
{
res[0, s, y, x] += Math.Pow(elements[z * hw + (y + dy) * width + x + dx] - b[s, z, dy, dx], 2.0);
}
}
}
res[0, s, y, x] /= b.hw;
}
}
}
});
}
return(res);
}
