示例#1
0
            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 = MyKernelFactory.Instance.KernelProduct <float>(Owner, nGPU, ProductMode.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 = MyKernelFactory.Instance.KernelReduction <float>(Owner, nGPU, ReductionMode.f_MinIdx_ff);

                m_kernel_UpdateXY_basedOnTheBrainsMovement = MyKernelFactory.Instance.Kernel(nGPU, @"Vision\KMeansWM", "ApplyBrainsMovement");
                m_kernel_UpdateCC_XY.SetupExecution(Owner.MaxClusters);
            }
示例#2
0
 public override void Init(int nGPU)
 {
     windowIdx = 0;
     elementselementsCountN = 0;
     columnsN           = Owner.Input.ColumnHint;
     rowsN              = Owner.Input.Count / Owner.Input.ColumnHint;
     columnsN           = Owner.Input.ColumnHint;
     elementsN          = Owner.Input.Count;
     m_actualConslMeans = new float[Owner.Output.Count];
     m_sumKernel        = MyKernelFactory.Instance.KernelReduction <float>(Owner, nGPU, ReductionMode.f_Sum_f);
 }
示例#3
0
        public override void Init(int nGPU)
        {
            m_initCentroidsKernel             = MyKernelFactory.Instance.Kernel(nGPU, @"Clustering\KMeansKernel", "InitCentroidsKernel");
            m_computeEuklidianDistancesKernel = MyKernelFactory.Instance.Kernel(nGPU, @"Clustering\KMeansKernel", "ComputeEuklidianDistancesKernel");
            m_findNearestCentroidKernel       = MyKernelFactory.Instance.Kernel(nGPU, @"Clustering\KMeansKernel", "FindNearestCentroidKernel");
            m_sumNewCentroidCoordinatesKernel = MyKernelFactory.Instance.Kernel(nGPU, @"Clustering\KMeansKernel", "SumNewCentroidCoordinatesKernel");
            m_avgCentroidCoordinatesKernel    = MyKernelFactory.Instance.Kernel(nGPU, @"Clustering\KMeansKernel", "AvgCentroidCoordinatesKernel");

            m_copyInputToVisFieldKernel = MyKernelFactory.Instance.Kernel(nGPU, @"Clustering\KMeansKernel", "CopyInputToVisFieldKernel");
            m_markCentroidsKernel       = MyKernelFactory.Instance.Kernel(nGPU, @"Clustering\KMeansKernel", "MarkCentroidsKernel");

            m_reduction = MyKernelFactory.Instance.KernelReduction <float>(Owner, nGPU, ReductionMode.f_Sum_f);

            m_d_changeFlag = new CudaDeviceVariable <int>(1);
            m_h_changeFlag = new int[1];
        }
示例#4
0
            public override void Init(int nGPU)
            {
                random = new Random();

                if (Owner.Method == ControlMethod.SimpleMean)
                {
                    m_kernel           = MyKernelFactory.Instance.Kernel(nGPU, @"Common\Statistics", "PrepareMeanStdDev");
                    m_reduction_kernel = MyKernelFactory.Instance.KernelReduction <float>(Owner, nGPU, ReductionMode.f_Sum_f);
                    m_finalize_kernel  = MyKernelFactory.Instance.Kernel(nGPU, @"Common\Statistics", "FinalizeMeanStdDev");

                    m_eye_kernel = MyKernelFactory.Instance.Kernel(nGPU, @"Retina\FindBrightSpotKernel", "ApplyEyeMovement");

                    m_imageWidth  = Owner.AttentionMap.ColumnHint;
                    m_imageHeight = Owner.AttentionMap.Count / m_imageWidth;

                    m_finalize_kernel.SetupExecution(1);
                }
                else
                {
                    m_kernel           = MyKernelFactory.Instance.Kernel(nGPU, @"Common\Statistics", "PrepareK_Means");
                    m_reduction_kernel = MyKernelFactory.Instance.KernelReduction <float>(Owner, nGPU, ReductionMode.f_Sum_f);
                    m_sumKernel        = MyKernelFactory.Instance.Kernel(nGPU, @"Common\Statistics", "SumCentroids");
                    m_finalize_kernel  = MyKernelFactory.Instance.Kernel(nGPU, @"Common\Statistics", "FinalizeK_Means");

                    m_dbiKernel    = MyKernelFactory.Instance.Kernel(nGPU, @"Common\Statistics", "EvaluateDBI");
                    m_1meansKernel = MyKernelFactory.Instance.Kernel(nGPU, @"Common\Statistics", "Prepare_1_MeansForJoin");
                    m_2meansKernel = MyKernelFactory.Instance.Kernel(nGPU, @"Common\Statistics", "Prepare_2_MeansForDivision");

                    m_eye_kernel = MyKernelFactory.Instance.Kernel(nGPU, @"Retina\FindBrightSpotKernel", "ApplyEyeMovement");
                    m_setKernel  = MyKernelFactory.Instance.Kernel(nGPU, @"Common\SetKernel");

                    m_imageWidth  = Owner.AttentionMap.ColumnHint;
                    m_imageHeight = Owner.AttentionMap.Count / m_imageWidth;
                }

                m_kernel.SetupExecution(Owner.AttentionMap.Count);
                m_1meansKernel.SetupExecution(Owner.AttentionMap.Count);
                m_2meansKernel.SetupExecution(Owner.AttentionMap.Count);

                m_eye_kernel.SetupExecution(1);

                Owner.m_centroidsCount = 5;
            }
