def k_nearest_neighbor(dataset): numOfFeature = dataset.shape[1] - 1 X = dataset[:, 0:numOfFeature] y = dataset[:, numOfFeature] X_train, X_test, y_train, y_test = train_test_split( X, y, random_state=EPISODE_NUM) for n_nei in N_NEIGHBORS: print "\nN_Neighbors: " + str(n_nei) # model = KNeighborClassifier(n_neighbors=5, weights='uniform', algorithm='auto', leaf_size=30, p=2, metric='minkowski', metric_params=None, n_jobs=1, **kwargs) model = KNeighborsClassifier(n_neighbors=n_nei) start_time = timer.start() # Set the timer fit_model(model, X_train, y_train, X_test, y_test) timer.end(start_time) # End
def draw_entities(self, screen, entity_list): timer.start("filtering offscreen entities", "drawing") entity_list = self._filter_onscreen_entities(screen, entity_list, 50) timer.end("filtering offscreen entities") paths = [] if self.settings.draw_3d(): timer.start("filtering out player", "drawing") players, non_players = self._rem_players(entity_list) random.shuffle(non_players) timer.end("filtering out player") self._draw_entities_3D(screen, non_players) for entity in players: self._decorate_sprite(entity) self._draw_entity_2D(screen, entity) else: for entity in entity_list: self._decorate_sprite(entity) self._draw_entity_2D(screen, entity)
def support_vector_machine(dataset): numOfFeature = dataset.shape[1] - 1 X = dataset[:, 0:numOfFeature] y = dataset[:, numOfFeature] X = preprocess_data(X) X_train, X_test, y_train, y_test = train_test_split( X, y, random_state=EPISODE_NUM) model = LinearSVC(multi_class='ovr') # model = SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0, # decision_function_shape='ovr', # degree=3, gamma='auto', kernel='rbf',max_iter=-1, probability=False, random_state=None, # shrinking=True,tol=0.001, verbose=False) # model = SVC(kernel='rbf', gamma=0.5, C=1.0) # C: SVM regularization parameter start_time = timer.start() # Set the timer fit_model(model, X_train, y_train, X_test, y_test) timer.end(start_time) # End score_model(model, X, y)
def update(self, dt): self.add_time(dt) timer.start("updating player", "update") if self.keystate['jump'] or self.get_player().jump_buffer > 0: self.get_player().jump_action() self.keystate['jump'] = False if bool(self.keystate['left']) ^ bool(self.keystate['right']): if self.keystate['left']: self.get_player().move_action(-1) elif self.keystate['right']: self.get_player().move_action(1) else: self.get_player().apply_friction(dt) self.ghost_recorder.update(dt) self.get_player().update(dt) if self.settings.frozen_mode(): dt = 0 timer.end("updating player") timer.start("updating everything", "update") for item in self.get_entities(): if item is not self.get_player(): item.update(dt) timer.end("updating everything") timer.start("collisions", "update") self.pusher.solve_collisions(self.get_entities()) self.rf_fixer.solve_rfs(self.get_entities()) timer.end("collisions") self.platformer_instance.current_level().bring_out_yer_dead()
######################################################## # Problem 9 - Special Pythagorean triplet # # A Pythagorean triplet is a set of three natural numbers, a < b < c, for which, # # a2 + b2 = c2 # # For example, 32 + 42 = 9 + 16 = 25 = 52. # # There exists exactly one Pythagorean triplet for which a + b + c = 1000. # Find the product abc. ######################################################## from functools import reduce import timer for n in range(1, 20): for m in range(n + 1, 21): a = m**2 - n**2 b = 2*m*n c = m**2 + n**2 if (a+b+c) == 1000: print(a*b*c) break print(timer.end()) # 31875000 # 0.000181 seconds
def _draw_entities_3D(self, screen, entity_list): timer.start("sorting entity list", "drawing") entity_list.sort(key=lambda x: -x.width()*x.height()) entity_list.sort(key=lambda x: x.get_update_priority()) timer.end("sorting entity list") timer.start("creating rectangles", "drawing") all_rects = [RECT_POOL.get().set_from_entity(x) for x in entity_list] timer.end("creating rectangles") timer.start("getting disjoint rects", "drawing") disjoint_rects = [] for i in range(0, len(all_rects)): r = all_rects[i] sub = r.subtract_all(all_rects[i+1:]) disjoint_rects.extend(sub) timer.end("getting disjoint rects") timer.start("dividing by quadrant", "drawing") c = (screen.get_width() / 2 + self.camera_pos[0], screen.get_height() / 2 + self.camera_pos[1]) quads = [[], [], [], []] for rect in disjoint_rects: my_quads = rect.quadrants(c) for q in my_quads: quads[q-1].append(rect) timer.end("dividing by quadrant") timer.start("creating adjacency dicts", "drawing") blocked_by = {x:objectpool.SET_POOL.get() for x in disjoint_rects} # blocked_by[n] = list of rects n prevents from being drawn blocking = {x:objectpool.SET_POOL.get() for x in disjoint_rects} # blocking[n] = list of rects preventing n from being drawn unblocked = objectpool.SET_POOL.get() unblocked.update(disjoint_rects) timer.end("creating adjacency dicts") timer.start("filling adjacency dicts", "drawing") for quad_list in quads: for i in range(0, len(quad_list)): for j in range(i+1, len(quad_list)): r1 = quad_list[i] r2 = quad_list[j] overlap = r2.overlapped_by_in_3D(r1, c) if overlap > 0: blocking[r2].add(r1) blocked_by[r1].add(r2) if r2 in unblocked: unblocked.remove(r2) elif overlap < 0: blocking[r1].add(r2) blocked_by[r2].add(r1) if r1 in unblocked: unblocked.remove(r1) timer.end("filling adjacency dicts") timer.start("kahn's algorithm", "drawing") # Kahn's Algorithm for sorting a graph topologically L = [] # result sorted list Adj = blocked_by # adjacency lookup rev_Adj = blocking # reverse adjacency lookup S = unblocked # nodes with no incoming edges while len(S) > 0: n = S.pop() del rev_Adj[n] L.append(n) for node in Adj[n]: rev_Adj[node].remove(n) if len(rev_Adj[node]) == 0: S.add(node) if len(rev_Adj) > 0: # oh no we have cycles!!! # todo - solve donut problem L.extend(rev_Adj.keys()) # just shove em in for now # print "Cycles in adjacency list!!!" # print "c = "+str(c) # print str(rev_Adj) L.reverse() timer.end("kahn's algorithm") timer.start("drawing rects", "drawing") self._draw_rects_3D(screen, L) RECT_POOL.put_back_all() timer.end("drawing rects")