public override void Run(MatOperation operation, MyMemoryBlock <float> A, MyMemoryBlock <float> B, MyMemoryBlock <float> Result)
{
switch (operation)
{
case MatOperation.Multiplication: // vectors/matrices have to be always in the correct dimesions!
if (A.Count == 1) // valueA * B
{
Result.Fill(.0f);
A.SafeCopyToHost();
MyCublasFactory.Instance.Axpy(A.Host[0], B.GetDevice(callee), 1, Result.GetDevice(callee), 1);
}
else if (B.Count == 1) // A * valueB
{
Result.Fill(.0f);
B.SafeCopyToHost();
MyCublasFactory.Instance.Axpy(B.Host[0], A.GetDevice(callee), 1, Result.GetDevice(callee), 1);
}
else // another executions...
{
Run(operation, A.GetDevice(callee), A.Count, A.ColumnHint, B.GetDevice(callee), B.Count, B.ColumnHint, Result.GetDevice(callee), Result.Count, Result.ColumnHint, 0);
}
break;
case MatOperation.DotProd:
Run(operation, A.GetDevice(callee), A.Count, A.ColumnHint, B.GetDevice(callee), B.Count, B.ColumnHint, Result.GetDevice(callee), Result.Count, Result.ColumnHint, 0);
break;
default:
MyLog.Writer.WriteLine(MyLogLevel.ERROR, "Trying to run cublas for undefined MatOperation");
break;
}
}
public override void Run(MatOperation operation, MyMemoryBlock <float> A, MyMemoryBlock <float> B, MyMemoryBlock <float> Result)
{
Result.Fill(.0f);
switch (operation)
{
case MatOperation.EuclidDist:
if (B.Count == A.ColumnHint)
{
A.SafeCopyToHost();
B.SafeCopyToHost();
for (int row = 0; row < A.Count / A.ColumnHint; row++)
{
Result.Host[row] = 0;
for (int Bindex = 0; Bindex < B.Count; Bindex++)
{
Result.Host[row] += (B.Host[Bindex] - A.Host[A.ColumnHint * row + Bindex]) * (B.Host[Bindex] - A.Host[A.ColumnHint * row + Bindex]);
}
Result.Host[row] = (float)Math.Sqrt((double)Result.Host[row]);
//System.Console.Write(" " + Result.Host[row]);
}
Result.SafeCopyToDevice();
}
break;
default:
MyLog.Writer.WriteLine(MyLogLevel.ERROR, "Trying to run cpu mat ops. for undefined MatOperation");
break;
}
}
public override void Run(MatOperation operation, MyMemoryBlock<float> A, MyMemoryBlock<float> B, MyMemoryBlock<float> Result)
{
Result.Fill(.0f);
switch (operation)
{
case MatOperation.EuclidDist:
if (B.Count == A.ColumnHint)
{
A.SafeCopyToHost();
B.SafeCopyToHost();
for (int row = 0; row < A.Count / A.ColumnHint; row++)
{
Result.Host[row] = 0;
for (int Bindex = 0; Bindex < B.Count; Bindex++)
{
Result.Host[row] += (B.Host[Bindex] - A.Host[A.ColumnHint * row + Bindex]) * (B.Host[Bindex] - A.Host[A.ColumnHint * row + Bindex]);
}
Result.Host[row] = (float)Math.Sqrt( (double) Result.Host[row] );
//System.Console.Write(" " + Result.Host[row]);
}
Result.SafeCopyToDevice();
}
break;
default:
MyLog.Writer.WriteLine(MyLogLevel.ERROR, "Trying to run cpu mat ops. for undefined MatOperation");
break;
}
}
public override void Run(MatOperation operation, MyMemoryBlock <float> A, MyMemoryBlock <float> Result)
{
int itmp;
Result.Fill(.0f);
switch (operation)
{
case MatOperation.AbsMinIndex:
itmp = MyCublasFactory.Instance.Min(A.GetDevice(callee), 1);
Result.Fill((float)(itmp - 1));
break;
case MatOperation.AbsMaxIndex:
itmp = MyCublasFactory.Instance.Max(A.GetDevice(callee), 1);
Result.Fill((float)(itmp - 1));
break;
case MatOperation.Norm2:
MyCublasFactory.Instance.Norm2(A.GetDevice(callee), 1, Result.GetDevice(callee));
break;
case MatOperation.Normalize:
float nrm = MyCublasFactory.Instance.Norm2(A.GetDevice(callee), 1);
MyCublasFactory.Instance.Axpy(1 / nrm, A.GetDevice(callee), 1, Result.GetDevice(callee), 1);
break;
case MatOperation.Minus:
MyCublasFactory.Instance.Axpy(-1.0f, A.GetDevice(callee), 1, Result.GetDevice(callee), 1);
break;
case MatOperation.Copy:
MyCublasFactory.Instance.Copy(A.GetDevice(callee), 1, Result.GetDevice(callee), 1);
break;
default:
MyLog.Writer.WriteLine(MyLogLevel.ERROR, "Trying to run cublas for undefined MatOperation");
break;
}
}
public override void Run(MatOperation operation, MyMemoryBlock <float> A, float value, MyMemoryBlock <float> Result)
{
Result.Fill(.0f);
switch (operation)
{
case MatOperation.Multiplication:
MyCublasFactory.Instance.Axpy(value, A.GetDevice(callee), 1, Result.GetDevice(callee), 1);
break;
default:
MyLog.Writer.WriteLine(MyLogLevel.ERROR, "Trying to run cublas for undefined MatOperation");
break;
}
}
//--------------------------------------------------------------------
/// <summary>
///
/// </summary>
/// <param name="Vec">input vector</param>
/// <param name="dim">dimetiosn of the vec</param>
/// <param name="id_start">vec start dispalcement</param>
private void NormalizeVector(MyMemoryBlock <float> Vec, int dim, int id_start = 0)
{
CUdeviceptr VecDevPtr = Vec.GetDevicePtr(0, id_start * dim);
m_dotKernel.Run(Owner.TempVal, 0, VecDevPtr, VecDevPtr, dim);
Owner.TempVal.SafeCopyToHost();
float length = (float)Math.Sqrt(Owner.TempVal.Host[0]);
if (length != 0)
{
m_mulKernel.Run(0f, 0f, 1.0f / length, 0f, VecDevPtr, VecDevPtr, dim);
}
else
{
Vec.Fill(0);
}
}
public override void Run(MatOperation operation, MyMemoryBlock<float> A, float value, MyMemoryBlock<float> Result)
{
Result.Fill(.0f);
switch (operation)
{
case MatOperation.Multiplication:
MyCublasFactory.Instance.Axpy(value, A.GetDevice(callee), 1, Result.GetDevice(callee), 1);
break;
default:
MyLog.Writer.WriteLine(MyLogLevel.ERROR, "Trying to run cublas for undefined MatOperation");
break;
}
}
public override void Run(MatOperation operation, MyMemoryBlock<float> A, MyMemoryBlock<float> Result)
{
int itmp;
Result.Fill(.0f);
switch (operation)
{
case MatOperation.MinIndex:
itmp = MyCublasFactory.Instance.Min(A.GetDevice(callee), 1);
Result.Fill((float)(itmp - 1));
break;
case MatOperation.MaxIndex:
itmp = MyCublasFactory.Instance.Max(A.GetDevice(callee), 1);
Result.Fill((float)(itmp - 1));
break;
case MatOperation.Norm2:
MyCublasFactory.Instance.Norm2(A.GetDevice(callee), 1, Result.GetDevice(callee));
break;
case MatOperation.Normalize:
float nrm = MyCublasFactory.Instance.Norm2(A.GetDevice(callee), 1);
MyCublasFactory.Instance.Axpy(1 / nrm, A.GetDevice(callee), 1, Result.GetDevice(callee), 1);
break;
case MatOperation.Minus:
MyCublasFactory.Instance.Axpy(-1.0f, A.GetDevice(callee), 1, Result.GetDevice(callee), 1);
break;
case MatOperation.Copy:
MyCublasFactory.Instance.Copy(A.GetDevice(callee), 1, Result.GetDevice(callee), 1);
break;
default:
MyLog.Writer.WriteLine(MyLogLevel.ERROR, "Trying to run cublas for undefined MatOperation");
break;
}
}
public override void Run(MatOperation operation, MyMemoryBlock<float> A, MyMemoryBlock<float> B, MyMemoryBlock<float> Result)
{
switch (operation)
{
case MatOperation.Multiplication: // vectors/matrices have to be always in the correct dimesions!
if (A.Count == 1) // valueA * B
{
Result.Fill(.0f);
A.SafeCopyToHost();
MyCublasFactory.Instance.Axpy(A.Host[0], B.GetDevice(callee), 1, Result.GetDevice(callee), 1);
}
else if (B.Count == 1) // A * valueB
{
Result.Fill(.0f);
B.SafeCopyToHost();
MyCublasFactory.Instance.Axpy(B.Host[0], A.GetDevice(callee), 1, Result.GetDevice(callee), 1);
}
else // another executions...
{
Run(operation, A.GetDevice(callee), A.Count, A.ColumnHint, B.GetDevice(callee), B.Count, B.ColumnHint, Result.GetDevice(callee), Result.Count, Result.ColumnHint, 0);
}
break;
case MatOperation.DotProd:
Run(operation, A.GetDevice(callee), A.Count, A.ColumnHint, B.GetDevice(callee), B.Count, B.ColumnHint, Result.GetDevice(callee), Result.Count, Result.ColumnHint, 0);
break;
default:
MyLog.Writer.WriteLine(MyLogLevel.ERROR, "Trying to run cublas for undefined MatOperation");
break;
}
}
public void Run(VectorOperation operation,
MyMemoryBlock<float> a,
MyMemoryBlock<float> b,
MyMemoryBlock<float> result)
{
if (!Validate(operation, a.Count, b.Count))
return;
switch (operation)
{
case VectorOperation.Rotate:
{
b.SafeCopyToHost();
float rads = DegreeToRadian(b.Host[0]);
float[] transform = { (float)Math.Cos(rads), -(float)Math.Sin(rads), (float)Math.Sin(rads), (float)Math.Cos(rads) };
Array.Copy(transform, m_temp.Host, transform.Length);
m_temp.SafeCopyToDevice();
m_matOperation.Run(MatOperation.Multiplication, m_temp, a, result);
}
break;
case VectorOperation.Angle:
{
m_matOperation.Run(MatOperation.DotProd, a, b, result);
result.SafeCopyToHost();
float dotProd = result.Host[0];
float angle = RadianToDegree((float)Math.Acos(dotProd));
result.Fill(0);
result.Host[0] = angle;
result.SafeCopyToDevice();
}
break;
case VectorOperation.DirectedAngle:
{
result.Host[0] = -90;
result.SafeCopyToDevice();
Run(VectorOperation.Rotate, a, result, result);
result.CopyToMemoryBlock(m_temp, 0, 0, result.Count);
m_matOperation.Run(MatOperation.DotProd, a, b, result);
result.SafeCopyToHost();
float dotProd = result.Host[0];
float angle;
if (Math.Abs(Math.Abs(dotProd) - 1) < 1E-4)
angle = 0;
else
angle = RadianToDegree((float)Math.Acos(dotProd));
m_matOperation.Run(MatOperation.DotProd, m_temp, b, result);
result.SafeCopyToHost();
float perpDotProd = result.Host[0];
if (perpDotProd > 0)
angle *= -1;
result.Fill(0);
result.Host[0] = angle;
result.SafeCopyToDevice();
}
break;
}
}
public void Run(VectorOperation operation,
MyMemoryBlock <float> a,
MyMemoryBlock <float> b,
MyMemoryBlock <float> result)
{
if (!Validate(operation, a.Count, b.Count))
{
return;
}
switch (operation)
{
case VectorOperation.Rotate:
{
b.SafeCopyToHost();
float rads = DegreeToRadian(b.Host[0]);
float[] transform = { (float)Math.Cos(rads), -(float)Math.Sin(rads), (float)Math.Sin(rads), (float)Math.Cos(rads) };
Array.Copy(transform, m_temp.Host, transform.Length);
m_temp.SafeCopyToDevice();
m_matOperation.Run(MatOperation.Multiplication, m_temp, a, result);
}
break;
case VectorOperation.Angle:
{
m_matOperation.Run(MatOperation.DotProd, a, b, result);
result.SafeCopyToHost();
float dotProd = result.Host[0];
float angle = RadianToDegree((float)Math.Acos(dotProd));
result.Fill(0);
result.Host[0] = angle;
result.SafeCopyToDevice();
}
break;
case VectorOperation.DirectedAngle:
{
result.Host[0] = -90;
result.SafeCopyToDevice();
Run(VectorOperation.Rotate, a, result, result);
result.CopyToMemoryBlock(m_temp, 0, 0, result.Count);
m_matOperation.Run(MatOperation.DotProd, a, b, result);
result.SafeCopyToHost();
float dotProd = result.Host[0];
float angle;
if (Math.Abs(Math.Abs(dotProd) - 1) < 1E-4)
{
angle = 0;
}
else
{
angle = RadianToDegree((float)Math.Acos(dotProd));
}
m_matOperation.Run(MatOperation.DotProd, m_temp, b, result);
result.SafeCopyToHost();
float perpDotProd = result.Host[0];
if (perpDotProd > 0)
{
angle *= -1;
}
result.Fill(0);
result.Host[0] = angle;
result.SafeCopyToDevice();
}
break;
}
}
public override void Execute()
{
currentGen++;
// If not genetically training. Return
//Get first population member from the network
getFFWeights(population[0]);
population[0].SafeCopyToDevice();
if (!DirectEvolution)
{
MyCublasFactory.Instance.Gemm(Operation.NonTranspose, Operation.NonTranspose,
arr_size, arr_size, arr_size, 1.0f,
multiplier.GetDevice(Owner), arr_size,
population[0].GetDevice(Owner), arr_size,
0.0f, outputPop[0].GetDevice(Owner), arr_size
);
MyCublasFactory.Instance.Gemm(Operation.NonTranspose, Operation.Transpose,
arr_size, arr_size, arr_size, 1.0f,
outputPop[0].GetDevice(Owner), arr_size,
multiplier.GetDevice(Owner), arr_size,
0.0f, population[0].GetDevice(Owner), arr_size
);
}
//Read the saved coeffs from the initial weight matrix into the first chromosome
population[0].CopyToMemoryBlock(cudaMatrices, 0, 0, arr_size * arr_size);
m_extractKernel.SetupExecution(1);
m_extractKernel.Run(cudaMatrices, chromosomePop, CoefficientsSaved, arr_size);
// Recombine and grow the population
if (DirectEvolution)
{
m_geneticKernel.Run(cudaMatrices, arr_size, m_weights, Owner.PopulationSize, chromosomePop, noise, Owner.MutationRate, Owner.Survivors, fitnesses, marking, WeightMagnitude);
}
else
{
m_geneticKernel.Run(cudaMatrices, arr_size, CoefficientsSaved, Owner.PopulationSize, chromosomePop, noise, Owner.MutationRate, Owner.Survivors, fitnesses, marking, Alpha);
}
chromosomePop.SafeCopyToHost();
cudaMatrices.Fill(0.0f);
m_implantKernel.SetupExecution(Owner.PopulationSize);
m_implantKernel.Run(cudaMatrices, chromosomePop, CoefficientsSaved, arr_size);
for (int i = 0; i < Owner.PopulationSize; i++)
{
// Read the cudaMatrices into the population
population[i].CopyFromMemoryBlock(cudaMatrices, i * arr_size * arr_size, 0, arr_size * arr_size);
if (!DirectEvolution)
{
MyCublasFactory.Instance.Gemm(Operation.Transpose, Operation.NonTranspose,
arr_size, arr_size, arr_size, 1.0f,
multiplier.GetDevice(Owner), arr_size,
population[i].GetDevice(0), arr_size,
0.0f, outputPop[i].GetDevice(0), arr_size
);
MyCublasFactory.Instance.Gemm(Operation.NonTranspose, Operation.NonTranspose,
arr_size, arr_size, arr_size, 1.0f,
outputPop[i].GetDevice(0), arr_size,
multiplier.GetDevice(Owner), arr_size,
0.0f, population[i].GetDevice(0), arr_size
);
}
population[i].SafeCopyToHost();
noise.Host[i] = (float)m_rand.NextDouble();
}
noise.SafeCopyToDevice();
// Determine the fitness of each member
determineFitnesses();
chromosomePop.SafeCopyToHost();
#region Sort Chromosomes
//sort the chromosomes and populations by fitness
//bubble sort, can be improved
float tmpfit;
int len = Owner.PopulationSize;
int newlen;
while (len != 0)
{
newlen = 0;
for (int i = 1; i < len; i++)
{
if (fitnesses.Host[i - 1] < fitnesses.Host[i])
{
// Swap fitnesses on the host
tmpfit = fitnesses.Host[i - 1];
fitnesses.Host[i - 1] = fitnesses.Host[i];
fitnesses.Host[i] = tmpfit;
newlen = i;
// Swap Chromosomes on the device
for (int x = 0; x < CoefficientsSaved; x++)
{
tmpfit = chromosomePop.Host[i * CoefficientsSaved + x];
chromosomePop.Host[i * CoefficientsSaved + x] = chromosomePop.Host[(i - 1) * CoefficientsSaved + x];
chromosomePop.Host[(i - 1) * CoefficientsSaved + x] = tmpfit;
}
for (int x = 0; x < arr_size * arr_size; x++)
{
tmpfit = population[i - 1].Host[x];
population[i - 1].Host[x] = population[i].Host[x];
population[i].Host[x] = tmpfit;
}
}
}
len = newlen;
}
MyLog.INFO.WriteLine("Top {0} networks:", Math.Max(Owner.Survivors, Owner.PopulationSize / 10));
for (int i = 0; i < Math.Max(Owner.Survivors, Owner.PopulationSize / 10); i++)
{
MyLog.INFO.Write("Fitness of network {0} is: {1}", i, fitnesses.Host[i]);
if (i < Owner.Survivors)
{
MyLog.INFO.Write(" - surviving");
}
MyLog.INFO.Write(" \n");
}
#endregion
// Best candidate to write to the network is the top of the population list
MyLog.INFO.WriteLine("Fitness of selected network is: " + fitnesses.Host[0]);
if (fitnesses.Host[0] >= Owner.TargetFitness)
{
MyLog.INFO.WriteLine("Found satisfying network, halting...");
Owner.Owner.SimulationHandler.PauseSimulation();
}
setFFWeights(population[0]);
MyLog.INFO.WriteLine("Written weights to network");
if (currentGen >= Owner.Generations && Owner.Generations > 0)
{
MyLog.INFO.WriteLine("Generation limit reached, halting...");
Owner.Owner.SimulationHandler.PauseSimulation();
}
}
