def learn(self):
# for each epoch
for _ in range(self.epochs):
# for each training frame
for training_frame_index in self.training_frames_queue:
matching_unit = []
for neuron_index, neuron in enumerate(self.neurons):
# count distanse between each training frame and neuron
distance = vector_distance(
self.image.get_normal_frame(training_frame_index),
normalize_vector(neuron.weights),
)
matching_unit.append(
[training_frame_index, neuron_index, distance,]
)
# find frame and neuron with closes distance
bmu = min(matching_unit, key=lambda x: x[2])
# recalculate weights for neuron
new_weights = normalize_vector(
self.neurons[bmu[1]].weights
) + self.learning_step * (
self.image.get_normal_frame(bmu[0])
- normalize_vector(self.neurons[bmu[1]].weights)
)
# update weights
self.neurons[bmu[1]].weights = new_weights
def draw_polyline_nice_corners(cr,
points,
arrow_degrees,
arrow_len,
arrow_start=False,
arrow_end=False):
ex, ey = points[-1]
prev = points[0]
if arrow_start:
cr.move_to(prev[0], prev[1])
draw_arrow(cr, utils.make_vector(points[1], points[0]), arrow_degrees,
arrow_len)
cr.move_to(prev[0], prev[1])
for i in xrange(1, len(points) - 1):
a = utils.make_vector(points[i - 1], points[i])
b = utils.make_vector(points[i], points[i + 1])
la = utils.vector_len(a)
lb = utils.vector_len(b)
if la < 0.01 or lb < 0.01:
continue
v = utils.vector_mul_scalar(utils.normalize_vector(a), min(la, 20.0))
w = utils.vector_mul_scalar(utils.normalize_vector(b), min(lb, 20.0))
t = utils.vector_diff(points[i], v)
cr.line_to(t[0], t[1])
cr.rel_curve_to(v[0], v[1], v[0], v[1], v[0] + w[0], v[1] + w[1])
cr.line_to(ex, ey)
cr.stroke()
if arrow_end:
cr.move_to(ex, ey)
draw_arrow(cr, utils.make_vector(points[-2], points[-1]),
arrow_degrees, arrow_len)
def draw_polyline_nice_corners(cr, points, arrow_degrees, arrow_len, arrow_start = False, arrow_end = False):
ex, ey = points[-1]
prev = points[0]
if arrow_start:
cr.move_to(prev[0],prev[1])
draw_arrow(cr, utils.make_vector(points[1], points[0]), arrow_degrees, arrow_len)
cr.move_to(prev[0],prev[1])
for i in xrange(1, len(points) - 1):
a = utils.make_vector(points[i-1], points[i])
b = utils.make_vector(points[i], points[i + 1])
la = utils.vector_len(a)
lb = utils.vector_len(b)
if la < 0.01 or lb < 0.01:
continue
v = utils.vector_mul_scalar(utils.normalize_vector(a), min(la, 20.0))
w = utils.vector_mul_scalar(utils.normalize_vector(b), min(lb, 20.0))
t = utils.vector_diff(points[i], v)
cr.line_to(t[0], t[1])
cr.rel_curve_to(v[0], v[1], v[0], v[1], v[0] + w[0], v[1] + w[1])
cr.line_to(ex,ey)
cr.stroke()
if arrow_end:
cr.move_to(ex, ey)
draw_arrow(cr, utils.make_vector(points[-2], points[-1]), arrow_degrees, arrow_len)
def getVisualWords(self, codebook, descriptor, size_descriptors, code_size): visual_words=np.zeros((len(descriptor),code_size*5),dtype=np.float32) for i in xrange(len(descriptor)): words=codebook.predict(descriptor[i].reshape(-1, size_descriptors)) visual_words[i,:code_size] = np.bincount(words,minlength=code_size) visual_words[i,:code_size] = normalize_vector(visual_words[i,:code_size]) # normalize for j in range(4): words=codebook.predict(descriptor[i][j]) visual_words[i,code_size*(j+1):code_size*(j+2)] = np.bincount(words,minlength=code_size) visual_words[i,code_size*(j+1):code_size*(j+2)] = normalize_vector(visual_words[i,code_size*(j+1):code_size*(j+2)]) # normalize return visual_words
def generate(self, space_game, ship):
# def create_enemy_star(self):
self.enemies = []
self.x = randint(100, CANVAS_WIDTH - 100)
self.y = randint(100, CANVAS_HEIGHT - 100)
while vector_len(self.x - self.ship.x, self.y - self.ship.y) < 200:
self.x = randint(100, CANVAS_WIDTH - 100)
self.y = randint(100, CANVAS_HEIGHT - 100)
for d in range(18):
self.dx, self.dy = direction_to_dxdy(d * 20)
self.enemy = Enemy(self, self.x, self.y,
self.dx * ENEMY_BASE_SPEED,
self.dy * ENEMY_BASE_SPEED)
self.enemies.append(self.enemy)
return self.enemies
# def create_enemy_from_edges(self):
self.x, self.y = random_edge_position()
self.vx, self.vy = normalize_vector(self.ship.x - self.x,
self.ship.y - self.y)
self.vx *= ENEMY_BASE_SPEED
self.vy *= ENEMY_BASE_SPEED
self.enemy = Enemy(self, self.x, self.y, self.vx, self.vy)
return [self.enemy]
def move_to(self, dest, speed=None):
if speed is None:
speed = self.max_speed
speed = min(speed, self.max_speed)
mv = vector_to(self.pos, dest)
mv = normalize_vector(mv, speed)
return self.move(mv)
def move(self, mv):
if not self.valid_move(mv):
return False
mv = normalize_vector(mv, self.max_speed)
self.prev_move = mv
self.pos[0] += mv[0]
self.pos[1] += mv[1]
return True
def generate(self, space_game, ship):
x, y = random_edge_position()
vx, vy = normalize_vector(ship.x - x, ship.y - y)
vx *= ENEMY_BASE_SPEED
vy *= ENEMY_BASE_SPEED
enemy = Enemy(space_game, x, y, vx, vy)
return [enemy]
def create_enemy_from_edges(self):
x, y = random_edge_position()
vx, vy = normalize_vector(self.ship.x - x, self.ship.y - y)
vx *= ENEMY_BASE_SPEED
vy *= ENEMY_BASE_SPEED
enemy = Enemy(self, x, y, vx, vy)
return [enemy]
def sentence_as_feature(sentence, index_dic): def get_index(dic, word): if not word in dic: dic[word] = len(dic) return dic[word] feature_vec = defaultdict(int) for word in sentence: feature_vec[get_index(index_dic, word)] += 1 return dict(normalize_vector(feature_vec))
def generate(self, space_game, ship):
# TODO: extracted from method create_enemy_from_edge
x, y = random_edge_position()
vx, vy = normalize_vector(ship.x - x, ship.y - y)
vx *= ENEMY_BASE_SPEED
vy *= ENEMY_BASE_SPEED
enemy = Enemy(self, x, y, vx, vy)
return [enemy]
def generate(self, space_game, ship):
self.x, self.y = random_edge_position()
self.vx, self.vy = normalize_vector(self.ship.x - self.x,
self.ship.y - self.y)
self.vx *= ENEMY_BASE_SPEED
self.vy *= ENEMY_BASE_SPEED
self.enemy = Enemy(self, self.x, self.y, self.vx, self.vy)
return [self.enemy]
def get_body_distance(self, location, walls, body, grid_size,
move_direction):
dist_left = -1
dist_right = -1
dist_up = -1
dist_down = -1
for y in range(location[1] - grid_size, walls[1][0], -grid_size):
if [location[0], y] in body:
dist_up = (location[1] - y) / grid_size
break
for x in range(location[0] + grid_size, walls[0][1], grid_size):
if [x, location[1]] in body:
dist_right = (x - location[0]) / grid_size
break
for y in range(location[1] + grid_size, walls[1][1], grid_size):
if [location[0], y] in body:
dist_down = (y - location[1]) / grid_size
break
for x in range(location[0] - grid_size, walls[0][0], -grid_size):
if [x, location[1]] in body:
dist_left = (location[0] - x) / grid_size
break
dist_up = dist_up if dist_up == 0 else -1
dist_right = dist_right if dist_right == 0 else -1
dist_down = dist_down if dist_down == 0 else -1
dist_left = dist_left if dist_left == 0 else -1
look_direction = []
if (move_direction == 'u'):
look_direction = [dist_up, dist_left, dist_right]
if (move_direction == 'r'):
look_direction = [dist_right, dist_up, dist_down]
if (move_direction == 'd'):
look_direction = [dist_down, dist_right, dist_left]
if (move_direction == 'l'):
look_direction = [dist_left, dist_down, dist_up]
if look_direction[0] >= 0:
self.sight[0] = look_direction[0]
if look_direction[1] >= 0:
self.sight[2] = look_direction[1]
if look_direction[2] >= 0:
self.sight[4] = look_direction[2]
self.sight = utils.normalize_vector(self.sight)
def auto_attacker2(self, team, role, opp, ball, side=0, tic=0):
"""Strategy for an attacker working with DQN."""
angle_to_ball = angle_to(team[role].pos, ball.pos)
angle_to_goal = angle_to(team[role].pos, goals[not side])
angle_ball_to_goal = angle_to(team[role].pos, goals[not side])
dist_ball_to_goal = dist(ball.pos, goals[not side])
dist_to_goal = dist(team[role].pos, goals[not side])
dist_to_ball = dist(team[role].pos, ball.pos)
print "angle_to_ball", angle_to_ball
print "angle_to_goal", angle_to_goal
print "angle_ball_to_goal", angle_ball_to_goal
print "dist_ball_to_goal", dist_ball_to_goal
print "dist_to_goal", dist_to_goal
print "dist_to_ball", dist_to_ball
# Decision tree
target = None
if abs(angle_diff(angle_to_goal, angle_ball_to_goal)) < 1 and \
dist_ball_to_goal < dist_to_goal:
# run to score!
target = ball.pos
print "GO KICK"
else:
if team[role].pos[0] < ball.pos[0]:
# go behind ball, aligned with goal
vec = vector_to(goals[not side], ball.pos)
vec = normalize_vector(vec, 0.7)
target = tonp(ball.pos) + vec
print "PREPARE TO KICK"
else:
# go behind goal
target = list(ball.pos)
if angle_to_ball > 0:
target[1] -= 0.5
else:
target[0] += 0.5
target[0] += 0.1
print "GO BEHIND BALL"
print team[role].pos, ball.pos, target
team[role].move_to(target)
def concatenate_embeddings_generate(embeddings_path,
out_path,
vocab=None,
batch_size=1024,
k=10):
printTrace("Reading vocab...")
# [[vocab_emb1], [vocab_emb_2], ...]
vocab_embeddings = [vocab_from_path(x) for x in embeddings_path]
word_id = set()
if vocab is None:
word_id = list(set.union(*vocab_embeddings))
else:
word_id = set(vocab)
union = set.union(*vocab_embeddings)
[
print("Word " + str(w) + " not found in any embedding")
for w in word_id - union
]
word_id = list(word_id.intersection(union))
print("The final embedding will have " + str(len(word_id)) + " words.")
for i_voc, voc in enumerate(vocab_embeddings):
print("Embedding " + str(i_voc) + " has " + str(len(voc)) + " words.")
print("We will generate " + str(len(set(word_id) - voc)) +
" words for the embedding " + str(i_voc))
print()
printTrace("Building matrix for word generation...")
generation_vocab_matrix = [[x for x in range(len(embeddings_path))]
for x in range(len(embeddings_path))]
nn_vocab = [defaultdict() for x in range(len(embeddings_path))]
for x, emb1 in enumerate(vocab_embeddings):
vocab_to_generate = set(word_id) - emb1
for y, emb2 in enumerate(vocab_embeddings):
generation_vocab_matrix[y][x] = list(
vocab_to_generate.intersection(emb2))
vocab_to_generate = vocab_to_generate - emb2
printTrace("===> Calculating nearest neighbors <===")
for i_emb_path, emb_path in enumerate(embeddings_path):
printTrace("Loading file: " + str(emb_path))
emb = load_embedding(
emb_path,
vocabulary=None,
length_normalize=True,
normalize_dimensionwise=False,
delete_duplicates=True,
)
for i_g, g in enumerate(generation_vocab_matrix[i_emb_path]):
if len(g) > 0:
# print('G: ' + str(g))
m = emb.words_to_matrix(
g) # generation_vocab_matrix[i_emb_path][i_g])
# print(len(m))
# print(generation_vocab_matrix[x][gi])
interset_vocab = list(
set.intersection(vocab_embeddings[i_emb_path],
vocab_embeddings[i_g]))
M = emb.words_to_matrix(interset_vocab)
total_words = len(m)
for i_batch, mb in enumerate(batch(m, batch_size)):
string = (
"<" + str(datetime.datetime.now()) + "> " +
"Using Embedding " + str(i_emb_path) +
" to generate vocab for Embedding " + str(i_g) +
": " +
str(int(100 *
(i_batch * batch_size) / total_words)) + "%")
print(string, end="\r")
result = cosine_knn(mb, M, k)
for i_result, indexes in enumerate(result):
nn_vocab[i_g][g[i_result + (batch_size * i_batch)]] = [
interset_vocab[i] for i in indexes
]
print()
printTrace("===> Calculating meta embedding <===")
total_words = len(word_id)
first_emb = True
if not os.path.exists("tmp"):
os.makedirs("tmp")
total_dims = 0
for x, emb_path in enumerate(embeddings_path):
matrix = []
printTrace("Loading file: " + str(emb_path))
emb = load_embedding(
emb_path,
vocabulary=None,
length_normalize=True,
normalize_dimensionwise=False,
delete_duplicates=True,
)
total_dims += emb.dims
string = "<" + str(
datetime.datetime.now()) + "> " + "Embedding " + str(x)
print(string, end="\r")
actual_matrix = []
for wi, w in enumerate(word_id):
m = np.zeros([emb.dims], dtype=float)
try:
m = emb.word_to_vector(w)
except KeyError as r:
try:
lw = nn_vocab[x][w]
v = np.zeros([emb.dims], dtype=float)
for word in lw:
v += emb.word_to_vector(word)
except KeyError as r:
raise ValueError(
"Something went wrong in the word generation process")
m = normalize_vector(v / k)
matrix.append(m)
if wi % 1000 == 0:
string = ("<" + str(datetime.datetime.now()) + "> " +
"Calculating meta embeddind for embedding " +
str(x) + ": " + str(int(100 * wi / total_words)) +
"%")
print(string, end="\r")
print()
with open("tmp/" + str(x), "w") as file:
for wi, w in enumerate(word_id):
if first_emb:
print(w + " " + " ".join(["%.6g" % x for x in matrix[wi]]),
file=file)
else:
print(" ".join(["%.6g" % x for x in matrix[wi]]),
file=file)
if wi % 1000 == 0:
string = ("<" + str(datetime.datetime.now()) + "> " +
"Saving embedding " + str(x) + " to file : " +
str(int(100 * wi / total_words)) + "%")
print(string, end="\r")
print()
first_emb = False
printTrace("Concatenation...")
excec_com = "paste -d ' ' "
for x in range(len(embeddings_path)):
excec_com = excec_com + "tmp/" + str(x) + " "
excec_com = excec_com + "> " + str(out_path)
print(excec_com)
os.system(excec_com)
excec_com = ("sed -i '1s/^/" + str(len(word_id)) + " " + str(total_dims) +
"\\n/' " + str(out_path))
print(excec_com)
os.system(excec_com)
try:
os.system("rm -rf tmp")
except:
print("Could not delete the tmp folder, do it manually")
printTrace("Done. Meta embedding saved in " + str(out_path))
def fget(self):
return normalize_vector(self._discrete_distribution.posterior)
def normalized_weights(self) -> List[float]:
return normalize_vector(self.weights)
def __normalize_framed_image(self):
self.normalized_framed_image = np.array(
[normalize_vector(frame) for frame in self.framed_image]
)
