def plot_running_times(): slow_measures = [] #slow_measures.append(time.clock()) last_time = time.clock() for size_cluster in range(2,200): alg_project3_solution.slow_closest_pair(gen_random_clusters(size_cluster)) slow_measures.append(time.clock() - last_time) last_time = time.clock() fast_measures = [] #fast_measures.append(time.clock()) last_time = time.clock() for size_cluster in range(2,200): alg_project3_solution.fast_closest_pair(gen_random_clusters(size_cluster)) fast_measures.append(time.clock() - last_time) last_time = time.clock() xlabel("number of points in cluster") ylabel("running time") #xscale('log') #yscale('log') plot(range(2,200), fast_measures, '-b', label="fast_closest_pair") plot(range(2,200), slow_measures, '-r', label="slow_closest_pair") legend(loc="upper left") show()
def plot_running_times(): slow_measures = [] #slow_measures.append(time.clock()) last_time = time.clock() for size_cluster in range(2, 200): alg_project3_solution.slow_closest_pair( gen_random_clusters(size_cluster)) slow_measures.append(time.clock() - last_time) last_time = time.clock() fast_measures = [] #fast_measures.append(time.clock()) last_time = time.clock() for size_cluster in range(2, 200): alg_project3_solution.fast_closest_pair( gen_random_clusters(size_cluster)) fast_measures.append(time.clock() - last_time) last_time = time.clock() xlabel("number of points in cluster") ylabel("running time") #xscale('log') #yscale('log') plot(range(2, 200), fast_measures, '-b', label="fast_closest_pair") plot(range(2, 200), slow_measures, '-r', label="slow_closest_pair") legend(loc="upper left") show()
def question1_plot(): xvals = [] slow_cp_yvals = [] fast_cp_yvals = [] for num_clusters in range(2,200+1): xvals.append(num_clusters) grc = gen_random_clusters(num_clusters) start = time.clock() alg_project3_solution.slow_closest_pair(grc) elapsed = (time.clock() - start) slow_cp_yvals.append(elapsed) start = time.clock() alg_project3_solution.fast_closest_pair(grc) elapsed = (time.clock() - start) fast_cp_yvals.append(elapsed) plt.plot(xvals, slow_cp_yvals, '-b', label='slow_closest_pair') plt.plot(xvals, fast_cp_yvals, '-r', label='fast_closest_pair') plt.legend(loc='upper right') plt.xlabel('number of initial clusters ') plt.ylabel('running time') plt.title('desktop Python') plt.grid(True) plt.show()
def timed_run(): slow_times = [] fast_times = [] for i in range(2, 201): cluster_list = gen_random_clusters(i) start_time = time.time() process_cluster.slow_closest_pair(cluster_list) end_time = time.time() ellapsed_time = end_time - start_time slow_times.append(ellapsed_time) start_time = time.time() process_cluster.fast_closest_pair(cluster_list) end_time = time.time() ellapsed_time = end_time - start_time fast_times.append(ellapsed_time) return slow_times, fast_times
def plot_running_time(): slow_runnint_time = [] fast_running_time = [] x_axis = range(2, 201) for num_clusters in x_axis: cluster_list = gen_random_clusters(num_clusters) cluster_list.sort(key=lambda cluster: cluster.horiz_center()) start = time.clock() student.slow_closest_pair(cluster_list) end_slow = time.clock() student.fast_closest_pair(cluster_list) end_fast = time.clock() slow_runnint_time.append(end_slow - start) fast_running_time.append(end_fast - end_slow) plt.plot(x_axis, slow_runnint_time, label="slow") plt.plot(x_axis, fast_running_time, label="fast") plt.legend() plt.ylabel('Running time') plt.xlabel('Number of clusters') plt.title("Closest Pair Algorithms Comparison") plt.show()
def plot_running_times(): """ Use gen_random_clusters and your favorite Python timing code to compute the running times of the functions slow_closest_pair and fast_closest_pair for lists of clusters of size 2 to 200. """ x_vals = [] y_1_vals = [] y_2_vals = [] for num_clusters in range(2, 200, 1): cluster_list = gen_random_clusters(num_clusters) x_vals.append(num_clusters) # measure process time (= CPU time consumed) of "slow_closest_pair" t0 = time.clock() p.slow_closest_pair(cluster_list) y_1_vals.append(time.clock() - t0) # measure process time (= CPU time consumed) of "fast_closest_pair" t0 = time.clock() p.fast_closest_pair(cluster_list) y_2_vals.append(time.clock() - t0) plt.plot(x_vals, y_1_vals, label="slow_closest_pair") plt.plot(x_vals, y_2_vals, label="fast_closest_pair") plt.xlabel("Input size (number of clusters)") plt.ylabel('CPU running time (sec.)') #tegner plt.legend() plt.title("Comparison of running times (desktop Python)") #goer det hele synligt plt.show()
def question1(filename): xs = range(2, 201) ys_fast, ys_slow = [], [] for n in xs: clusters = get_random_clusters(n) ys_fast.append(timeit(lambda: fast_closest_pair(clusters), number=1)) ys_slow.append(timeit(lambda: slow_closest_pair(clusters), number=1)) plt.plot(xs, ys_fast, '-r', label='fast_closest_pair') plt.plot(xs, ys_slow, '-b', label='slow_closest_pair') plt.title('Running time of two closest_pair functions (desktop Python)') plt.xlabel('Number of initial clusters') plt.ylabel('Running time, seconds') plt.legend(loc='upper left') plt.tight_layout() plt.savefig(filename) print('Saved plot to %s', filename)
cluster_list.append(alg_cluster.Cluster(set([]), random_x, random_y, 0, 0)) return cluster_list # run function and record running time start = 2 end = 200 slow_closest_list = [] fast_closest_list = [] for item in range(start,end): # create cluster list cluster_list = gen_random_clusters(item) # run hierarchy tStart = time.time() alg_project3_solution.slow_closest_pair(cluster_list) tStop = time.time() slow_closest_list.append(tStop - tStart) # run kmeans tStart = time.time() alg_project3_solution.fast_closest_pair(cluster_list) tStop = time.time() fast_closest_list.append(tStop - tStart) # plot def legend_example(): xvals= [i for i in range(start,end)] yvals1 = slow_closest_list yvals2 = fast_closest_list
def test_closest_pair_functions(self): cluster1 = p.c.Cluster(set(["DK"]), 1, 2, 100, 0.01) cluster2 = p.c.Cluster(set(["SW"]), 4, 6, 200, 0.05) cluster3 = p.c.Cluster(set(["Brasil"]), 4, 2, 100000000, 3) #cluster1.merge_clusters(cluster2) cluster4 = p.c.Cluster(set(["NL"]), 5, 6, 4, 4) cluster5 = p.c.Cluster(set(["NL"]), 5, 3, 100, 0.01) self.assertEqual(p.slow_closest_pair([]), (float("inf"), -1, -1)) self.assertEqual(p.slow_closest_pair([]), p.fast_closest_pair([])) self.assertEqual(p.slow_closest_pair([cluster1]), (float("inf"), -1, -1)) self.assertEqual(p.slow_closest_pair([cluster1]), p.fast_closest_pair([cluster1])) self.assertEqual(p.slow_closest_pair([cluster1, cluster1]), (0.0, 0, 1)) self.assertEqual(p.slow_closest_pair([cluster1, cluster1]), p.fast_closest_pair([cluster1, cluster1])) self.assertEqual( p.slow_closest_pair([cluster1, cluster2, cluster3, cluster4]), (1, 1, 3)) self.assertEqual( p.slow_closest_pair([cluster1, cluster2, cluster3, cluster4]), p.fast_closest_pair([cluster1, cluster2, cluster3, cluster4])) self.assertEqual(p.slow_closest_pair([cluster1, cluster2, cluster3]), (3, 0, 2)) self.assertEqual(p.slow_closest_pair([cluster1, cluster2, cluster3]), p.fast_closest_pair([cluster1, cluster2, cluster3])) self.assertEqual( p.slow_closest_pair( [cluster1, cluster2, cluster3, cluster4, cluster5]), (1, 1, 3)) self.assertEqual( p.slow_closest_pair( [cluster1, cluster2, cluster3, cluster4, cluster5]), p.fast_closest_pair( [cluster1, cluster2, cluster3, cluster4, cluster5])) cluster0 = p.c.Cluster(set(["Al"]), 1.1, 10, 0, 0) cluster1 = p.c.Cluster(set(["DK"]), 1, 2, 100, 0.01) cluster2 = p.c.Cluster(set(["SW"]), 4, 6, 200, 0.05) cluster3 = p.c.Cluster(set(["Brasil"]), 4, 2, 100000000, 3) #cluster1.merge_clusters(cluster2) cluster4 = p.c.Cluster(set(["NL"]), 5, 6, 4, 4) cluster5 = p.c.Cluster(set(["NL"]), 5, 6.1, 100, 0.01) cluster6 = p.c.Cluster(set(["hl"]), 6, 13, 0, 0) cluster7 = p.c.Cluster(set(["hl"]), 6.5, 15, 0, 0) cluster8 = p.c.Cluster(set(["hl"]), 8, 13, 0, 0) cluster_list = [ cluster0, cluster1, cluster2, cluster3, cluster4, cluster5, cluster6, cluster7, cluster8 ] self.assertEqual(p.slow_closest_pair(cluster_list), p.fast_closest_pair(cluster_list)) cluster0 = p.c.Cluster(set(["Al"]), 1.1, 10, 0, 0) cluster1 = p.c.Cluster(set(["DK"]), 1, 2, 100, 0.01) cluster2 = p.c.Cluster(set(["SW"]), 4, 6, 200, 0.05) cluster3 = p.c.Cluster(set(["Brasil"]), 4, 2, 100000000, 3) #cluster1.merge_clusters(cluster2) cluster4 = p.c.Cluster(set(["NL"]), 5, 6, 4, 4) cluster5 = p.c.Cluster(set(["NL"]), 5, 6.1, 100, 0.01) cluster6 = p.c.Cluster(set(["hl"]), 6, 13, 0, 0) cluster7 = p.c.Cluster(set(["hl"]), 6.5, 15, 0, 0) cluster8 = p.c.Cluster(set(["hl"]), 8, 13, 0, 0) cluster_list = [ cluster0, cluster1, cluster2, cluster3, cluster4, cluster5, cluster6, cluster7, cluster8 ] #print p.slow_closest_pair(cluster_list) self.assertEqual(p.slow_closest_pair(cluster_list), p.fast_closest_pair(cluster_list)) cluster0 = p.c.Cluster(set(["Al"]), 1.1, 10, 0, 0) cluster1 = p.c.Cluster(set(["DK"]), 1, 2, 100, 0.01) cluster2 = p.c.Cluster(set(["SW"]), 4, 6, 200, 0.05) cluster3 = p.c.Cluster(set(["Brasil"]), 4, 2, 100000000, 3) #cluster1.merge_clusters(cluster2) cluster4 = p.c.Cluster(set(["NL"]), 5, 50, 4, 4) cluster5 = p.c.Cluster(set(["NL"]), 5, 100, 100, 0.01) cluster6 = p.c.Cluster(set(["hl"]), 6, 13, 0, 0) cluster7 = p.c.Cluster(set(["hl"]), 6.5, 15, 0, 0) cluster8 = p.c.Cluster(set(["hl"]), 8, 13, 0, 0) cluster_list = [ cluster0, cluster1, cluster2, cluster3, cluster4, cluster5, cluster6, cluster7, cluster8 ] #print p.slow_closest_pair(cluster_list) self.assertEqual(p.slow_closest_pair(cluster_list), p.fast_closest_pair(cluster_list)) cluster0 = p.c.Cluster(set(["Al"]), 1.1, 10, 0, 0) cluster1 = p.c.Cluster(set(["DK"]), 1, 2, 100, 0.01) cluster2 = p.c.Cluster(set(["SW"]), 4, 6, 200, 0.05) cluster3 = p.c.Cluster(set(["Brasil"]), 4, 30, 100000000, 3) #cluster1.merge_clusters(cluster2) cluster4 = p.c.Cluster(set(["NL"]), 5, 50, 4, 4) cluster5 = p.c.Cluster(set(["NL"]), 5, 100, 100, 0.01) cluster6 = p.c.Cluster(set(["hl"]), 6, 13, 0, 0) cluster7 = p.c.Cluster(set(["hl"]), 30, 15, 0, 0) cluster8 = p.c.Cluster(set(["hl"]), 40, 13, 0, 0) cluster_list = [ cluster0, cluster1, cluster2, cluster3, cluster4, cluster5, cluster6, cluster7, cluster8 ] #print p.slow_closest_pair(cluster_list) self.assertEqual(p.slow_closest_pair(cluster_list), p.fast_closest_pair(cluster_list)) cluster0 = p.c.Cluster(set(["Al"]), 0, 10, 0, 0) cluster1 = p.c.Cluster(set(["DK"]), 1, 2, 100, 0.01) cluster2 = p.c.Cluster(set(["SW"]), 4, 20, 200, 0.05) cluster3 = p.c.Cluster(set(["Brasil"]), 4, 30, 100000000, 3) #cluster1.merge_clusters(cluster2) cluster4 = p.c.Cluster(set(["NL"]), 5, 50, 4, 4) cluster5 = p.c.Cluster(set(["NL"]), 5, 100, 100, 0.01) cluster6 = p.c.Cluster(set(["hl"]), 20, 13, 0, 0) cluster7 = p.c.Cluster(set(["hl"]), 30, 15, 0, 0) cluster8 = p.c.Cluster(set(["hl"]), 40, 13, 0, 0) cluster_list = [ cluster0, cluster1, cluster2, cluster3, cluster4, cluster5, cluster6, cluster7, cluster8 ] #print p.slow_closest_pair(cluster_list) self.assertEqual(p.slow_closest_pair(cluster_list), p.fast_closest_pair(cluster_list))
def run_suite(): """ Testing code for the functions written for Word Wrangler """ # create a TestSuite (and an object) suite = poc_simpletest.TestSuite() # create a set of 3 clusters cluster1 = CC.Cluster([1, 1], 0, 0, 100, 0.00001) cluster2 = CC.Cluster([2, 2, 2], 3, 4, 200, 0.00002) cluster3 = CC.Cluster([3, 3, 3, 3], 6, 8, 300, 0.00003) list_of_clusters = [cluster1, cluster2, cluster3] # testing the slow_closest_pair function with the 3 cluster list suite.run_test(student.slow_closest_pair(list_of_clusters), (5., 0, 1), "Test #1: testing slow_closest_pair on 3 clusters") # testing the fast_closest_pair function with the 3 cluster list suite.run_test(student.fast_closest_pair(list_of_clusters), (5., 0, 1), "Test #2: testing fast_closest_pair on 3 clusters") # add a fourth cluster to the list cluster4 = CC.Cluster([4, 4, 4, 4, 4], 12, 16, 400, 0.00004) list_of_clusters.append(cluster4) # testing the slow_closest_pair function with the 4 cluster list suite.run_test(student.slow_closest_pair(list_of_clusters), (5., 0, 1), "Test #3: testing slow_closest_pair on 4 clusters") # testing the fast_closest_pair function with the 4 cluster list suite.run_test(student.fast_closest_pair(list_of_clusters), (5., 0, 1), "Test #4: testing fast_closest_pair on 4 clusters") # create a set of 4 clusters cluster1 = CC.Cluster(set([]), 0, 0, 1, 0) cluster2 = CC.Cluster(set([]), 1, 0, 1, 0) cluster3 = CC.Cluster(set([]), 2, 0, 1, 0) cluster4 = CC.Cluster(set([]), 3, 0, 1, 0) list_of_clusters = [cluster1, cluster2, cluster3, cluster4] # testing closest_pair_strip on 4 clusters suite.run_test(student.closest_pair_strip(list_of_clusters, 1.5, 1.0), (1.0, 1, 2), "Test #5: testing closest_pair_strip on 4 clusters") # create a set of 4 clusters cluster1 = CC.Cluster(set([]), 1.0, 0.0, 1, 0) cluster2 = CC.Cluster(set([]), 4.0, 0.0, 1, 0) cluster3 = CC.Cluster(set([]), 5.0, 0.0, 1, 0) cluster4 = CC.Cluster(set([]), 7.0, 0.0, 1, 0) list_of_clusters = [cluster1, cluster2, cluster3, cluster4] # testing fast_closest_pair on 4 clusters suite.run_test(student.fast_closest_pair(list_of_clusters), (1.0, 1, 2), "Test #6: testing closest_pair_strip on 4 clusters") # create a set of 4 clusters cluster1 = CC.Cluster(set([]), -4.0, 0.0, 1, 0) cluster2 = CC.Cluster(set([]), 0.0, -1.0, 1, 0) cluster3 = CC.Cluster(set([]), 0.0, 1.0, 1, 0) cluster4 = CC.Cluster(set([]), 4.0, 0.0, 1, 0) list_of_clusters = [cluster1, cluster2, cluster3, cluster4] # testing closest_pair_strip on 4 clusters suite.run_test(student.closest_pair_strip(list_of_clusters, 0.0, 4.1231059999999999), (2.0, 1, 2), "Test #7: testing closest_pair_strip on 4 clusters") # create a set of 4 clusters cluster1 = CC.Cluster(set([]), -4.0, 0.0, 1, 0) cluster2 = CC.Cluster(set([]), 0.0, -1.0, 1, 0) cluster3 = CC.Cluster(set([]), 0.0, 1.0, 1, 0) cluster4 = CC.Cluster(set([]), 4.0, 0.0, 1, 0) list_of_clusters = [cluster1, cluster2, cluster3, cluster4] # testing fast_closest_pair on 4 clusters suite.run_test(student.fast_closest_pair(list_of_clusters), (2.0, 1, 2), "Test #8: testing fast_closest_pair on 4 clusters") # create a sorted list_of_clusters from a small dataset containing 8 clusters fhandle = open("unifiedCancerData_8.txt") list_of_clusters = [] for line in fhandle: tokens = line.split(',') cluster = CC.Cluster(set([tokens[0]]), float(tokens[1]), float(tokens[2]), int(tokens[3]), float(tokens[4])) list_of_clusters.append(cluster) list_of_clusters.sort(key = lambda cluster: cluster.horiz_center()) print "The following list_of_clusters was loaded:" for index in range(len(list_of_clusters)): print index, list_of_clusters[index] print # testing the slow_closest_pair function with 8 cluster list suite.run_test(student.slow_closest_pair(list_of_clusters), (2.4479655653349655, 5, 7), "Test #9: testing slow_closest_pair on 8 clusters") # testing the fast_closest_pair function with 8 cluster list suite.run_test(student.fast_closest_pair(list_of_clusters), (2.4479655653349655, 5, 7), "Test #10: testing fast_closest_pair on 8 clusters") # testing the hierarchical_clustering function with 8 clusters clustering_result = student.hierarchical_clustering(list_of_clusters, 5) for index in range(len(clustering_result)): print clustering_result[index] print # testing the kmeans_clustering function with 8 clusters clustering_result = student.kmeans_clustering(list_of_clusters, 5, 3) for index in range(len(clustering_result)): print clustering_result[index] print # create a sorted list_of_clusters from a small dataset containing 17 clusters fhandle = open("unifiedCancerData_17.txt") list_of_clusters = [] for line in fhandle: tokens = line.split(',') cluster = CC.Cluster(set([tokens[0]]), float(tokens[1]), float(tokens[2]), int(tokens[3]), float(tokens[4])) list_of_clusters.append(cluster) list_of_clusters.sort(key = lambda cluster: cluster.horiz_center()) # testing the slow_closest_pair function with 17 cluster list suite.run_test(student.slow_closest_pair(list_of_clusters), (1.9439662413427632, 9, 10), "Test #11: testing slow_closest_pair on 17 clusters") # testing the fast_closest_pair function with 17 cluster list suite.run_test(student.fast_closest_pair(list_of_clusters), (1.9439662413427632, 9, 10), "Test #12: testing fast_closest_pair on 17 clusters") # create a sorted list_of_clusters from a small dataset containing 24 clusters fhandle = open("unifiedCancerData_24.txt") list_of_clusters = [] for line in fhandle: tokens = line.split(',') cluster = CC.Cluster(set([tokens[0]]), float(tokens[1]), float(tokens[2]), int(tokens[3]), float(tokens[4])) list_of_clusters.append(cluster) list_of_clusters.sort(key = lambda cluster: cluster.horiz_center()) print "The following list_of_clusters was loaded:" for index in range(len(list_of_clusters)): print index, list_of_clusters[index] print # testing the kmeans_clustering function with 24 clusters clustering_result = student.kmeans_clustering(list_of_clusters, 10, 1) print "This output was created by kmeans_slustering:" for index in range(len(clustering_result)): print index, clustering_result[index] print # create a sorted list_of_clusters from a small dataset containing 39 clusters fhandle = open("unifiedCancerData_39.txt") list_of_clusters = [] for line in fhandle: tokens = line.split(',') cluster = CC.Cluster(set([tokens[0]]), float(tokens[1]), float(tokens[2]), int(tokens[3]), float(tokens[4])) list_of_clusters.append(cluster) list_of_clusters.sort(key = lambda cluster: cluster.horiz_center()) # testing the slow_closest_pair function with 39 cluster list suite.run_test(student.slow_closest_pair(list_of_clusters), (1.6612217536988727, 22, 24), "Test #13: testing slow_closest_pair on 39 clusters") # testing the fast_closest_pair function with 39 cluster list suite.run_test(student.fast_closest_pair(list_of_clusters), (1.6612217536988727, 22, 24), "Test #14: testing fast_closest_pair on 39 clusters") # create a sorted list_of_clusters from a small dataset containing 111 clusters fhandle = open("unifiedCancerData_111.csv") list_of_clusters = [] for line in fhandle: tokens = line.split(',') cluster = CC.Cluster(set([tokens[0]]), float(tokens[1]), float(tokens[2]), int(tokens[3]), float(tokens[4])) list_of_clusters.append(cluster) list_of_clusters.sort(key = lambda cluster: cluster.horiz_center()) print "The following list_of_clusters was loaded:" for index in range(len(list_of_clusters)): print index, list_of_clusters[index] print # testing the slow_closest_pair function with 111 cluster list suite.run_test(student.slow_closest_pair(list_of_clusters), (1.266216002018164, 79, 81), "Test #15: testing slow_closest_pair on 111 clusters") # testing the fast_closest_pair function with 111 cluster list suite.run_test(student.fast_closest_pair(list_of_clusters), (1.266216002018164, 79, 81), "Test #16: testing fast_closest_pair on 111 clusters") # testing the hierarchical_clustering function with 111 clusters clustering_result = student.hierarchical_clustering(list_of_clusters, 5) for index in range(len(clustering_result)): print clustering_result[index] print # report number of tests and failures print suite.report_results()
return _cluster_list ##################################### # Code for answering question 1 of the application # Measure the running times for the functions slow_closest_pair and fast_closest_pair num_clusters = [] running_times_slow = [] running_times_fast = [] for index in range(2,201): cluster_list = gen_random_clusters(index) num_clusters.append(index) start_time = time.time() distance = sol.slow_closest_pair(cluster_list) end_time = time.time() running_times_slow.append(end_time - start_time) start_time = time.time() distance = sol.fast_closest_pair(cluster_list) end_time = time.time() running_times_fast.append(end_time - start_time) if index % 10 == 0: print "=====> Covered clusterlist up to", index # Create plot of the result plt.plot(num_clusters, running_times_slow, '-b', label='slow_closest_pair') plt.plot(num_clusters, running_times_fast, '-r', label='fast_closest_pair') plt.legend(loc='upper left') plt.grid(True) plt.title("Plot 9: running times of slow_closest_pair and fast_closest_pair")
def test01(self): (distance,idx1,idx2) = slow_closest_pair([Cluster(set([]), 0, 0, 1, 0), Cluster(set([]), 1, 0, 1, 0), Cluster(set([]), 2, 0, 1, 0), Cluster(set([]), 3, 0, 1, 0)]) self.assertAlmostEqual(distance, 1.0)