public float RunReturn(DistanceOperation operation,
CudaDeviceVariable <float> A, int sizeA,
CudaDeviceVariable <float> B, int sizeB)
{
if (m_temp == null)
{
MyLog.ERROR.WriteLine("Init the object with a valid temp block of size at least one to enable RunReturn.");
return(float.NaN);
}
switch (operation)
{
case DistanceOperation.None:
return(float.NaN);
case DistanceOperation.EuclidDist:
Run(DistanceOperation.EuclidDistSquared, A, sizeA, B, sizeB, m_temp.GetDevice(m_caller), sizeA);
m_temp.SafeCopyToHost(0, 1);
return((float)Math.Sqrt(m_temp.Host[0]));
default:
Run(operation, A, sizeA, B, sizeB, m_temp.GetDevice(m_caller), sizeA);
m_temp.SafeCopyToHost(0, 1);
return(m_temp.Host[0]);
}
}
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;
}
}
/// <summary>
/// Returns float array of value from memory block of given node
/// </summary>
/// <param name="nodeId">Node ID</param>
/// <param name="blockName">Memory block name</param>
/// <returns>Retrieved values</returns>
public float[] GetValues(int nodeId, string blockName = "Output")
{
MyMemoryBlock <float> block = GetMemBlock(nodeId, blockName);
block.SafeCopyToHost();
return(block.Host);
}
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;
}
}
private void GenerateWeightFromInitialWeights()
{
m_weightBlock.SafeCopyToHost();
for (int i = 0; i < m_initialWeight.Length; i++)
{
m_weightBlock.Host[m_weightOffset + i] = m_initialWeight[i];
}
m_weightBlock.SafeCopyToDevice();
}
private void GenerateBiasFromInitialWeights()
{
m_biasBlock.SafeCopyToHost();
for (int i = 0; i < m_initialBias.Length; i++)
{
m_biasBlock.Host[m_biasOffset + i] = m_initialBias[i];
}
m_biasBlock.SafeCopyToDevice();
}
public void PrintMemBlock2Console(MyMemoryBlock <float> m, string s = "")
{
System.Console.Write(" + " + s + ": ");
m.SafeCopyToHost();
for (int i = 0; i < Math.Min(30, m.Count); i++)
{
System.Console.Write(m.Host[i] + " ");
}
System.Console.WriteLine("");
}
public override void Run(MatOperation operation, MyMemoryBlock <float> A, MyMemoryBlock <float> B, MyMemoryBlock <float> Result)
{
if (OpersKerlsDictionary.ContainsKey(operation))
{
if (operation == MatOperation.GetRow)
{
B.SafeCopyToHost();
OpersKerlsDictionary[operation].SetupExecution(A.ColumnHint);
OpersKerlsDictionary[operation].Run(A, A.Count, A.ColumnHint, Result, Result.Count, Result.ColumnHint, B.Host[0]);
}
else if (operation == MatOperation.GetCol)
{
B.SafeCopyToHost();
OpersKerlsDictionary[operation].SetupExecution(A.Count / A.ColumnHint);
OpersKerlsDictionary[operation].Run(A, A.Count, A.ColumnHint, Result, Result.Count, Result.ColumnHint, B.Host[0]);
}
else if (operation == MatOperation.MultiplElemntWise | operation == MatOperation.Addition | operation == MatOperation.Substraction | operation == MatOperation.Pow)
{
if (A.Count >= B.Count)
{
OpersKerlsDictionary[operation].SetupExecution(A.Count);
OpersKerlsDictionary[operation].Run(A, A.Count, A.ColumnHint, B, B.Count, B.ColumnHint, Result, Result.Count, Result.ColumnHint, float.NaN);
}
else
{
OpersKerlsDictionary[operation].SetupExecution(B.Count);
OpersKerlsDictionary[operation].Run(B, B.Count, B.ColumnHint, A, A.Count, A.ColumnHint, Result, Result.Count, Result.ColumnHint, float.NaN);
}
}
else
{ // other executions are performed by ,,standartezied'' kernel-call
OpersKerlsDictionary[operation].SetupExecution(A.Count);
OpersKerlsDictionary[operation].Run(A, A.Count, A.ColumnHint, B, B.Count, B.ColumnHint, Result, Result.Count, Result.ColumnHint);
}
}
else
{
MyLog.Writer.WriteLine(MyLogLevel.ERROR, "Trying to run kernel MatrixOps for uninitialized kernel");
}
}
private bool CropHasUsefullValueAndCopy2Host(MyMemoryBlock <float> Crop)
{
if (Owner.XCrop == null)
{
return(false);
}
Crop.SafeCopyToHost();
if (Crop.Host[0] < 0.1f && Crop.Host[0] > -0.1f)
{
return(false);
}
return(true);
}
/// <summary>
/// Normalizes vectors along the leading dimension.
/// </summary>
public static void NormalizeLeadingDim(
MyMemoryBlock <float> vectors, MyMemoryBlock <float> temp,
int leadingDim, int otherDim,
MyProductKernel <float> dotKernel, MyCudaKernel multKernel, int GPU)
{
var count = leadingDim * otherDim;
Debug.Assert(vectors != null && temp != null, "Missing data!");
Debug.Assert(dotKernel != null && multKernel != null, "Missing kernels.");
Debug.Assert(leadingDim > 0 && otherDim > 0, "Negative matrix dimensions!");
Debug.Assert(vectors.Count >= count, "Too little vectors to orthonormalize!");
Debug.Assert(temp.Count >= Math.Max(leadingDim, otherDim), "Too little temp space!");
multKernel.SetupExecution(leadingDim);
for (int i = 0; i < otherDim; i++)
{
var seg = vectors.GetDevicePtr(GPU, i * leadingDim);
//dotKernel.Run(temp, i, seg, seg, leadingDim, /* distributed: */ 0);
dotKernel.outOffset = i;
dotKernel.Run(temp, seg, seg, leadingDim);
}
temp.SafeCopyToHost(0, otherDim);
for (int i = 0; i < otherDim; i++)
{
if (temp.Host[i] < 0.0000001f)
{
temp.Host[i] = 0;
}
else
{
temp.Host[i] = (float)(1 / Math.Sqrt(temp.Host[i]));
}
}
temp.SafeCopyToDevice(0, otherDim);
for (int i = 0; i < otherDim; i++)
{
var seg = vectors.GetDevicePtr(GPU, i * leadingDim);
var len = temp.GetDevicePtr(GPU, i);
multKernel.Run(seg, len, seg, (int)MyJoin.MyJoinOperation.Multiplication, leadingDim, 1);
}
}
public float getValMax_inColumn(MyMemoryBlock <float> dt, int column)
{
dt.SafeCopyToHost();
float max = -1000.0f;
for (int i = 0; i < dt.Count / dt.ColumnHint; i++)
{
int idx = i * dt.ColumnHint + column;
if (dt.Host[idx] > max)
{
max = dt.Host[idx];
}
}
return(max);
}
private bool CropHasUsefullValueAndCopy2Host(MyMemoryBlock <float> Crop)
{
if (Crop == null)
{
MyLog.WARNING.WriteLine("One Crop not connected, not cropping this dimension");
return(false);
}
Crop.SafeCopyToHost();
// deadband aroud zero
if (Crop.Host[0] < 0.1f && Crop.Host[0] > -0.1f)
{
return(false);
}
return(true);
}
private List <int> GetListOfMaxValues(MyMemoryBlock <float> data)
{
data.SafeCopyToHost();
float maxVal = float.MinValue;
for (int i = 0; i < data.Count; i++)
{
if (data.Host[i] > maxVal)
{
maxVal = data.Host[i];
}
}
List <int> maxIndexes = new List <int>();
for (int i = 0; i < data.Count; i++)
{
if (data.Host[i] == maxVal)
{
maxIndexes.Add(i);
}
}
return(maxIndexes);
}
public void PrintMemBlock2Console(MyMemoryBlock<float> m, string s = "")
{
System.Console.Write(" + " + s + ": ");
m.SafeCopyToHost();
for (int i = 0; i < Math.Min(30,m.Count); i++)
{
System.Console.Write(m.Host[i]+" ");
}
System.Console.WriteLine("");
}
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;
}
}
/// <summary>
/// Normalizes vectors along the leading dimension.
/// </summary>
public static void NormalizeLeadingDim(
MyMemoryBlock<float> vectors, MyMemoryBlock<float> temp,
int leadingDim, int otherDim,
MyProductKernel<float> dotKernel, MyCudaKernel multKernel, int GPU)
{
var count = leadingDim * otherDim;
Debug.Assert(vectors != null && temp != null, "Missing data!");
Debug.Assert(dotKernel != null && multKernel != null, "Missing kernels.");
Debug.Assert(leadingDim > 0 && otherDim > 0, "Negative matrix dimensions!");
Debug.Assert(vectors.Count >= count, "Too little vectors to orthonormalize!");
Debug.Assert(temp.Count >= Math.Max(leadingDim, otherDim), "Too little temp space!");
multKernel.SetupExecution(leadingDim);
for (int i = 0; i < otherDim; i++)
{
var seg = vectors.GetDevicePtr(GPU, i * leadingDim);
//dotKernel.Run(temp, i, seg, seg, leadingDim, /* distributed: */ 0);
dotKernel.outOffset = i;
dotKernel.Run(temp, seg, seg, leadingDim);
}
temp.SafeCopyToHost(0, otherDim);
for (int i = 0; i < otherDim; i++)
{
if (temp.Host[i] < 0.0000001f)
temp.Host[i] = 0;
else
temp.Host[i] = (float)(1 / Math.Sqrt(temp.Host[i]));
}
temp.SafeCopyToDevice(0, otherDim);
for (int i = 0; i < otherDim; i++)
{
var seg = vectors.GetDevicePtr(GPU, i * leadingDim);
var len = temp.GetDevicePtr(GPU, i);
multKernel.Run(seg, len, seg, (int)MyJoin.MyJoinOperation.Multiplication, leadingDim, 1);
}
}
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();
}
}
public float RunReturn(MatOperation operation, MyMemoryBlock<float> A, MyMemoryBlock<float> Result)
{
Run(operation, A, Result);
Result.SafeCopyToHost();
return Result.Host[0];
}
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 Render()
{
GL.ClearColor(.15f, .15f, .15f, 0.0f);
GL.Enable(EnableCap.AlphaTest);
GL.Disable(EnableCap.DepthTest);
//Gl.AlphaFunc(GL_NOTEQUAL, 0);
GL.Enable(EnableCap.Blend);
GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.One);
GL.Enable(EnableCap.PointSmooth);
//////////////////////////////////////////////////////
// P O I N T S
GL.Enable(EnableCap.PointSmooth);
GL.PointSize(4.0f);
GL.Begin(PrimitiveType.Points);
MyAbstractLayer currentLayer = m_firstLayer;
MyMemoryBlock <float> memBlockData2Vis = currentLayer.Output;
bool normalizeData2Vis = false;
int a = 0;
while (currentLayer != null)
{
//--- which data to dispaly
switch (ThisObserverObject.PointVisMode)
{
case MyNeuralNetworkGroupObserver.MyPointVisMode.Output:
memBlockData2Vis = currentLayer.Output;
break;
case MyNeuralNetworkGroupObserver.MyPointVisMode.Delta:
memBlockData2Vis = currentLayer.Delta;
normalizeData2Vis = true;
break;
default:
memBlockData2Vis = currentLayer.Output;
break;
}
memBlockData2Vis.SafeCopyToHost();
//--- go through neurons and plot each
for (int j = 0; j < currentLayer.Neurons; j++) // this is super in efficint :(
{
int id = a * m_dataDim;
float val = memBlockData2Vis.Host[j];
val = Math.Abs(val); // value has to be >0
if (normalizeData2Vis) // norlaimnze deltas :)
{
val = val * 3f;
}
System.Drawing.Color col = MyObserverHelpers.ColorFromHSV(120f, 0.5f, Math.Min(val, 1.0f)); // value has to be 0-1
GL.Color3(col.R / 256f, col.G / 256f, col.B / 256f);
GL.Vertex3(m_data[id], m_data[id + 1], m_data[id + 2]);
++a;
}
MyAbstractLayer nextLayer = currentLayer.NextTopologicalLayer;
currentLayer = currentLayer.NextTopologicalLayer;
}
GL.End();
//////////////////////////////////////////////////////
// L I N E S
if (ThisObserverObject.EdgeVisMode != MyNeuralNetworkGroupObserver.MyEdgeVisMode.None)
{
GL.LineWidth(0.1f);
GL.Color4(.2f, .2f, .5f, 0.06f);
GL.Begin(PrimitiveType.Lines);
currentLayer = m_firstLayer;
int curIdxStart = 0; // start of the current index
while (currentLayer != null)
{
int nextIdxStart = curIdxStart + currentLayer.Neurons;
MyAbstractLayer nextLayer = currentLayer.NextTopologicalLayer;
if (nextLayer != null)
{
//--- what to show
switch (ThisObserverObject.EdgeVisMode)
{
case MyNeuralNetworkGroupObserver.MyEdgeVisMode.Ones:
break;
case MyNeuralNetworkGroupObserver.MyEdgeVisMode.Output:
currentLayer.Output.SafeCopyToHost();
break;
case MyNeuralNetworkGroupObserver.MyEdgeVisMode.Weights:
(nextLayer as MyHiddenLayer).Weights.SafeCopyToHost();
break;
case MyNeuralNetworkGroupObserver.MyEdgeVisMode.WeightsXOut:
(nextLayer as MyHiddenLayer).Weights.SafeCopyToHost();
currentLayer.Output.SafeCopyToHost();
break;
default:
break;
}
for (int nc = 0; nc < currentLayer.Neurons; nc++)
{
for (int nn = 0; nn < nextLayer.Neurons; nn++)
{
float edgeWeight = .007f;
switch (ThisObserverObject.EdgeVisMode)
{
case MyNeuralNetworkGroupObserver.MyEdgeVisMode.Output:
edgeWeight = currentLayer.Output.Host[nc] / 50f;
break;
case MyNeuralNetworkGroupObserver.MyEdgeVisMode.Weights:
edgeWeight = (nextLayer as MyHiddenLayer).Weights.Host[nn * currentLayer.Neurons + nc];
break;
case MyNeuralNetworkGroupObserver.MyEdgeVisMode.WeightsXOut:
edgeWeight = currentLayer.Output.Host[nc];
edgeWeight *= (nextLayer as MyHiddenLayer).Weights.Host[nn * currentLayer.Neurons + nc];
break;
default:
break;
}
int i_c = (nc + curIdxStart) * m_dataDim; // index current
int i_n = (nn + nextIdxStart) * m_dataDim; // index next
GL.Color4(.5f, .5f, .5f, edgeWeight * ThisObserverObject.EdgeVisMultiplier);
GL.Vertex3(m_data[i_c], m_data[i_c + 1], m_data[i_c + 2]);
GL.Vertex3(m_data[i_n], m_data[i_n + 1], m_data[i_n + 2]);
}
}
}
currentLayer = nextLayer;
curIdxStart = nextIdxStart;
}
GL.End();
}
}
public override void Run(MatOperation operation, MyMemoryBlock<float> A, MyMemoryBlock<float> B, MyMemoryBlock<float> Result)
{
if (OpersKerlsDictionary.ContainsKey(operation))
{
if (operation == MatOperation.GetRow)
{
B.SafeCopyToHost();
OpersKerlsDictionary[operation].SetupExecution(A.ColumnHint);
OpersKerlsDictionary[operation].Run(A, A.Count, A.ColumnHint, Result, Result.Count, Result.ColumnHint, B.Host[0]);
}
else if (operation == MatOperation.GetCol)
{
B.SafeCopyToHost();
OpersKerlsDictionary[operation].SetupExecution(A.Count / A.ColumnHint);
OpersKerlsDictionary[operation].Run(A, A.Count, A.ColumnHint, Result, Result.Count, Result.ColumnHint, B.Host[0]);
}
else if (operation == MatOperation.MultiplElemntWise | operation == MatOperation.Addition | operation == MatOperation.Substraction | operation == MatOperation.Pow)
{
if (A.Count >= B.Count)
{
OpersKerlsDictionary[operation].SetupExecution(A.Count);
OpersKerlsDictionary[operation].Run(A, A.Count, A.ColumnHint, B, B.Count, B.ColumnHint, Result, Result.Count, Result.ColumnHint, float.NaN);
}
else
{
OpersKerlsDictionary[operation].SetupExecution(B.Count);
OpersKerlsDictionary[operation].Run(B, B.Count, B.ColumnHint, A, A.Count, A.ColumnHint, Result, Result.Count, Result.ColumnHint, float.NaN);
}
}
else
{ // other executions are performed by ,,standartezied'' kernel-call
OpersKerlsDictionary[operation].SetupExecution(A.Count);
OpersKerlsDictionary[operation].Run(A, A.Count, A.ColumnHint, B, B.Count, B.ColumnHint, Result, Result.Count, Result.ColumnHint);
}
}
else
{
MyLog.Writer.WriteLine(MyLogLevel.ERROR, "Trying to run kernel MatrixOps for uninitialized kernel");
}
}
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 float RunReturn(MatOperation operation, MyMemoryBlock <float> A, MyMemoryBlock <float> Result)
{
Run(operation, A, Result);
Result.SafeCopyToHost();
return(Result.Host[0]);
}
