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")
