def test_linear_search(self): test_list = utils.random_list(20, 1, 100) test_list.append(1) result = algorithm_easy.linear_search(1, test_list) self.assertEqual(True, result) result = algorithm_easy.linear_search(101, test_list) self.assertEqual(False, result)
def test_quick_sort_rec(self): collection = utils.random_list(10000, 1, 1000) result = sorting.qs(collection) is_sorted = sorting.isSorted(result) self.assertEqual(True, is_sorted) collection = utils.reversed_sorted_list(1, 10000) result = sorting.quick_sort_rec(collection) is_sorted = sorting.isSorted(result) self.assertEqual(True, is_sorted) collection = utils.sorted_list(1, 10000) result = sorting.quick_sort_rec(collection) is_sorted = sorting.isSorted(result) self.assertEqual(True, is_sorted)
def test_merge_sort(self): collection = utils.random_list(10000, 1, 1000) result = sorting.merge_sort(collection) is_sorted = sorting.isSorted(result) self.assertEqual(True, is_sorted) collection = utils.reversed_sorted_list(1, 10000) result = sorting.merge_sort(collection) is_sorted = sorting.isSorted(result) self.assertEqual(True, is_sorted) collection = utils.sorted_list(1, 10000) result = sorting.merge_sort(collection) is_sorted = sorting.isSorted(result) self.assertEqual(True, is_sorted)
def test_quick_sort_inplace(self): collection = utils.random_list(10000, 1, 1000) sorting.qs_inplace(collection) is_sorted = sorting.isSorted(collection) self.assertEqual(True, is_sorted) collection = utils.reversed_sorted_list(1, 10000) sorting.qs_inplace(collection) is_sorted = sorting.isSorted(collection) self.assertEqual(True, is_sorted) collection = utils.sorted_list(1, 10000) sorting.qs_inplace(collection) is_sorted = sorting.isSorted(collection) self.assertEqual(True, is_sorted)
def sgd(train_data, train_label, test_data, test_label, method, max_iteration=5, step=0.01): n, d = train_data.shape # beta = np.random.random((1, d)) beta = np.zeros((1, d)) beta[:, :] = 0.01 train_errors = [] test_errors = [] losses = [] iteration_count = 0 sample = 0.0 for i in range(max_iteration): index_list = random_list(n) for i in range(n): index = index_list.pop() if method == 'logistic': beta = lr_iteration(beta, train_data[index], train_label[index], lamda, gamma) elif method == 'ridge': beta = ridge_iteration(beta, train_data[index], train_label[index], lamda, gamma) if np.math.floor(max_iteration * n * sample) == iteration_count: train_error = error(beta, train_data, train_label) test_error = error(beta, test_data, test_label) loss = compute_loss(beta, train_data, train_label, method, lamda) train_errors.append(train_error) test_errors.append(test_error) losses.append(loss) print "t: {}, loss:{}, error: {}".format( sample, loss, train_error) sample += float(step) iteration_count += 1 return beta, train_errors, test_errors, losses
def __init__(self): # Tk init Tk.__init__(self) self.title("Visualized Sorting Algorithms") self.geometry("{}x{}".format(WIDTH, HEIGHT)) self.resizable(False, False) # Sorting control variables self.sorting = False data = random_list(0, 100, 200) self.sort = list(self.ALGORITHMS.values())[0](data) # First algorithm self.sort_delay = 1000/DEFAULT_SORT_SPEED # delay, in milliseconds self.tick_timer = current_milli_time() # Visualizer init self.visualizer = Visualizer(self, width=CANVAS_WIDTH, height=CANVAS_HEIGHT, bd=0, highlightthickness=0) # Control panel init self.control_panel = ControlPanel(self) # Main loop while True: self.tick()
def new_algo(self, algo, min_val, max_val, size): data = random_list(min_val, max_val, size) self.sort = self.ALGORITHMS[algo](data) self.visualizer.algo_name = algo self.pause()
# source: https://www.practicepython.org/exercise/2014/02/15/03-list-less-than-ten.html from utils import random_list, input_number a = random_list(100, 100) num = input_number( 'Give me a number and I\'ll print a list of numbers that are smaller than that given number:' ) print('Original list:') print(a) print('Numbers that are smaller than {}:'.format(num)) print([x for x in a if x < num])
def list_ends(): a = random_list(200, 10000) print('List elements') print(a) print('First and last elements') return [a[0], a[-1]]
for i in range(1000): results.append(simulate_gachapon(15)) q75, q25 = np.percentile(results, [75, 25]) iqr = q75 - q25 h = 2 * iqr * len(results)**(-1 / 3) bins = int((max(results) - min(results)) / h) """plt.hist(results, bins=bins) plt.title('Distribution of gachapon results') plt.ylabel('Number of occurrences') plt.xlabel('Number of iterations until all prizes collected') plt.savefig('problem_2_plot.png')""" length_list = [] runtimes = [] for i in range(50, 2500, 50): length_list.append(i) my_list = random_list(i) initial_time = time.time() get_element_counts(my_list) final_time = time.time() runtimes.append(final_time - initial_time) plt.scatter(length_list, runtimes) plt.title('Runtime vs. List Length') plt.ylabel('Runtime (s)') plt.xlabel('Length of list (number of elements)') plt.savefig('problem_3_plot.png')
# source: https://www.practicepython.org/exercise/2014/03/05/05-list-overlap.html from utils import random_list a = random_list(50, 50) print('List a:') print(sorted(a)) b = random_list(50, 50) print('List b:') print(sorted(b)) c = [x for x in set(a+b) if x in a and x in b] print('List c:') print(sorted(c))
def cluster_gen(directory, clusters, data, raw_data, generator_network, \ isShown = False, rafd_kid = True, alpha=1, isAdjustWeight = False, isBackward = True, isRandWeight = False, weight_bound = [0.6, 1], k = 100, ): ''' Inputs for this code block: - data - raw_data for calling 'imagePath' - path to latent vectors folder - functions: + hierarchical_partition + generate_images + face_recognition.face_locations + face_recognition.face_encodings + fakeid_quality Output for this code block: - fakeid_dist_avg - all_distances ''' cluster_index_dict = cluster_idx_dict(clusters) filenames = get_filenames(directory, isFolder=isBackward) data_frame = [] for i, vectorPath in enumerate(filenames): d = [{ 'cluster': clusters[i], 'encoding': data[i], 'latentVector': np.load(vectorPath).reshape((1, 18, -1)) }] data_frame.extend(d) df_stats = pd.DataFrame(data_frame) labelList = np.unique(clusters) information_loss = [] fakeid_dist_avg = [] all_distances = [] #for cluster_id in range(448,449): for cluster_id in tqdm_notebook(range(0, len(labelList)), desc='[Generating]: '): #for cluster_id in labelList: ################ print ids in cluster ########## if isShown: show_cluster_ids(cluster_id, cluster_index_dict, raw_data) ################################################# cluster_vectors = [ x['latentVector'] for x in data_frame if x['cluster'] == cluster_id ] if isRandWeight: weights = random_list(weight_bound[0], weight_bound[1], len(cluster_vectors)) mix = alpha * mix_function(cluster_vectors, weights) else: mix = alpha * sum(cluster_vectors) / len(cluster_vectors) df_stats.loc[df_stats.cluster == cluster_id, 'mix_latent'] = \ df_stats.loc[df_stats.cluster == cluster_id].apply(lambda row: mix, axis = 1) # print(mix.shape) img = generate_images(generator_network, mix, z=False)[0] quality_fakeid, distances, df_stats = \ dist_to_fakeid(img, cluster_id, clusters, data, df_stats) information_loss.append(quality_fakeid) fakeid_dist_avg.append(quality_fakeid / len(cluster_vectors)) all_distances.append(distances) if isShown: plt.imshow(img) plt.axis('off') plt.title("Generated image for cluster %d" % cluster_id) plt.show() df_stats['disclosure'] = df_stats['fakeid_dist'].map(lambda row: 1 if row > 0.6 else 0) disclosure_prob = len( df_stats[df_stats['disclosure'] == 0]) / len(clusters) #Disclosure Risks Assessment if isAdjustWeight: previous_alpha = alpha while disclosure_prob > 1 / k: current_alpha = previous_alpha * 0.8 df_stats = adjust_weights(df_stats, clusters, data, raw_data, cluster_index_dict, generator_network, alpha=current_alpha, beta=0.8, isShown_re_gen=isShown) disclosure_prob = len( df_stats[df_stats['disclosure'] == 0]) / len(clusters) previous_alpha = current_alpha #calculating below variables according to new df_stats information_loss = [] all_distances = [] fakeid_dist_avg = [] for label in labelList: cluster_stats = df_stats[df_stats.cluster == label] information_loss.append(cluster_stats.information_loss.unique()[0]) fakeid_dist_avg.append(cluster_stats.avg_IL.unique()[0]) all_distances.append(cluster_stats.fakeid_dist.values.tolist()) disclosure_prob = len( df_stats[df_stats['disclosure'] == 0]) / len(clusters) return fakeid_dist_avg, all_distances, information_loss, \ labelList, disclosure_prob, df_stats