float NearestCC_dist; //. similarity to closest
public override void Init(int nGPU)
{
m_kernel_AddNewCCenter = MyKernelFactory.Instance.Kernel(nGPU, @"Vision\KMeansWM", "AddDataAsCC");
m_kernel_AddNewCCenter.SetupExecution(Owner.DescCount);
m_kernel_UpadteCC_desc = MyKernelFactory.Instance.Kernel(nGPU, @"Vision\KMeansWM", "UpadateCC_Desc");
m_kernel_UpadteCC_desc.SetupExecution(Owner.DescCount);
m_kernel_UpdateCC_XY = MyKernelFactory.Instance.Kernel(nGPU, @"Vision\KMeansWM", "UpdateCC_XY");
m_kernel_UpdateCC_XY.SetupExecution(Owner.ObjectXY.Count);
m_dotKernel = MyReductionFactory.Kernel(nGPU, MyReductionFactory.Mode.f_DotProduct_f);
m_mulKernel = MyKernelFactory.Instance.Kernel(nGPU, @"Transforms\TransformKernels", "PolynomialFunctionKernel");
m_mulKernel.SetupExecution(Owner.DescCount);
m_matMultpl = MyKernelFactory.Instance.Kernel(Owner.GPU, @"Common\CombineVectorsKernel", "MatMultipl_naive");
m_matMultpl.GridDimensions = new ManagedCuda.VectorTypes.dim3(1, Owner.DescCount);
m_matMultpl.BlockDimensions = new ManagedCuda.VectorTypes.dim3(1, 1);
m_minIdxKernel = MyReductionFactory.Kernel(nGPU, MyReductionFactory.Mode.f_MinIdx_ff);
m_kernel_UpdateXY_basedOnTheBrainsMovement = MyKernelFactory.Instance.Kernel(nGPU, @"Vision\KMeansWM", "ApplyBrainsMovement");
m_kernel_UpdateCC_XY.SetupExecution(Owner.MaxClusters);
}
public MyJoinPatchesObserver()
{
m_kernel_fillImWhite = MyKernelFactory.Instance.Kernel(MyKernelFactory.Instance.DevCount - 1, @"Vision\JoinPatchesObs", "FillImWhite");
m_kernel_fillImFromIm = MyKernelFactory.Instance.Kernel(MyKernelFactory.Instance.DevCount - 1, @"Vision\JoinPatchesObs", "FillImByOtherIm");
m_kernel_drawEdges = MyKernelFactory.Instance.Kernel(MyKernelFactory.Instance.DevCount - 1, @"Vision\JoinPatchesObs", "Draw_edges");
m_kernel_drawDesc = MyKernelFactory.Instance.Kernel(MyKernelFactory.Instance.DevCount - 1, @"Vision\JoinPatchesObs", "FillImByEnergy");
}
public MyGradientBackPropAgent(MyAbstractFeedForwardNode network, int nGPU, MyMemoryBlock<float> labelInput)
: base(network)
{
m_updateWeightKernel = MyKernelFactory.Instance.Kernel(nGPU, @"XmlFeedForwardNet\UpdateWeightKernel");
DeltaProvider = new MyLabelDeltaProvider(m_network, nGPU);
DeltaProvider.LabelInput = labelInput;
}
public override void Init(int nGPU)
{
m_samplingDeltaKernel = MyKernelFactory.Instance.Kernel(nGPU, @"NeuralNetwork\Layer\DeltaKernels", "GaussianSamplingDeltaKernel");
m_samplingDeltaKernel.SetupExecution(Owner.Neurons);
m_regularizationDeltaKernel = MyKernelFactory.Instance.Kernel(nGPU, @"NeuralNetwork\Layer\RegularizationTermKernels", "GaussianRegularizationDeltaKernel");
}
public override void Init(int nGPU)
{
switch (Owner.LearningTasks)
{
case MyLSTMLayer.LearningTasksType.RTRL:
{
m_deltaKernel = MyKernelFactory.Instance.Kernel(nGPU, @"LSTM\LSTMDeltaKernel", "LSTMDeltaKernel");
m_deltaBackKernel = MyKernelFactory.Instance.Kernel(nGPU, @"LSTM\LSTMDeltaKernel", "LSTMDeltaBackKernel");
break;
}
case MyLSTMLayer.LearningTasksType.BPTT:
{
m_deltaKernel = MyKernelFactory.Instance.Kernel(nGPU, @"LSTM\LSTMDeltaKernel", "LSTMDeltaKernelBPTT");
m_gateGradientKernel = MyKernelFactory.Instance.Kernel(nGPU, @"LSTM\LSTMDeltaKernel", "LSTMGateGradientKernelBPTT");
m_cellInputGradientKernel = MyKernelFactory.Instance.Kernel(nGPU, @"LSTM\LSTMDeltaKernel", "LSTMCellInputGradientKernelBPTT");
m_deltaBackKernel = MyKernelFactory.Instance.Kernel(nGPU, @"LSTM\LSTMDeltaKernel", "LSTMDeltaBackKernelBPTT");
m_gateGradientKernel.SetupExecution((Owner.Input.Count + Owner.Output.Count + Owner.CellsPerBlock + 1) * Owner.MemoryBlocks);
m_cellInputGradientKernel.SetupExecution((Owner.Input.Count + Owner.Output.Count + 1) * Owner.CellStates.Count);
break;
}
}
m_deltaKernel.SetupExecution(Owner.MemoryBlocks);
}
public override void Init(int nGPU)
{
if (DecayFactor != 1f)
{
if (DecayFactor > 1f)
{
MyLog.WARNING.WriteLine("Decay factor on a HashingMemoryNode that is greater than one is suspicious...");
}
_polynomialFuncKernel = MyKernelFactory.Instance.Kernel(nGPU, @"Transforms\TransformKernels", "PolynomialFunctionKernel");
_polynomialFuncKernel.SetupExecution(Memory.Count);
}
if (AddFactor != 1f)
{
_constMulKernel = MyKernelFactory.Instance.Kernel(nGPU, @"Transforms\TransformKernels", "PolynomialFunctionKernel");
_constMulKernel.SetupExecution(Owner.SymbolSize);
}
if (NormalizeTarget)
{
_combineVectorsKernel = MyKernelFactory.Instance.Kernel(nGPU, @"Common\CombineVectorsKernel", "CombineTwoVectorsKernel");
_combineVectorsKernel.SetupExecution(Owner.SymbolSize);
_mapToIdcsKernel = MyKernelFactory.Instance.Kernel(nGPU, @"Common\CombineVectorsKernel", "MapToIdcs");
_mapToIdcsKernel.SetupExecution(Owner.SymbolSize);
_dotKernel = MyReductionFactory.Kernel(nGPU, MyReductionFactory.Mode.f_DotProduct_f);
}
else
{
_mapToIdcsKernel = MyKernelFactory.Instance.Kernel(nGPU, @"common\CombineVectorsKernel", "AddToIdcs");
_mapToIdcsKernel.SetupExecution(Owner.SymbolSize);
}
Temp.SafeCopyToHost();
}
public MyFourierBinder(MyWorkingNode owner, int inputSize, MyMemoryBlock <float> tempBlock)
: base(owner, inputSize, tempBlock)
{
m_fft = new CudaFFTPlan1D(inputSize, cufftType.R2C, 1);
m_ifft = new CudaFFTPlan1D(inputSize, cufftType.C2R, 1);
m_mulkernel = MyKernelFactory.Instance.Kernel(owner.GPU, @"Common\CombineVectorsKernel", "MulComplexElementWise");
m_mulkernel.SetupExecution(inputSize + 1);
m_involutionKernel = MyKernelFactory.Instance.Kernel(owner.GPU, @"Common\CombineVectorsKernel", "InvolveVector");
m_involutionKernel.SetupExecution(inputSize - 1);
m_inversionKernel = MyKernelFactory.Instance.Kernel(owner.GPU, @"Transforms\InvertValuesKernel", "InvertLengthComplexKernel");
m_inversionKernel.SetupExecution(inputSize);
m_dotKernel = MyReductionFactory.Kernel(owner.GPU, MyReductionFactory.Mode.f_DotProduct_f);
m_normalKernel = MyKernelFactory.Instance.Kernel(owner.GPU, @"Transforms\TransformKernels", "PolynomialFunctionKernel");
m_normalKernel.SetupExecution(inputSize);
m_firstFFTOffset = 0;
m_secondFFTOffset = (inputSize + 1) * 2;
m_tempOffset = (inputSize + 1) * 4;
Denominator = inputSize;
}
public override void Init(int nGPU)
{
base.Init(nGPU);
m_applyThresholdKernel = MyKernelFactory.Instance.Kernel(nGPU, @"Vision\VisionMath", "ApplyThreshold");
m_applyThresholdKernel.SetupExecution(Owner.MaskOutput.Count);
}
/// <summary>
/// Transforms the <paramref name="output"/> vector into a vector of indices with properties specified by the parameters.
/// </summary>
/// <param name="input">The vector to transform.</param>
/// <param name="output">The memory to contain the results.</param>
/// <param name="misc">A vector containing the range to modulate to as the first value (typically 2f because dot product ranges from [-1,1])
/// and the bin size in this modulated space (typically <paramref name="misc"/>[0] / internalBinCount) as the second value.</param>
/// <param name="offsets">The random offsets for each <paramref name="output"/> value (typically uniform random numbers in [0, <paramref name="misc"/>[0].</param>
/// <param name="vectorSize">The length of the <paramref name="output"/> vector.</param>
/// <param name="outputBinCount">The range into which the internal bins will be scattered.</param>
/// <param name="seed">The seed used for the scattering the internal bins.</param>
/// <param name="combineVectorsKernel">The kernel used for addition, modulo and integer division.</param>
/// <param name="hashKernel">The kernel used for scattering the internal bins.</param>
/// <param name="noHashKernel"></param>
/// <param name="doHashMapping"></param>
/// <param name="internalBinCount"></param>
/// <param name="stream"></param>
public static void GetIndices(
CUdeviceptr input, CUdeviceptr output, CUdeviceptr misc, CUdeviceptr?offsets,
int vectorSize, int outputBinCount, int seed,
MyCudaKernel combineVectorsKernel, MyCudaKernel hashKernel, MyCudaKernel noHashKernel,
bool doHashMapping, int internalBinCount,
CudaStream stream)
{
Debug.Assert(vectorSize > 0, "Invalid vector size");
Debug.Assert(outputBinCount > 1, "Requires at least 2 output bins");
Debug.Assert(combineVectorsKernel != null && hashKernel != null, "Missing kernels");
// Values are in [-1, 1] if they were normalized
if (offsets != null)
{
// Offset to [-1, 3]
combineVectorsKernel.RunAsync(stream, input, offsets.Value, output, (int)MyJoin.MyJoinOperation.Addition, vectorSize, vectorSize);
}
// Modulate to [0, 2]
combineVectorsKernel.RunAsync(stream, output, misc, output, (int)MyJoin.MyJoinOperation.Modulo, vectorSize, 1);
// Transform to integers in [0, InternalBinCount - 1]
combineVectorsKernel.RunAsync(stream, output, misc + sizeof(float), output, (int)MyJoin.MyJoinOperation.Division_int, vectorSize, 1);
if (doHashMapping)
{
hashKernel.RunAsync(stream, output, output, vectorSize, vectorSize, outputBinCount, seed);
}
else
{
noHashKernel.RunAsync(stream, output, output, vectorSize, internalBinCount);
}
}
protected override void Execute()
{
if (Target.Image == null)
{
Target.NOfObjects.SafeCopyToHost();
m_kernel_downInTime.SetupExecution(TextureWidth * TextureHeight);
m_kernel_downInTime.Run(VBODevicePointer, TextureWidth * TextureHeight);
m_kernel_fillImActSate.GridDimensions = new ManagedCuda.VectorTypes.dim3((int)Target.NOfObjects.Host[0]); // numbe rof clusters to print
m_kernel_fillImActSate.BlockDimensions = new ManagedCuda.VectorTypes.dim3(16, 16); // size of square
// m_kernel_fillImActSate.Run(VBODevicePointer, TextureWidth, TextureWidth * TextureHeight, Target.ClusCentersXY, Target.ClusCentersXY.ColumnHint, Target.MaxClusters, 1, Target.ClusCentersSize, GetMaxFreqOfClusters());
m_kernel_fillImActSate.Run(VBODevicePointer, TextureWidth, TextureWidth * TextureHeight, Target.ClusCentersXY, Target.ClusCentersXY.ColumnHint, Target.MaxClusters, 1, Target.ClusCentersLastSeen, 2.0f, IsXYInputInOneNorm());
}
if (Target.Image != null)
{
MyCudaKernel m_ker = MyKernelFactory.Instance.Kernel(MyKernelFactory.Instance.DevCount - 1, @"Vision\VisionObsFce", "FillVBOFromInputImage");
m_ker.SetupExecution(TextureWidth * TextureHeight);
m_ker.Run(Target.Image, TextureWidth * TextureHeight, VBODevicePointer);
m_ker = MyKernelFactory.Instance.Kernel(MyKernelFactory.Instance.DevCount - 1, @"Vision\KMeansWM", "FocuserInputObserver");
m_ker.SetupExecution(TextureWidth * TextureHeight);
// FocuserInputObserver(float* values, float* pupilControl, int id_pupil , int inputWidth, int inputHeight, unsigned int* pixels, float color)
m_ker.Run(Target.Image, Target.ClusCentersXY, 4, TextureWidth, TextureHeight, VBODevicePointer, 0.0f);
m_ker.Run(Target.Image, Target.ClusCentersXY, 3, TextureWidth, TextureHeight, VBODevicePointer, 0.1f);
m_ker.Run(Target.Image, Target.ClusCentersXY, 2, TextureWidth, TextureHeight, VBODevicePointer, 0.2f);
m_ker.Run(Target.Image, Target.ClusCentersXY, 1, TextureWidth, TextureHeight, VBODevicePointer, 0.3f);
m_ker.Run(Target.Image, Target.ClusCentersXY, 0, TextureWidth, TextureHeight, VBODevicePointer, 0.4f);
}
}
public MySegmentObserver()
{
m_kernel_draw = MyKernelFactory.Instance.Kernel(MyKernelFactory.Instance.DevCount - 1, @"Vision\SegmentObs", "Draw");
k_test = MyKernelFactory.Instance.Kernel(MyKernelFactory.Instance.DevCount - 1, @"Vision\SegmentObs", "Test_draw_xy");
k_test.SetupExecution(new dim3(1), new dim3(1));
}
public override void Init(Int32 nGPU)
{
switch (Owner.Interpolation)
{
case InterpolationType.Bilinear:
m_kernel = MyKernelFactory.Instance.Kernel(nGPU, @"Transforms\Transform2DKernels", "BilinearResampleKernel");
m_kernel.SetupExecution(Owner.outputWidth * Owner.outputHeight);
break;
case InterpolationType.Exact1toN:
if (Owner.GetTransformationType() == ExactTransformationType.Increasing)
{
m_kernel = MyKernelFactory.Instance.Kernel(nGPU, @"Transforms\Transform2DKernels", "ExactResampleKernel_1toN");
}
else
{
m_kernel = MyKernelFactory.Instance.Kernel(nGPU, @"Transforms\Transform2DKernels", "ExactResampleKernel_Nto1");
}
m_kernel.SetupExecution(Owner.outputWidth * Owner.outputHeight);
break;
default:
throw new InvalidEnumArgumentException("Unknown interpolation type " + Owner.Interpolation);
}
}
public static void DrawString(string str, int x, int y, uint bgColor, uint fgColor, CUdeviceptr image, int imageWidth, int imageHeight)
{
// Crop if the string is too long
if (str.Length > 20)
{
str = str.Substring(0, 20);
}
MyCudaKernel m_drawDigitKernel = MyKernelFactory.Instance.Kernel(MyKernelFactory.Instance.DevCount - 1, @"Observers\DrawDigitsKernel");
CudaDeviceVariable <float> characters = MyMemoryManager.Instance.GetGlobalVariable <float>("CHARACTERS_TEXTURE", MyKernelFactory.Instance.DevCount - 1, LoadDigits);
m_drawDigitKernel.SetConstantVariable("D_BG_COLOR", bgColor);
m_drawDigitKernel.SetConstantVariable("D_FG_COLOR", fgColor);
m_drawDigitKernel.SetConstantVariable("D_IMAGE_WIDTH", imageWidth);
m_drawDigitKernel.SetConstantVariable("D_IMAGE_HEIGHT", imageHeight);
m_drawDigitKernel.SetConstantVariable("D_DIGIT_WIDTH", CharacterWidth);
m_drawDigitKernel.SetConstantVariable("D_DIGIT_SIZE", CharacterSize);
m_drawDigitKernel.SetConstantVariable("D_DIGITMAP_NBCHARS", CharacterMapNbChars);
int[] indexes = stringToDigitIndexes(str);
m_drawDigitKernel.SetConstantVariable("D_DIGIT_INDEXES", indexes);
m_drawDigitKernel.SetConstantVariable("D_DIGIT_INDEXES_LEN", indexes.Length);
m_drawDigitKernel.SetupExecution(CharacterSize * indexes.Length);
m_drawDigitKernel.Run(image, characters.DevicePointer, x, y);
}
public MyGradientBackPropAgent(MyAbstractFeedForwardNode network, int nGPU, MyMemoryBlock <float> labelInput)
: base(network)
{
m_updateWeightKernel = MyKernelFactory.Instance.Kernel(nGPU, @"XmlFeedForwardNet\UpdateWeightKernel");
DeltaProvider = new MyLabelDeltaProvider(m_network, nGPU);
DeltaProvider.LabelInput = labelInput;
}
public override void Init(Int32 nGPU)
{
if (Owner.OutputSize <= 0)
{
return;
}
m_pixelCount = Owner.InputSize;
switch (Owner.Target)
{
case TransformTarget.RGB:
m_kernel = MyKernelFactory.Instance.Kernel(nGPU, @"Drawing\RgbaDrawing", "RawToRgbKernel");
break;
case TransformTarget.RawBW:
m_kernel = MyKernelFactory.Instance.Kernel(nGPU, @"Drawing\RgbaDrawing", "RawToRawGrayscaleKernel");
break;
case TransformTarget.Grayscale:
m_kernel = MyKernelFactory.Instance.Kernel(nGPU, @"Drawing\RgbaDrawing", "RawToGrayscaleKernel");
break;
}
m_kernel.SetupExecution(m_pixelCount);
}
public MyFourierBinder(MyWorkingNode owner, int inputSize, MyMemoryBlock<float> tempBlock)
: base(owner, inputSize, tempBlock)
{
m_stream = new CudaStream();
m_fft = new CudaFFTPlan1D(inputSize, cufftType.R2C, 1);
m_fft.SetStream(m_stream.Stream);
m_ifft = new CudaFFTPlan1D(inputSize, cufftType.C2R, 1);
m_ifft.SetStream(m_stream.Stream);
m_mulkernel = MyKernelFactory.Instance.Kernel(owner.GPU, @"Common\CombineVectorsKernel", "MulComplexElementWise");
m_mulkernel.SetupExecution(inputSize + 1);
m_involutionKernel = MyKernelFactory.Instance.Kernel(owner.GPU, @"Common\CombineVectorsKernel", "InvolveVector");
m_involutionKernel.SetupExecution(inputSize - 1);
m_inversionKernel = MyKernelFactory.Instance.Kernel(owner.GPU, @"Transforms\InvertValuesKernel", "InvertLengthComplexKernel");
m_inversionKernel.SetupExecution(inputSize);
m_dotKernel = MyKernelFactory.Instance.KernelProduct<float>(owner, owner.GPU, ProductMode.f_DotProduct_f);
m_normalKernel = MyKernelFactory.Instance.Kernel(owner.GPU, @"Transforms\TransformKernels", "PolynomialFunctionKernel");
m_normalKernel.SetupExecution(inputSize);
m_firstFFTOffset = 0;
m_secondFFTOffset = (inputSize + 1) * 2;
m_tempOffset = (inputSize + 1) * 4;
Denominator = inputSize;
}
public override void Init(int nGPU)
{
switch (Mode)
{
case HashMapperMode.Simple:
break;
case HashMapperMode.LocalitySensitive:
MyMemoryManager.Instance.ClearGlobalVariable(Owner.GlobalVariableName, Owner.GPU);
// Only values are the modulo and and integer divisor (placing into bins)
Owner.Temp.SafeCopyToHost(0, 2);
Owner.Temp.Host[0] = 2f;
Owner.Temp.Host[1] = 2f / InternalBinCount;
Owner.Temp.SafeCopyToDevice(0, 2);
break;
default:
throw new ArgumentOutOfRangeException();
}
_combineVectorsKernel = MyKernelFactory.Instance.Kernel(nGPU, @"common\CombineVectorsKernel", "CombineTwoVectorsKernelVarSize");
_combineVectorsKernel.SetupExecution(Owner.InputSize);
_hashKernel = MyKernelFactory.Instance.Kernel(nGPU, @"VSA\Mappers", "GetIndices_ImplicitSeed");
_hashKernel.SetupExecution(Owner.Output.Count);
_noHashKernel = MyKernelFactory.Instance.Kernel(nGPU, @"VSA\Mappers", "GetIndices_NoHashing");
_noHashKernel.SetupExecution(Owner.Output.Count);
m_stream = new CudaStream();
}
public override void Init(int nGPU)
{
m_forwardSamplingKernel = MyKernelFactory.Instance.Kernel(nGPU, @"NeuralNetwork\Layer\FeedForwardKernels", "GaussianForwardSamplingKernel");
m_forwardSamplingKernel.SetupExecution(Owner.Neurons);
m_resetPriorStats = MyKernelFactory.Instance.Kernel(nGPU, @"NeuralNetwork\Layer\FeedForwardKernels", "GaussianResetPriorStats");
m_resetPriorStats.SetupExecution(Owner.Input.Count);
m_minMaxField = MyKernelFactory.Instance.Kernel(nGPU, @"NeuralNetwork\Layer\FeedForwardKernels", "GaussianMinMaxField");
m_minMaxField.SetupExecution(Owner.Input.Count);
m_samplePrior = MyKernelFactory.Instance.Kernel(nGPU, @"NeuralNetwork\Layer\FeedForwardKernels", "GaussianSamplePrior");
m_samplePrior.SetupExecution(Owner.Input.Count);
m_L1TermKernel = MyKernelFactory.Instance.Kernel(nGPU, @"NeuralNetwork\Layer\RegularizationTermKernels", "L1TermKernel");
m_L1TermKernel.SetupExecution(m_L1TermKernel.MAX_THREADS);
m_L1TermKernel.DynamicSharedMemory = m_L1TermKernel.BlockDimensions.x * sizeof(float);
m_L2TermKernel = MyKernelFactory.Instance.Kernel(nGPU, @"NeuralNetwork\Layer\RegularizationTermKernels", "L2TermKernel");
m_L2TermKernel.SetupExecution(m_L2TermKernel.MAX_THREADS);
m_L2TermKernel.DynamicSharedMemory = m_L2TermKernel.BlockDimensions.x * sizeof(float);
m_regularizationKernel = MyKernelFactory.Instance.Kernel(nGPU, @"NeuralNetwork\Layer\RegularizationTermKernels", "GaussianRegularizationKernel");
m_regularizationKernel.SetupExecution(m_regularizationKernel.MAX_THREADS);
m_regularizationKernel.DynamicSharedMemory = m_regularizationKernel.BlockDimensions.x * sizeof(float);
}
// MyCudaKernel m_ker;
public MyKMeansWMObserver()
{
m_kernel_fillImActSate = MyKernelFactory.Instance.Kernel(MyKernelFactory.Instance.DevCount - 1, @"Vision\KMeansWM", "FillImByActState");
m_kernel_downInTime = MyKernelFactory.Instance.Kernel(MyKernelFactory.Instance.DevCount - 1, @"Vision\KMeansWM", "DownInTime");
//m_ker = MyKernelFactory.Instance.Kernel(MyKernelFactory.Instance.DevCount - 1, @"Vision\VisionObsFce", "FillVBOFromInputImage");
}
public override void Init(int nGPU)
{
outputWidth = Owner.Output.ColumnHint;
outputHeight = Owner.Output.Count / Owner.Output.ColumnHint;
m_kernel = MyKernelFactory.Instance.Kernel(MyKernelFactory.Instance.DevCount - 1, @"Observers\FocuserInputObserver", "RetinaObserver_UnMaskPatchFl");
m_kernel.SetupExecution(Owner.Output.Count);
}
public MyPermutationBinder(MyWorkingNode owner, int inputSize, MyMemoryBlock<float> tempBlock)
: base(owner, inputSize, tempBlock)
{
m_PermKernel = MyKernelFactory.Instance.Kernel(owner.GPU, @"Common\CombineVectorsKernel", "CombineVectorsKernel");
m_PermKernel.SetupExecution(inputSize);
m_binaryPermKernel = MyKernelFactory.Instance.Kernel(owner.GPU, @"Common\CombineVectorsKernel", "CombineTwoVectorsKernel");
m_binaryPermKernel.SetupExecution(inputSize);
}
public void InitWorldOutputs(int nGPU)
{
m_kernel = MyKernelFactory.Instance.Kernel(nGPU, @"Transforms\Transform2DKernels", "BilinearResampleKernel");
m_kernel.SetupExecution(Viewport.Width * Viewport.Height);
m_grayscaleKernel = MyKernelFactory.Instance.Kernel(MyKernelFactory.Instance.DevCount - 1, @"Observers\ColorScaleObserverSingle", "DrawGrayscaleKernel");
m_grayscaleKernel.SetupExecution(Viewport.Width * Viewport.Height);
}
public override void Init(int nGPU)
{
m_updateGateWeightsKernel = MyKernelFactory.Instance.Kernel(nGPU, @"LSTM\LSTMUpdateWeightsKernel", "LSTMUpdateGateWeightsKernel");
m_updateCellWeightsKernel = MyKernelFactory.Instance.Kernel(nGPU, @"LSTM\LSTMUpdateWeightsKernel", "LSTMUpdateCellWeightsKernel");
m_updateGateWeightsKernel.SetupExecution((Owner.Input.Count + Owner.Output.Count + Owner.CellsPerBlock + 1) * Owner.MemoryBlocks);
m_updateCellWeightsKernel.SetupExecution((Owner.Input.Count + Owner.Output.Count + 1) * Owner.CellStates.Count);
}
public override void Init(int nGPU)
{
kerX = MyKernelFactory.Instance.Kernel(nGPU, @"Vision\VisionMath", "SetMatrixVauleMinMaxX");
kerX.SetupExecution(Owner.Output.Count);
kerY = MyKernelFactory.Instance.Kernel(nGPU, @"Vision\VisionMath", "SetMatrixVauleMinMaxY");
kerY.SetupExecution(Owner.Output.Count);
}
void MyMemoryBlockObserver_TargetChanged(object sender, PropertyChangedEventArgs e)
{
Type type = Target.GetType().GenericTypeArguments[0];
m_kernel = MyKernelFactory.Instance.Kernel(@"Observers\ColorScaleObserver" + type.Name);
m_vectorKernel = MyKernelFactory.Instance.Kernel(MyKernelFactory.Instance.DevCount - 1, @"Observers\ColorScaleObserverSingle", "DrawVectorsKernel");
m_rgbKernel = MyKernelFactory.Instance.Kernel(MyKernelFactory.Instance.DevCount - 1, @"Observers\ColorScaleObserverSingle", "DrawRGBKernel");
}
public override void Initialize(Int32 nGPU)
{
// Create the kernels
m_forwardKernel = MyKernelFactory.Instance.Kernel(nGPU, @"XmlFeedForwardNet\MirrorPoolLayerKernel", "ForwardKernel");
m_backwardKernel = MyKernelFactory.Instance.Kernel(nGPU, @"XmlFeedForwardNet\MirrorPoolLayerKernel", "BackwardKernel");
base.Initialize(nGPU);
}
public override void Initialize(Int32 nGPU)
{
// Create the kernels
m_forwardKernel = MyKernelFactory.Instance.Kernel(nGPU, @"XmlFeedForwardNet\SoftmaxLayerKernel", "ForwardKernel");
m_backwardKernel = MyKernelFactory.Instance.Kernel(nGPU, @"XmlFeedForwardNet\SoftmaxLayerKernel", "BackwardKernel");
base.Initialize(nGPU);
}
public MyAbstractQLearningObserver()
{
m_kernel = MyKernelFactory.Instance.Kernel(MyKernelFactory.Instance.DevCount - 1, @"Harm\MatrixQLearningKernel", "createTexture");
m_vertexKernel = MyKernelFactory.Instance.Kernel(MyKernelFactory.Instance.DevCount - 1, @"Harm\MatrixQLearningKernel", "crate3Dplot");
m_setKernel = MyKernelFactory.Instance.Kernel(MyKernelFactory.Instance.DevCount - 1, @"Common\SetKernel");
TriggerReset();
}
public override void Init(int nGPU)
{
m_forwardKernel = MyKernelFactory.Instance.Kernel(nGPU, @"NeuralNetwork\Layer\FeedForwardKernels", "FullyConnectedForwardKernel");
m_forwardBatchKernel = MyKernelFactory.Instance.Kernel(nGPU, @"NeuralNetwork\Layer\FeedForwardKernels", "FullyConnectedForwardBatchKernel");
m_L1TermKernel = MyKernelFactory.Instance.Kernel(nGPU, @"NeuralNetwork\Layer\RegularizationTermKernels", "L1TermKernel");
m_L2TermKernel = MyKernelFactory.Instance.Kernel(nGPU, @"NeuralNetwork\Layer\RegularizationTermKernels", "L2TermKernel");
m_softmaxKernel = MyKernelFactory.Instance.Kernel(nGPU, @"NeuralNetwork\Activation\ActivationFunction", "SoftmaxKernel");
}
public override void Init(int nGPU)
{
m_setContextKernel = MyKernelFactory.Instance.Kernel(nGPU, @"\CWSetContext");
m_setContextKernel.SetupExecution(Owner.HIDDEN_UNITS * Owner.NeuronGroups);
m_setContextKernel.SetConstantVariable("D_NEURONS_PER_GROUP", Owner.NeuronsPerGroup);
m_setContextKernel.SetConstantVariable("D_NEURON_GROUPS", Owner.NeuronGroups);
m_setContextKernel.SetConstantVariable("D_HIDDEN_UNITS", Owner.HIDDEN_UNITS);
}
public override void Init(int nGPU)
{
m_cellWeightsRTRLPartialsKernel = MyKernelFactory.Instance.Kernel(nGPU, @"LSTM\LSTMPartialDerivativesKernel", "LSTMCellWeightsRTRLPartialsKernel");
m_gateWeightsRTRLPartialsKernel = MyKernelFactory.Instance.Kernel(nGPU, @"LSTM\LSTMPartialDerivativesKernel", "LSTMGateWeightsRTRLPartialsKernel");
m_cellWeightsRTRLPartialsKernel.SetupExecution(Owner.CellWeightsRTRLPartials.Count);
m_gateWeightsRTRLPartialsKernel.SetupExecution(Owner.InputGateWeightsRTRLPartials.Count);
}
public override void Init(int nGPU)
{
m_normalizePositionKernel = MyKernelFactory.Instance.Kernel(nGPU, @"VSA\SymbolicGrid", "NormalizePositionKernel");
m_interpolateSymbolsKernel = MyKernelFactory.Instance.Kernel(nGPU, @"VSA\SymbolicGrid", "InterpolateSymbolsKernel");
m_sumSymbolsKernel = MyKernelFactory.Instance.Kernel(nGPU, @"VSA\SymbolicGrid", "SumSymbolsKernel");
m_sumBasicSymbolsKernel = MyKernelFactory.Instance.Kernel(nGPU, @"VSA\SymbolicGrid", "SumBasicSymbolsKernel");
m_computeDistanceKernel = MyKernelFactory.Instance.Kernel(nGPU, @"VSA\SymbolicGrid", "ComputeDistanceKernel");
}
public override void Init(int nGPU)
{
m_kernel = MyKernelFactory.Instance.Kernel(nGPU, @"Vision\JoinPatches", "FillAdjacencyMatrix");
m_kernel.SetupExecution(Owner.MaskCount);
m_kernel_resetIm = MyKernelFactory.Instance.Kernel(nGPU, @"Vision\VisionMath", "ResetImage");
m_kernel_resetIm.SetupExecution(Owner.PatchesNum * Owner.PatchesNum);
}
public MyPermutationBinder(MyWorkingNode owner, int inputSize, MyMemoryBlock <float> tempBlock)
: base(owner, inputSize, tempBlock)
{
m_stream = new CudaStream();
m_binaryPermKernel = MyKernelFactory.Instance.Kernel(owner.GPU, @"Common\CombineVectorsKernel", "CombineTwoVectorsKernel");
m_binaryPermKernel.SetupExecution(inputSize);
}
//constructor with node parameter
public MyMatrixObserver()
{
NbDecimals = 2;
m_drawMatrixKernel = MyKernelFactory.Instance.Kernel(@"Observers\DrawMatrixKernel", true);
m_setKernel = MyKernelFactory.Instance.Kernel(@"Common\SetKernel", true);
m_drawMatrixKernel.SetConstantVariable("D_CHARACTER_WIDTH", MyDrawStringHelper.CharacterWidth);
m_drawMatrixKernel.SetConstantVariable("D_CHARACTER_HEIGHT", MyDrawStringHelper.CharacterHeight);
m_drawMatrixKernel.SetConstantVariable("D_CHARACTER_SIZE", MyDrawStringHelper.CharacterWidth * MyDrawStringHelper.CharacterHeight);
m_characters = MyMemoryManager.Instance.GetGlobalVariable<float>("CHARACTERS_TEXTURE", MyKernelFactory.Instance.DevCount - 1, MyDrawStringHelper.LoadDigits);
TargetChanged += MyMatrixObserver_TargetChanged;
}
/// <summary>
/// /Constructor with node parameter
/// </summary>
public MyTextObserver()
{
MaxLineLength = 80;
MaxRows = 16;
TextureWidth = 800;
TextureHeight = 400;
m_History = new List<string>();
m_History.Add("");
m_ClearCanvasKernel = MyKernelFactory.Instance.Kernel(@"GrowingNeuralGas\ClearCanvasKernel");
TriggerReset();
}
public MyHistogramObserver()
{
MAX_VALUE = 1.00f;
MIN_VALUE = 0.00f;
BIN_VALUE_WIDTH = 0.10f;
BINS = (int)Math.Ceiling((double)((MAX_VALUE - MIN_VALUE) / BIN_VALUE_WIDTH)) + 2;
BIN_PIXEL_HEIGHT = 250;
BIN_PIXEL_WIDTH = 32;
UPDATE_STEP = 100;
COLOR_ONE = 0xFF00CCFF;
COLOR_TWO = 0xFF00B8E6;
BACKGROUND = 0xFFFFFFFF;
OUT_OF_BOUNDS = 0xFFFF0000;
m_computeHistogram = MyKernelFactory.Instance.Kernel(@"Observers\ComputeHistogramKernel");
m_visualizeHistogram = MyKernelFactory.Instance.Kernel(@"Observers\VisualizeHistogramKernel");
}
public MyDistanceOps(MyWorkingNode caller, DistanceOperation operations, MyMemoryBlock<float> tempBlock = null)
{
m_caller = caller;
m_operations = operations;
m_temp = tempBlock;
if (operations.HasFlag(DistanceOperation.DotProd))
{
m_dotKernel = MyReductionFactory.Kernel(m_caller.GPU, MyReductionFactory.Mode.f_DotProduct_f);
}
if (operations.HasFlag(DistanceOperation.CosDist))
{
m_cosKernel = MyReductionFactory.Kernel(m_caller.GPU, MyReductionFactory.Mode.f_Cosine_f);
}
if (operations.HasFlag(DistanceOperation.EuclidDist) || operations.HasFlag(DistanceOperation.EuclidDistSquared))
{
// EuclidDist computes EuclidDistSquared first, so keep them together:
m_operations |= DistanceOperation.EuclidDist | DistanceOperation.EuclidDistSquared;
m_dotKernel = MyReductionFactory.Kernel(m_caller.GPU, MyReductionFactory.Mode.f_DotProduct_f);
}
if (operations.HasFlag(DistanceOperation.HammingDist))
{
m_reduceSumKernel = MyReductionFactory.Kernel(m_caller.GPU, MyReductionFactory.Mode.f_Sum_f);
}
if (operations.HasFlag(DistanceOperation.HammingSim))
{
m_reduceSumKernel = MyReductionFactory.Kernel(m_caller.GPU, MyReductionFactory.Mode.f_Sum_f);
}
if (operations.HasFlag(DistanceOperation.EuclidDist) || operations.HasFlag(DistanceOperation.EuclidDistSquared) ||
operations.HasFlag(DistanceOperation.HammingDist) || operations.HasFlag(DistanceOperation.HammingSim))
{
m_combineVecsKernel = MyKernelFactory.Instance.Kernel(m_caller.GPU, @"Common\CombineVectorsKernel", "CombineTwoVectorsKernel");
}
}
/// <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);
}
}
/// <summary>
/// Transforms all the vectors stored in <paramref name="vectors"/> to be pair-wise orthonormal using a modified version of the Gram-Schmidt algorithm.
/// </summary>
/// <param name="vectors">The vectors to orthonormalize.</param>
/// <param name="temp">A vector of temporal space.</param>
/// <param name="xDim">The length of each vector.</param>
/// <param name="yDim">The number of vectors.</param>
/// <param name="dotKernel">The kernel to compute a dot product.</param>
/// <param name="multKernel">The kernel to compute vector combinations.</param>
public static void OrthonormalizeVectors(MyMemoryBlock<float> vectors, MyMemoryBlock<float> temp, int xDim, int yDim, MyProductKernel<float> dotKernel, MyCudaKernel multKernel, int GPU)
{
int count = xDim * yDim;
Debug.Assert(vectors != null && temp != null, "Missing data!");
Debug.Assert(dotKernel != null && multKernel != null, "Missing a kernel!");
Debug.Assert(xDim > 0 && yDim > 0, "Negative matrix dimensions!");
Debug.Assert(vectors.Count >= count, "Too little vectors to orthonormalize!");
Debug.Assert(temp.Count >= xDim, "Too little temp space!");
multKernel.SetupExecution(xDim);
for (int i = 0; i < count; i += xDim)
{
var curr = vectors.GetDevicePtr(GPU, i);
// Normalize the current vector
{
//ZXC dotKernel.Run(temp, 0, curr, curr, xDim, /* distributed: */ 0);
dotKernel.Run(temp, curr, curr, xDim);
temp.SafeCopyToDevice(0, 1);
if (temp.Host[0] < 0.0000001f)
continue;
temp.Host[0] = (float)(1 / Math.Sqrt(temp.Host[0]));
temp.SafeCopyToDevice(0, 1);
multKernel.Run(curr, temp, curr, (int)MyJoin.MyJoinOperation.Multiplication, xDim, 1);
}
// Make all the remaining vectors orthogonal to the current one
for (int j = i + xDim; j < count; j += xDim)
{
var next = vectors.GetDevicePtr(GPU, j);
// Compute and subtract the projection onto the current vector
//ZXC dotKernel.Run(temp, xDim, curr, next, xDim, /* distributed: */ 0);
dotKernel.outOffset = xDim;
dotKernel.Run(temp, curr, next, xDim);
multKernel.Run(curr, temp, temp, (int)MyJoin.MyJoinOperation.Multiplication, xDim, 1);
multKernel.Run(next, temp, next, (int)MyJoin.MyJoinOperation.Subtraction, xDim, xDim);
}
}
}
public void Init(int nGPU)
{
m_RBMInputForwardKernel = MyKernelFactory.Instance.Kernel(nGPU, @"RBM\RBMKernels", "RBMInputForwardKernel");
m_RBMInputForwardAndStoreKernel = MyKernelFactory.Instance.Kernel(nGPU, @"RBM\RBMKernels", "RBMInputForwardAndStoreKernel");
m_RBMUpdateBiasesKernel = MyKernelFactory.Instance.Kernel(nGPU, @"RBM\RBMKernels", "RBMUpdateBiasesKernel");
m_RBMRandomActivationKernel = MyKernelFactory.Instance.Kernel(nGPU, @"RBM\RBMKernels", "RBMRandomActivationKernel");
}
/// <summary>
/// Generates a matrix with <paramref name="xDim"/> being the leading dimension in column-major storage.
/// </summary>
/// <param name="unmanagedVectors">A memory block to store the generated matrix.
/// Must be as large as <paramref name="xDim"/> x <paramref name="yDim"/>.</param>
/// <param name="unmanagedBaseVectors">A temporary block to store all the base vectors.
/// Must be as large as Max(<paramref name="xDim"/>, <paramref name="yDim"/>)^2.
/// Only neccessary when <paramref name="mode"/> is set to <see cref="VectorGenerationMode.AverageBaseVectors"/>.</param>
/// <param name="temp">The temporary storage. It should be as long as the longer of the dimensions.</param>
/// <param name="random">The random object for number generation.</param>
/// <param name="xDim">The size of the other dimension.</param>
/// <param name="yDim">The size of the leading dimension.</param>
/// <param name="mode">If true, the vectors along the longer dimension will be orthonormalized.</param>
/// <param name="axisToNormalize">The axis along which to normalize vectors after orthonormalization.</param>
public static void GenerateTransformMatrix(
MyMemoryBlock<float> unmanagedVectors, MyMemoryBlock<float> unmanagedBaseVectors, MyMemoryBlock<float> temp,
Random random, int xDim, int yDim,
MyProductKernel<float> dotKernel, MyCudaKernel multKernel, MyCudaKernel transposeKernel, int GPU,
VectorGenerationMode mode = VectorGenerationMode.Normal, AxisToNormalizeEnum axisToNormalize = AxisToNormalizeEnum.yDim)
{
Debug.Assert(random != null, "Missing random object");
Debug.Assert(unmanagedVectors != null && (mode != VectorGenerationMode.AverageBaseVectors || unmanagedBaseVectors != null) && temp != null, "Missing data!");
Debug.Assert(dotKernel != null && multKernel != null && transposeKernel != null, "Missing a kernel!");
// Mapping to rows --- Column-major storage --- rows will the leading dimension
// The larger dimension vectors will be orthogonal; the cols dimension vectors will be normalized
switch (mode)
{
case VectorGenerationMode.Normal:
if (axisToNormalize == AxisToNormalizeEnum.xDim)
{
// Generate normalized vectors with xDim as the leading dim
GenerateRandomNormalVectors(unmanagedVectors.Host, random, xDim, yDim);
unmanagedVectors.SafeCopyToDevice();
// Transpose to the correct position
transposeKernel.Run(unmanagedVectors, unmanagedVectors, xDim, yDim);
}
else
{
GenerateRandomNormalVectors(unmanagedVectors.Host, random, yDim, xDim);
unmanagedVectors.SafeCopyToDevice();
}
break;
case VectorGenerationMode.Orthonormalize:
int largerDim = Math.Max(xDim, yDim);
int smallerDim = Math.Min(xDim, yDim);
// Generate vectors with larger leading dimension
GenerateRandomNormalVectors(unmanagedVectors.Host, random, largerDim, smallerDim, normalize: false);
unmanagedVectors.SafeCopyToDevice();
// Orthonormalize along the larger dimension
OrthonormalizeVectors(unmanagedVectors, temp, largerDim, smallerDim, dotKernel, multKernel, GPU);
if (xDim > yDim)
{
// xDim is leading and is normalized
// We need to transpose to get the correct dims
transposeKernel.Run(unmanagedVectors, unmanagedVectors, xDim, yDim);
if (axisToNormalize == AxisToNormalizeEnum.yDim)
NormalizeLeadingDim(unmanagedVectors, temp, yDim, xDim, dotKernel, multKernel, GPU);
}
else
{
// yDim is leading and is normalized
// The matrix is in correct position
if (axisToNormalize == AxisToNormalizeEnum.xDim)
{
// TODO: generate the matrix with transposed dims?
// TODO: SMELLY VERSION:
transposeKernel.Run(unmanagedVectors, unmanagedVectors, yDim, xDim);
NormalizeLeadingDim(unmanagedVectors, temp, xDim, yDim, dotKernel, multKernel, GPU);
transposeKernel.Run(unmanagedVectors, unmanagedVectors, xDim, yDim);
}
}
break;
case VectorGenerationMode.AverageBaseVectors:
int longerDim = Math.Max(xDim, yDim);
int shorterDim = Math.Min(xDim, yDim);
GenerateTransformMatrix(
unmanagedBaseVectors, null, temp,
random, longerDim, longerDim,
dotKernel, multKernel, transposeKernel, GPU,
VectorGenerationMode.Orthonormalize);
if (shorterDim == longerDim)
break;
float it = 0f;
float step = longerDim / (float)shorterDim;
int beg, end = 0;
for (int i = 0; i < shorterDim; i++)
{
beg = end;
it += step;
end = (int)it;
var vect = unmanagedVectors.GetDevicePtr(GPU, i * longerDim);
for (int j = beg; j < end; j++)
{
var baseVect = unmanagedBaseVectors.GetDevicePtr(GPU, j * longerDim);
multKernel.Run(baseVect, vect, vect, (int)MyJoin.MyJoinOperation.Addition, longerDim,
longerDim);
}
}
if (xDim > yDim)
{
// xDim is leading and is not normalized
// We need to transpose to get the correct dims
if (axisToNormalize == AxisToNormalizeEnum.xDim)
{
NormalizeLeadingDim(unmanagedVectors, temp, xDim, yDim, dotKernel, multKernel, GPU);
transposeKernel.Run(unmanagedVectors, unmanagedVectors, xDim, yDim);
}
else
{
transposeKernel.Run(unmanagedVectors, unmanagedVectors, xDim, yDim);
NormalizeLeadingDim(unmanagedVectors, temp, yDim, xDim, dotKernel, multKernel, GPU);
}
}
else
{
// yDim is leading and is not normalized
// The matrix is in correct position
if (axisToNormalize == AxisToNormalizeEnum.yDim)
NormalizeLeadingDim(unmanagedVectors, temp, yDim, xDim, dotKernel, multKernel, GPU);
else
{
// TODO: SMELLY VERSION:
transposeKernel.Run(unmanagedVectors, unmanagedVectors, yDim, xDim);
NormalizeLeadingDim(unmanagedVectors, temp, xDim, yDim, dotKernel, multKernel, GPU);
transposeKernel.Run(unmanagedVectors, unmanagedVectors, xDim, yDim);
}
}
break;
}
}
void MyMemoryBlockObserver_TargetChanged(object sender, PropertyChangedEventArgs e)
{
Type type = Target.GetType().GenericTypeArguments[0];
m_kernel = MyKernelFactory.Instance.Kernel(@"Observers\ColorScaleObserver" + type.Name);
m_vectorKernel = MyKernelFactory.Instance.Kernel(MyKernelFactory.Instance.DevCount - 1, @"Observers\ColorScaleObserverSingle", "DrawVectorsKernel");
m_rgbKernel = MyKernelFactory.Instance.Kernel(MyKernelFactory.Instance.DevCount - 1, @"Observers\ColorScaleObserverSingle", "DrawRGBKernel");
if (!m_methodSelected)
{
Method = Target.Metadata.GetOrDefault(MemoryBlockMetadataKeys.RenderingMethod,
defaultValue: RenderingMethod.RedGreenScale);
}
if (!m_showCoordinatesSelected)
{
ShowCoordinates = Target.Metadata.GetOrDefault(MemoryBlockMetadataKeys.ShowCoordinates,
defaultValue: false);
}
}
public void Init(int nGPU)
{
m_RBMForwardKernel = MyKernelFactory.Instance.Kernel(nGPU, @"RBM\RBMKernels", "RBMForwardKernel");
m_RBMForwardAndStoreKernel = MyKernelFactory.Instance.Kernel(nGPU, @"RBM\RBMKernels", "RBMForwardAndStoreKernel");
m_RBMBackwardKernel = MyKernelFactory.Instance.Kernel(nGPU, @"RBM\RBMKernels", "RBMBackwardKernel");
m_RBMSamplePositiveKernel = MyKernelFactory.Instance.Kernel(nGPU, @"RBM\RBMKernels", "RBMSamplePositiveKernel");
m_RBMUpdateWeightsKernel = MyKernelFactory.Instance.Kernel(nGPU, @"RBM\RBMKernels", "RBMUpdateWeightsKernel");
m_RBMCopyFilterKernel = MyKernelFactory.Instance.Kernel(nGPU, @"RBM\RBMKernels", "RBMCopyFilterKernel");
m_RBMUpdateBiasesKernel = MyKernelFactory.Instance.Kernel(nGPU, @"RBM\RBMKernels", "RBMUpdateBiasesKernel");
m_RBMRandomActivationKernel = MyKernelFactory.Instance.Kernel(nGPU, @"RBM\RBMKernels", "RBMRandomActivationKernel");
m_RBMDropoutMaskKernel = MyKernelFactory.Instance.Kernel(nGPU, @"RBM\RBMKernels", "RBMDropoutMaskKernel");
}
void MyMemoryBlockObserver_TargetChanged(object sender, PropertyChangedEventArgs e)
{
Type type = Target.GetType().GenericTypeArguments[0];
m_kernel = MyKernelFactory.Instance.Kernel(@"Observers\ColorScaleObserver" + type.Name);
m_vectorKernel = MyKernelFactory.Instance.Kernel(MyKernelFactory.Instance.DevCount - 1, @"Observers\ColorScaleObserverSingle", "DrawVectorsKernel");
m_rgbKernel = MyKernelFactory.Instance.Kernel(MyKernelFactory.Instance.DevCount - 1, @"Observers\ColorScaleObserverSingle", "DrawRGBKernel");
}
public override void Initialize(Int32 nGPU)
{
// Create the kernels
m_setKernel = MyKernelFactory.Instance.Kernel(nGPU, @"Common\SetKernel");
m_RBMBackwardKernel = MyKernelFactory.Instance.Kernel(nGPU, @"XmlFeedForwardNet\RBMKernel", "BackwardKernel");
m_RBMObserverKernel = MyKernelFactory.Instance.Kernel(nGPU, @"XmlFeedForwardNet\RBMKernel", "ObserverKernel");
m_ForwardKernel = MyKernelFactory.Instance.Kernel(nGPU, @"XmlFeedForwardNet\RBMKernel", "NeuronCopyForwardKernel");
m_ForwardAndStoreKernel = MyKernelFactory.Instance.Kernel(nGPU, @"XmlFeedForwardNet\RBMKernel", "NeuronCopyForwardAndStoreKernel");
base.Initialize(nGPU);
}
public override void Initialize(Int32 nGPU)
{
// Create the kernels
m_setKernel = MyKernelFactory.Instance.Kernel(nGPU, @"Common\SetKernel");
m_forwardKernel = MyKernelFactory.Instance.Kernel(nGPU, @"XmlFeedForwardNet\NeuronLayerKernel", "ForwardKernel");
m_backwardKernel = MyKernelFactory.Instance.Kernel(nGPU, @"XmlFeedForwardNet\NeuronLayerKernel", "BackwardKernel");
m_weightKernel = MyKernelFactory.Instance.Kernel(nGPU, @"XmlFeedForwardNet\NeuronLayerKernel", "WeightKernel");
m_biasKernel = MyKernelFactory.Instance.Kernel(nGPU, @"XmlFeedForwardNet\NeuronLayerKernel", "BiasKernel");
m_backpropKernel = MyKernelFactory.Instance.Kernel(nGPU, @"XmlFeedForwardNet\NeuronLayerKernel", "BackpropKernel");
m_RBMForwardKernel = MyKernelFactory.Instance.Kernel(nGPU, @"XmlFeedForwardNet\RBMKernel", "ForwardKernel");
m_RBMForwardAndStoreKernel = MyKernelFactory.Instance.Kernel(nGPU, @"XmlFeedForwardNet\RBMKernel", "ForwardAndStoreKernel");
m_RBMBackwardKernel = MyKernelFactory.Instance.Kernel(nGPU, @"XmlFeedForwardNet\RBMKernel", "BackwardKernel");
m_RBMSampleKernel = MyKernelFactory.Instance.Kernel(nGPU, @"XmlFeedForwardNet\RBMKernel", "SampleKernel");
m_RBMUpdateWeightKernel = MyKernelFactory.Instance.Kernel(nGPU, @"XmlFeedForwardNet\RBMKernel", "UpdateWeightKernel");
m_RBMUpdateBiasKernel = MyKernelFactory.Instance.Kernel(nGPU, @"XmlFeedForwardNet\RBMKernel", "UpdateBiasKernel");
m_RBMObserverKernel = MyKernelFactory.Instance.Kernel(nGPU, @"XmlFeedForwardNet\RBMKernel", "ObserverKernel");
base.Initialize(nGPU);
}
public override void Initialize(Int32 nGPU)
{
m_setKernel = MyKernelFactory.Instance.Kernel(nGPU, @"Common\SetKernel");
// Use the same kernels as MyNeuronLayer
m_forwardKernel = MyKernelFactory.Instance.Kernel(nGPU, @"XmlFeedForwardNet\MirrorNeuronLayerKernel", "ForwardKernel");
m_backwardKernel = MyKernelFactory.Instance.Kernel(nGPU, @"XmlFeedForwardNet\MirrorNeuronLayerKernel", "BackwardKernel");
m_weightKernel = MyKernelFactory.Instance.Kernel(nGPU, @"XmlFeedForwardNet\MirrorNeuronLayerKernel", "WeightKernel");
m_biasKernel = MyKernelFactory.Instance.Kernel(nGPU, @"XmlFeedForwardNet\MirrorNeuronLayerKernel", "BiasKernel");
base.Initialize(nGPU);
}
void MyMemoryBlockObserver_TargetChanged(object sender, PropertyChangedEventArgs e)
{
// TODO fix this: should be handled somewhere above (during deserialization)!
if (Target == null)
{
MyLog.ERROR.WriteLine("Observer: could find the target MemoryBlock, so not opening this one.");
return;
}
Type type = Target.GetType().GenericTypeArguments[0];
m_kernel = MyKernelFactory.Instance.Kernel(@"Observers\ColorScaleObserver" + type.Name);
m_vectorKernel = MyKernelFactory.Instance.Kernel(MyKernelFactory.Instance.DevCount - 1, @"Observers\ColorScaleObserverSingle", "DrawVectorsKernel");
m_rgbKernel = MyKernelFactory.Instance.Kernel(MyKernelFactory.Instance.DevCount - 1, @"Observers\ColorScaleObserverSingle", "DrawRGBKernel");
m_tiledKernel = MyKernelFactory.Instance.Kernel(MyKernelFactory.Instance.DevCount - 1, @"Observers\ColorScaleObserverSingle", "ColorScaleObserverTiledSingle");
m_tiledRGBKernel = MyKernelFactory.Instance.Kernel(MyKernelFactory.Instance.DevCount - 1, @"Observers\ColorScaleObserverSingle", "DrawRGBTiledKernel");
if (!m_methodSelected)
{
Method = Target.Metadata.GetOrDefault(MemoryBlockMetadataKeys.RenderingMethod,
defaultValue: RenderingMethod.RedGreenScale);
}
if (!m_showCoordinatesSelected)
{
ShowCoordinates = Target.Metadata.GetOrDefault(MemoryBlockMetadataKeys.ShowCoordinates,
defaultValue: false);
}
if (ObserveTensors && type.Name != "Single")
{
MyLog.WARNING.WriteLine("Observing tensors, with anything other than Signles not supported, will use Single");
}
if (Method == RenderingMethod.Vector)
{
MyLog.WARNING.WriteLine("Observing tensors in Vector mode not supported");
}
}
public override void Initialize(Int32 nGPU)
{
// Create the kernels
m_setKernel = MyKernelFactory.Instance.Kernel(nGPU, @"Common\SetKernel");
m_forwardKernel = MyKernelFactory.Instance.Kernel(nGPU, @"XmlFeedForwardNet\MirrorConvolutionLayerKernel", "ForwardKernel");
m_forwardBiasKernel = MyKernelFactory.Instance.Kernel(nGPU, @"XmlFeedForwardNet\MirrorConvolutionLayerKernel", "ForwardBiasKernel");
m_backwardKernel = MyKernelFactory.Instance.Kernel(nGPU, @"XmlFeedForwardNet\MirrorConvolutionLayerKernel", "BackwardKernel");
m_weightBiasesKernel = MyKernelFactory.Instance.Kernel(nGPU, @"XmlFeedForwardNet\MirrorConvolutionLayerKernel", "WeightBiasKernel");
m_weightKernel = MyKernelFactory.Instance.Kernel(nGPU, @"XmlFeedForwardNet\MirrorConvolutionLayerKernel", "WeightKernel");
base.Initialize(nGPU);
}
public override void Initialize(Int32 nGPU)
{
// Create the kernels
m_setKernel = MyKernelFactory.Instance.Kernel(nGPU, @"Common\SetKernel");
m_forwardKernel = MyKernelFactory.Instance.Kernel(nGPU, @"XmlFeedForwardNet\ConvolutionLayerKernel", "ForwardKernel");
m_backwardKernel = MyKernelFactory.Instance.Kernel(nGPU, @"XmlFeedForwardNet\ConvolutionLayerKernel", "BackwardKernel");
m_weightKernel = MyKernelFactory.Instance.Kernel(nGPU, @"XmlFeedForwardNet\ConvolutionLayerKernel", "WeightKernel");
base.Initialize(nGPU);
// Routage
uint nbMaps = (uint)FeatureInputs.Length;
uint nbSourceOffset = m_extraOffset;
uint featureInfoOffset = nbSourceOffset + nbMaps;
uint sourceIndexOffset = featureInfoOffset + nbMaps;
// Write features' number of sources
uint extraOffset = 0;
for (uint featureMapId = 0; featureMapId < nbMaps; featureMapId++)
{
uint[] featureSources = FeatureInputs[featureMapId];
uint featureNbSources = (uint)featureSources.Length;
// Write features' number of sources
m_extraBlock.Host[nbSourceOffset + featureMapId] = featureNbSources;
// Write feature info offset
m_extraBlock.Host[featureInfoOffset + featureMapId] = extraOffset;
for (uint inputId = 0; inputId < featureNbSources; inputId++)
m_extraBlock.Host[sourceIndexOffset + extraOffset + inputId] = featureSources[inputId];
extraOffset += featureNbSources;
}
// Pointers
FeatureInfos = m_extraBlock.GetDevicePtr(m_network, (int)nbSourceOffset);
}
public MyXORBinder(MyWorkingNode owner, int inputSize)
: base(owner, inputSize, null)
{
m_XORKernel = MyKernelFactory.Instance.Kernel(owner.GPU, @"Common\CombineVectorsKernel", "CombineTwoVectorsKernel");
m_XORKernel.SetupExecution(inputSize);
}
public MyLabelDeltaProvider(MyAbstractFeedForwardNode network, int nGPU)
: base(network)
{
m_combineKernel = MyKernelFactory.Instance.Kernel(nGPU, @"Common\CombineVectorsKernel", "CombineTwoVectorsKernel");
m_energyKernel = MyKernelFactory.Instance.Kernel(nGPU, @"XmlFeedForwardNet\EnergyKernel");
}
// Sets up the genetic task
public override void Init(int nGPU)
{
currentGen = 0;
m_weights = 0;
// Load the relevant kernels
m_coeffGenKernel = MyKernelFactory.Instance.Kernel(nGPU, @"Genetic\CosyneGenetics", "generateCoefficients");
m_geneticKernel = MyKernelFactory.Instance.Kernel(nGPU, @"Genetic\CosyneGenetics", "grow");
m_extractKernel = MyKernelFactory.Instance.Kernel(nGPU, @"Genetic\CosyneGenetics", "extractCoeffs");
m_cosineGenKernel = MyKernelFactory.Instance.Kernel(nGPU, @"Genetic\CosyneGenetics", "createCosineMatrix");
m_implantKernel = MyKernelFactory.Instance.Kernel(nGPU, @"Genetic\CosyneGenetics", "implantCoeffs");
// Init the random generator
m_rand = new Random();
// Set up coefficient Generation
m_coeffGenKernel.SetupExecution(Owner.PopulationSize);
// Set up genetic recombination
m_geneticKernel.SetupExecution(Owner.PopulationSize);
// This finds the first nn group in the network. Possibility of getting a list of networks and evolving them all seperately?
List<MyNode> ch = Owner.Owner.Network.Children;
foreach (MyNode n in ch)
{
if (n is MyNeuralNetworkGroup)
{
nn = n as MyNeuralNetworkGroup;
MyLog.INFO.WriteLine("Evolving the layers of node: " + nn.Name);
break;
}
}
if (nn == null)
{
throw new NullReferenceException("There is no top level NeuralNetworkGroup.");
}
// Construct the layerlist which is to be read from and written to
constructLayerList(nn);
// This is how big the weight matrix will be
arr_size = (int)Math.Ceiling(Math.Sqrt(m_weights));
// Get the relevant execution plan
m_executionPlan = Owner.Owner.SimulationHandler.Simulation.ExecutionPlan[0];
#region MemoryBlocks
// Initialise the population
population = new List<MyMemoryBlock<float>>();
outputPop = new List<MyMemoryBlock<float>>();
for (int i = 0; i < Owner.PopulationSize; i++)
{
population.Add(new MyMemoryBlock<float>());
population[i].Owner = Owner;
population[i].Count = arr_size * arr_size;
population[i].AllocateMemory();
outputPop.Add(new MyMemoryBlock<float>());
outputPop[i].Owner = Owner;
outputPop[i].Count = arr_size * arr_size;
outputPop[i].AllocateMemory();
}
// Allocate space to manipulate weight matrices on the device
cudaMatrices = new MyMemoryBlock<float>();
cudaMatrices.Owner = Owner;
cudaMatrices.Count = arr_size * arr_size * Owner.PopulationSize;
cudaMatrices.AllocateDevice();
// Allocate a memory block for the Cosine matrix
multiplier = new MyMemoryBlock<float>();
multiplier.Owner = Owner;
multiplier.Count = arr_size * arr_size;
multiplier.AllocateDevice();
// Fill the cosine Matrices
m_cosineGenKernel.SetupExecution(arr_size);
m_cosineGenKernel.Run(multiplier, arr_size);
// Allocate space needed for chromosomes
chromosomePop = new MyMemoryBlock<float>();
chromosomePop.Owner = Owner;
if (DirectEvolution)
chromosomePop.Count = m_weights * Owner.PopulationSize;
else
chromosomePop.Count = CoefficientsSaved * Owner.PopulationSize;
chromosomePop.AllocateMemory();
// Allocate some space for noise to seed the cuda_rand generator
noise = new MyMemoryBlock<float>();
noise.Owner = Owner;
noise.Count = Owner.PopulationSize;
noise.AllocateMemory();
// Write some noise to the initial array
for (int i = 0; i < Owner.PopulationSize; i++)
{
noise.Host[i] = (float)m_rand.NextDouble() * 100000 + (float)m_rand.NextDouble() * 40;
}
noise.SafeCopyToDevice();
// Allocate space for the fitnesses
fitnesses = new MyMemoryBlock<float>();
fitnesses.Owner = Owner;
fitnesses.Count = Owner.PopulationSize;
fitnesses.AllocateMemory();
// Allocate some temporary storage
tempMB = new MyMemoryBlock<float>();
tempPop = new MyMemoryBlock<float>();
tempMB.Owner = Owner;
tempMB.Count = CoefficientsSaved;
tempMB.AllocateDevice();
tempPop.Owner = Owner;
tempPop.Count = arr_size * arr_size;
tempPop.AllocateDevice();
marking = new MyMemoryBlock<int>();
marking.Owner = Owner;
marking.Count = CoefficientsSaved * Owner.PopulationSize;
marking.AllocateDevice();
#endregion
// Check saved Coeffs size
if (CoefficientsSaved > m_weights)
{
MyLog.WARNING.Write("Saving more Coefficients than exist in the weight matrix. Setting to max permissable value\n");
CoefficientsSaved = m_weights;
}
if (CoefficientsSaved == m_weights)
{
MyLog.INFO.Write("Saving a coefficient for every weight. Evolving weights directly\n");
DirectEvolution = true;
}
if (DirectEvolution)
CoefficientsSaved = m_weights;
// Generate the rest of the population
if (DirectEvolution)
m_coeffGenKernel.Run(chromosomePop, CoefficientsSaved, noise, Owner.PopulationSize, WeightMagnitude);
else
m_coeffGenKernel.Run(chromosomePop, CoefficientsSaved, noise, Owner.PopulationSize, Alpha);
//Disable Backprop tasks in Network
if (nn.GetActiveBackpropTask() != null)
{
if (!nn.GetActiveBackpropTask().DisableLearning)
{
MyLog.WARNING.WriteLine("Disabling backprop learning for Neural Network");
nn.GetActiveBackpropTask().DisableLearning = true;
}
}
}
public override void Initialize(Int32 nGPU)
{
// Create the kernels
m_forwardKernel = MyKernelFactory.Instance.Kernel(nGPU, @"XmlFeedForwardNet\PoolLayerKernel", "ForwardKernel");
m_backwardKernel = MyKernelFactory.Instance.Kernel(nGPU, @"XmlFeedForwardNet\PoolLayerKernel", "BackwardKernel");
base.Initialize(nGPU);
// Forward
ChosenInputPtr = ChosenInput.GetDevicePtr(m_network, ChosenInputOffset);
}