Пример #1
0
        ///-------------------------------------------------------------------------------------------------
        /// <summary>   Map partition. </summary>
        ///
        /// <remarks>   Chris Rossbach ([email protected]), 8/7/2012. </remarks>
        ///
        /// <param name="partition">    The partition. </param>
        ///-------------------------------------------------------------------------------------------------

        public static void MapPartition(
            object oPartition
            )
        {
            KMeansMapPartition partition = oPartition as KMeansMapPartition;

            while (!m_bMapPhasesComplete)
            {
                partition.m_newCenters     = KMeansCalculator.CreateCenterAccumulatorList(partition.m_nCenters, partition.m_nRank);
                partition.m_newGroupCounts = KMeansCalculator.CreateGroupCountList(partition.m_nCenters, partition.m_nRank);
                partition.m_fDelta         = 0.0f;
                partition.m_evtMapWorkAvailable.WaitOne();
                if (!m_bMapPhasesComplete)
                {
                    for (int i = partition.m_nStartIndex; i < partition.m_nPartitionSize; i++)
                    {
                        Vector vec    = partition.m_vectors.ElementAt(i);
                        int    nIndex = FindNearestCenter(vec, partition.m_oldCenters);
                        if (partition.m_clusterIds.ElementAt(i) != nIndex)
                        {
                            partition.m_fDelta += 1.0f;
                        }
                        partition.m_clusterIds[i]           = nIndex;
                        partition.m_newCenters[nIndex]     += vec;
                        partition.m_newGroupCounts[nIndex] += 1;
                    }
                    partition.m_barrier.SignalAndWait();
                }
            }
        }
Пример #2
0
 SelectInitialCenters(
     IEnumerable <Vector> attributes,
     int nMinClusters,
     int nRandomSeed
     )
 {
     return(KMeansCalculator.SelectRandomCenters(attributes, nMinClusters, nRandomSeed));
 }
Пример #3
0
        ///-------------------------------------------------------------------------------------------------
        /// <summary>   Updates the centers. </summary>
        ///
        /// <remarks>   Chris Rossbach ([email protected]), 8/7/2012. </remarks>
        ///
        /// <param name="update">       The update. </param>
        ///-------------------------------------------------------------------------------------------------

        public static void UpdateCenters(
            object oUpdate
            )
        {
            KMeansUpdateCenters update = oUpdate as KMeansUpdateCenters;

            update.m_nIterations = 0;
            while (!m_bUpdatePhasesComplete)
            {
                update.m_sharedCenters     = KMeansCalculator.CreateCenterAccumulatorList(update.m_nCenters, update.m_nRank);
                update.m_sharedGroupCounts = KMeansCalculator.CreateGroupCountList(update.m_nCenters, update.m_nRank);
                update.m_fDelta            = 0.0f;
                update.m_evtMapWorkComplete.WaitOne();
                if (m_bVerbose)
                {
                    Console.WriteLine("update...");
                }
                for (int w = 0; w < update.m_workers.Count(); w++)
                {
                    KMeansMapPartition worker = update.m_workers[w];
                    update.m_fDelta += worker.m_fDelta;
                    for (int i = 0; i < update.m_nCenters; i++)
                    {
                        update.m_sharedCenters[i]     += worker.m_newCenters[i];
                        update.m_sharedGroupCounts[i] += worker.m_newGroupCounts[i];
                    }
                }
                for (int i = 0; i < update.m_nCenters; i++)
                {
                    update.m_sharedCenters[i] /= update.m_sharedGroupCounts[i];
                }
                update.m_fDelta /= update.m_nPoints;
                update.m_nIterations++;

                if (update.m_nIterations < update.m_options.m_nMaxIterations &&
                    update.m_fDelta >= update.m_options.m_fConvergenceThreshold)
                {
                    for (int w = 0; w < update.m_workers.Count(); w++)
                    {
                        update.m_workers[w].m_oldCenters = update.m_sharedCenters;
                    }
                    update.m_evtMapWorkComplete.Reset();
                    update.m_evtMapWorkAvailable.Set();
                }
                else
                {
                    m_bMapPhasesComplete    = true;
                    m_bUpdatePhasesComplete = true;
                    update.m_evtMapWorkAvailable.Set(); // shouldn't be needed, but harmless
                    return;
                }
            }
        }