示例#5
0
            public override void Init(int nGPU)
            {
                lastIdx = -1;

                if (Owner.UseBSCVariety)
                {
                    m_sum = MyKernelFactory.Instance.KernelReduction <float>(Owner, nGPU, ReductionMode.f_Sum_f);
                }
                else
                {
                    m_dot = MyKernelFactory.Instance.KernelProduct <float>(Owner, nGPU, ProductMode.f_DotProduct_f);
                }

                MyMemoryManager.Instance.ClearGlobalVariable(Owner.GlobalVariableName, nGPU);

                if (Owner.UseBSCVariety)
                {
                    m_similarityKernel = MyKernelFactory.Instance.Kernel(Owner.GPU, @"Common\CombineVectorsKernel", "CombineTwoVectorsKernel");
                    m_similarityKernel.SetupExecution(Owner.SymbolSize);
                }
            }
示例#6
0
        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 = MyKernelFactory.Instance.KernelProduct <float>(caller, caller.GPU, ProductMode.f_DotProduct_f);
            }

            if (operations.HasFlag(DistanceOperation.CosDist))
            {
                m_cosKernel = MyKernelFactory.Instance.KernelProduct <float>(caller, caller.GPU, ProductMode.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   = MyKernelFactory.Instance.KernelProduct <float>(caller, caller.GPU, ProductMode.f_DotProduct_f);
            }

            if (operations.HasFlag(DistanceOperation.HammingDist))
            {
                m_reduceSumKernel = MyKernelFactory.Instance.KernelReduction <float>(caller, caller.GPU, ReductionMode.f_Sum_f);
            }
            if (operations.HasFlag(DistanceOperation.HammingSim))
            {
                m_reduceSumKernel = MyKernelFactory.Instance.KernelReduction <float>(caller, caller.GPU, ReductionMode.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");
            }
        }
示例#7
0
        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 = MyKernelFactory.Instance.KernelProduct<float>(caller, caller.GPU, ProductMode.f_DotProduct_f);
            }

            if (operations.HasFlag(DistanceOperation.CosDist))
            {
                m_cosKernel = MyKernelFactory.Instance.KernelProduct<float>(caller, caller.GPU, ProductMode.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 = MyKernelFactory.Instance.KernelProduct<float>(caller, caller.GPU, ProductMode.f_DotProduct_f);
            }

            if (operations.HasFlag(DistanceOperation.HammingDist))
            {
                m_reduceSumKernel = MyKernelFactory.Instance.KernelReduction<float>(caller, caller.GPU, ReductionMode.f_Sum_f);
            }
            if (operations.HasFlag(DistanceOperation.HammingSim))
            {
                m_reduceSumKernel = MyKernelFactory.Instance.KernelReduction<float>(caller, caller.GPU, ReductionMode.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");
            }
        }