Пример #4
0
        ///-------------------------------------------------------------------------------------------------
        /// <summary>   Main entry-point for this application. </summary>
        ///
        /// <remarks>   crossbac, 8/6/2013. </remarks>
        ///
        /// <param name="args"> Array of command-line argument strings. </param>
        ///-------------------------------------------------------------------------------------------------

        static void Main(string[] args)
        {
            KMeansOptions options = KMeansOptions.getOptions(args);

            if (options == null)
            {
                return;
            }

            if (options.m_bGenerateData)
            {
                GenerateRandomInput(options.m_strFileName,
                                    options.m_nGenerateElems,
                                    options.m_nGenerateDims);
                return;
            }

            Vector[] attributes =
                options.m_bBinaryInput ?
                KMeansCalculator.ReadBinaryInput(options.m_strFileName) :
                KMeansCalculator.ReadTextInput(options.m_strFileName);

            ComparePerformance(options, attributes);
        }
Пример #5
0
        ///-------------------------------------------------------------------------------------------------
        /// <summary>   Compare performance of several implementations. </summary>
        ///
        /// <remarks>   Chris Rossbach ([email protected]), 8/7/2012. </remarks>
        ///
        /// <param name="options">      Options for controlling the operation. </param>
        /// <param name="attributes">   The attributes. </param>
        ///-------------------------------------------------------------------------------------------------

        static void ComparePerformance(
            KMeansOptions options,
            IEnumerable <Vector> attributes
            )
        {
            List <String> runnableVersions            = SelectVersionsToCompare(options);
            Dictionary <String, Sample[]>    perfdata = new Dictionary <string, Sample[]>();
            Dictionary <String, Performance> stats    = new Dictionary <string, Performance>();

            foreach (String version in runnableVersions)
            {
                Sample[] vdata = new Sample[options.m_nTotalRuns];
                for (int i = 0; i < options.m_nTotalRuns; i++)
                {
                    vdata[i] = new Sample();
                }
                perfdata[version] = vdata;
            }

            IEnumerable <Vector> goldcenters =
                SelectInitialCenters(attributes,
                                     options.m_nClusters,
                                     options.m_nRandomSeed);

            for (int i = 0; i < options.m_nTotalRuns; i++)
            {
                long lReferenceImplTime            = 0;
                IEnumerable <Vector> refnewcenters = null;
                if (options.m_bCheckResult)
                {
                    Vector[]        refcenters = DuplicateCenters(goldcenters);
                    ReferenceKMeans refkmeans  = new ReferenceKMeans();
                    refnewcenters      = refkmeans.Compute(attributes, refcenters, options.m_nMaxIterations, true);
                    lReferenceImplTime = refkmeans.RuntimeMilliseconds;
                }

                foreach (String sVersion in runnableVersions)
                {
                    bool             bAvoidLazyEval  = true;
                    int              nMaxParallelism = 1;
                    int[]            rClusterIds     = null;
                    Vector[]         newcenters      = DuplicateCenters(goldcenters);
                    KMeansCalculator kmeans          = SelectImplementation(options, sVersion, out nMaxParallelism, out bAvoidLazyEval);
                    int              nIterations     = kmeans.execute(options, attributes, ref newcenters, out rClusterIds, nMaxParallelism, bAvoidLazyEval);
                    Sample           isample         = perfdata[sVersion][i];
                    isample.m_impltime = kmeans.RuntimeMilliseconds;
                    isample.m_success  = true;
                    isample.m_reftime  = 0;
                    if (options.m_bCheckResult)
                    {
                        isample.m_reftime = lReferenceImplTime;
                        isample.m_success = KMeansCalculator.CheckResult(options,
                                                                         newcenters,
                                                                         refnewcenters,
                                                                         options.m_bVerbose,
                                                                         options.m_bVerbose);
                        if (!isample.m_success)
                        {
                            Console.WriteLine("FAILED");
                            return;
                        }
                    }
                }
            }

            Console.WriteLine("SUCCEEDED");
            foreach (String v in perfdata.Keys)
            {
                Sample[]    samples = perfdata[v];
                Performance perf    = new Performance(samples);
                Console.WriteLine("{0,-15}: {1}, avg={2}", v, perf.RawRuntimes(), perf.m_impltime.ToString("f1"));
            }
        }