def getInitCameraUp(self):
#va = self.getFocalPoint() - self.getInitPosition()
va = self.getInitPosition() - self.getFocalPoint() # w
vb = self.getZAxis() # up
w = Utils.normalize(va) # w
u = Utils.normalize(numpy.cross(vb, w))
v = numpy.cross(w, u)
return v
def visualize(self):
# Using PCA (Principal Components Analysis) to recognize faces
# Face recognizer just in openCV version 2.4x, not in version 3.0 (alpha + beta)
# cv2.createEigenFaceRecognizer()
[X, y] = read_images(self._facePath)
# get k principal components
[D, W, mu] = pca(as_row_matrix(X), y)
# to check how many principal components (eigenfaces) - which has the same dimension with observed vector
# print(len(W[1, :]))
# print(len(W[:, 1]))
# Visualize eigenfaces
E = []
# take at most 16 people
for i in xrange(min(len(X), 16)):
e = W[:, i].reshape(X[0].shape)
# normalize value of eigenvectors in [0, 255] to display on image
E.append(normalize(e, 0, 255))
# display k principal components (k eigenvectors)
# eigenfaces encode facial features + illumination of image
subplot(title="Eigencefaces AT&T",
images=E,
rows=4,
cols=4,
sptitle="Eigenface",
colormap=cm.gray,
filename="pca_eigenface.png")
# Reconstructor image from eigenfaces
# array of vector number [10, 30, 50 ..., min(len(X), 320)]
steps = [i for i in xrange(10, min(len(X), 320), 20)]
E = []
# take at most 16 eigenvectors of first person
for i in xrange(min(len(steps), 16)):
num_eigenvectors = steps[i]
# project each vector x1, x2, ... xn to num_eigenvectors
P = project(W[:, 0:num_eigenvectors], X[0].reshape(1, -1), mu)
# reconstruct image from num_eigenvectors
R = reconstruct(W[:, 0:num_eigenvectors], P, mu)
R = R.reshape(X[0].shape)
E.append(normalize(R, 0, 255))
# reconstruct image from k (10, 30, ...) eigenvector
subplot(title="Reconstruction AT&T",
images=E,
rows=4,
cols=4,
sptitle="EigenVectors",
sptitles=steps,
colormap=cm.gray,
filename="pca_reconstruction.png")
def control(self, dt):
self.crosshair_sprite.rotate(dt*45)
if self.aim_angle != self.last_aim_angle:
self.barrel_sprite.rotate(
self.aim_angle - self.barrel_sprite.rotation + 90)
self.changed_pos = True
self.last_aim_angle = self.aim_angle
if self.x != self.last_x:
self.changed_pos = True
self.new_y = -1
for y in range(max(self.y - 5, 0), MAP_H):
if not self.map.collision_map[y-1][int(self.x)] and \
self.map.collision_map[y][int(self.x)]:
self.new_y = y
break
if self.new_y == -1 and self.final_x == -1:
self.x = self.last_x
return
self.y = self.new_y
p1 = (self.x - 4, self.map.get_height(normalize(int(self.x) - 4),
normalize(int(self.y - 5))))
p2 = (self.x + 4, self.map.get_height(normalize(int(self.x) + 4),
normalize(int(self.y - 5))))
angle = degrees(atan2(p2[1] - p1[1], p2[0] - p1[0]))
self.sprite.rotate(angle - self.sprite.rotation)
else:
self.new_y = -1
for y in range(max(self.y - 5, 0), MAP_H):
if not self.map.collision_map[y-1][int(self.x)] and \
self.map.collision_map[y][int(self.x)]:
self.new_y = y
break
if self.new_y != self.y:
self.y = self.new_y
p1 = (self.x - 4, self.map.get_height(int(self.x) - 4,
int(self.y - 5)))
p2 = (self.x + 4, self.map.get_height(int(self.x) + 4,
int(self.y - 5)))
angle = degrees(atan2(p2[1] - p1[1], p2[0] - p1[0]))
self.sprite.rotate(angle - self.sprite.rotation)
self.last_x = self.x
def attack_pgd(encoder, classifier, X, y, epsilon=params.epsilon, alpha=params.pgd_alpha,
attack_iters=params.attack_iters, restarts=params.restarts,
norm=params.norm, early_stop=params.early_stop, clamps=params.clamps):
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
epsilon /= 255.0
alpha /= 255.0
max_loss = torch.zeros(y.shape[0]).to(device)
max_delta = torch.zeros_like(X).to(device)
for _ in range(restarts):
delta = torch.zeros_like(X).to(device)
if norm == "l_inf":
delta.uniform_(-epsilon, epsilon)
elif norm == "l_2":
delta.uniform_(-0.5,0.5).renorm(p=2, dim=1, maxnorm=epsilon)
else:
raise ValueError
delta = clamp(delta, clamps[0]-X, clamps[1]-X)
delta.requires_grad = True
for _ in range(attack_iters):
feats = encoder((normalize(X + delta)))
output = classifier(feats)
if early_stop:
index = torch.where(output.max(1)[1] == y)[0]
else:
index = slice(None,None,None)
if not isinstance(index, slice) and len(index) == 0:
break
loss = F.cross_entropy(output, y)
loss.backward()
grad = delta.grad.detach()
d = delta[index, :, :, :]
g = grad[index, :, :, :]
x = X[index, :, :, :]
if norm == "l_inf":
d = torch.clamp(d + alpha * torch.sign(g), min=-epsilon, max=epsilon)
elif norm == "l_2":
g_norm = torch.norm(g.view(g.shape[0],-1),dim=1).view(-1,1,1,1)
scaled_g = g/(g_norm + 1e-10)
d = (d + scaled_g*alpha).view(d.size(0),-1).renorm(p=2,dim=0,maxnorm=epsilon).view_as(d)
d = clamp(d, clamps[0] - x, clamps[1] - x)
delta.data[index, :, :, :] = d
delta.grad.zero_()
all_loss = F.cross_entropy(classifier(encoder(normalize(X+delta))), y, reduction='none')
max_delta[all_loss >= max_loss] = delta.detach()[all_loss >= max_loss]
max_loss = torch.max(max_loss, all_loss)
return max_delta
def extract_features(parsed_file, unified_file, cube_file, cube_context_file, freq_data_file, stop_word_file, freq_pattern_file, base_dir, total_docs, filtered_cell_str):
print filtered_cell_str
freq_patterns = load_freq_patterns(freq_pattern_file)
freq_data = load_freq(freq_data_file)
cubes = load_cube(cube_file)
contexts = load_context(cube_context_file)
unified_list = load_unified_list(unified_file)
print contexts.keys()
#cubes['all'] = [i for i in range(total_docs)]
all_docs = [i for i in range(total_docs)]
total_cnt = agg_phrase_cnt(freq_data, all_docs)
print sum(total_cnt.values())
#extract the features of phrases in each cube
phrase_feature_all = {}
idx = 0
for att in cubes:
if att != filtered_cell_str: #'Topic|Sports;Location|Illinois;':
continue
print "start processing " + att
selected_doc = cubes[att]
selected_context = contexts[att]
#print selected_context
feature_extractor = FeatureExtractor(parsed_file, selected_doc, selected_context, freq_data, stop_word_file, freq_patterns, total_cnt, unified_list)
phrase_features = feature_extractor.extract_features()
for phrase in phrase_features:
norm_phrase = normalize(phrase)
phrase_features[phrase].append(unified_list[norm_phrase])
cell_phrase = "{0}{1}".format(att.replace('|', '_').replace(';', '_').replace(' ', '_').lower(), norm_phrase)
phrase_feature_all[cell_phrase] = phrase_features[phrase]
file_name = "{0}/{1}.fea".format(base_dir, "cells.fea")
save_features(file_name, phrase_feature_all)
def randDirection(self):
x = random.random()
y = random.random()
z = random.random()
v = numpy.array([x, y, z], dtype=numpy.float32)
v = Utils.normalize(v)
return v
def get_item_train(self, filename):
images, kspaces = from_train_file_to_image_and_kspace(filename)
mask = gen_mask(kspaces[0], accel_factor=self.af)
fourier_mask = np.repeat(mask.astype(np.float), kspaces[0].shape[0], axis=0)
img_batch = list()
zero_img_batch = list()
if self.norm and self.mode == 'validation':
means = list()
stddevs = list()
for kspace, image in zip(kspaces, images):
zero_filled_rec = zero_filled(kspace * fourier_mask)
if self.norm:
zero_filled_rec, mean, std = normalize_instance(zero_filled_rec, eps=1e-11)
image = normalize(image, mean, std, eps=1e-11)
if self.mode == 'validation':
means.append(mean)
stddevs.append(std)
zero_filled_rec = zero_filled_rec[:, :, None]
zero_img_batch.append(zero_filled_rec)
image = image[..., None]
img_batch.append(image)
zero_img_batch = np.array(zero_img_batch)
img_batch = np.array(img_batch)
if self.norm and self.mode == 'validation':
return zero_img_batch, img_batch, means, stddevs
else:
return (zero_img_batch, img_batch)
def isOccluded(self, pt1, pt2):
vd = pt2 - pt1
tMax = Utils.norm2(vd)
vd = Utils.normalize(vd)
isIntersect, t = Utils.rayIntersectObjects(pt1, vd, self.facesList, self.pointsList, 0, tMax)
return isIntersect
def get_item_train(self, filename):
images, kspaces = from_train_file_to_image_and_kspace(filename)
mask = gen_mask(kspaces[0], accel_factor=self.af)
fourier_mask = np.repeat(mask.astype(np.float), kspaces[0].shape[0], axis=0)
img_batch = list()
z_kspace_batch = list()
to_pad = type(self).pad - kspaces.shape[2]
pad_seq = [(0, 0), (to_pad // 2, to_pad // 2)]
if self.norm and self.mode == 'validation':
means = list()
stddevs = list()
for kspace, image in zip(kspaces, images):
zero_filled_rec = ifft(kspace * fourier_mask)
if self.norm:
zero_filled_rec, mean, std = normalize_instance(zero_filled_rec, eps=1e-11)
image = normalize(image, mean, std, eps=1e-11)
if self.mode == 'validation':
means.append(mean)
stddevs.append(std)
zero_filled_rec = np.pad(zero_filled_rec, pad_seq, mode='constant')
z_kspace = fft(zero_filled_rec)
z_kspace = z_kspace[:, :, None]
z_kspace_batch.append(z_kspace)
image = np.pad(image, pad_seq, mode='constant')
image = image[..., None]
img_batch.append(image)
z_kspace_batch = np.array(z_kspace_batch)
img_batch = np.array(img_batch)
if self.norm and self.mode == 'validation':
return z_kspace_batch, img_batch, means, stddevs
else:
return (z_kspace_batch, img_batch)
def get_summary_dict(batch, run, visualization_keys=None, *others):
if visualization_keys is None:
visualization_keys = ['reconstruction', 'L1']
run = dict(filter(lambda x: x[1] is not None, run.items()))
visuals = np.asarray([
255 * np.hstack([
normalize(batch[i]),
*[normalize(run[key][i]) for key in visualization_keys],
*[normalize(element[i]) for element in others]
]) for i in range(len(batch))
])
scalars = dict(
filter(
lambda x: not (type(x[1]) == float and x[1] != x[1]) and x[1].ndim
== 0, run.items()))
return scalars, visuals
def Load_data(self):
'''
Loading data
return:
- source_data: [samples, self.max_len(steps), input_size]
'''
print('==> Loading data...\n')
source_data = {}
print('Source data shape (samples, max_data_steps, input_size):')
for activity_name, frames_list in self.source_path.items():
frame_data = np.zeros(
(len(frames_list), self.num_joint, self.coord_dim),
dtype=np.float32)
for i, frame in enumerate(frames_list):
with open(frame) as json_file:
data = json.load(json_file)
frame_data[i] = utils.normalize(
np.array(data['people'][0]['pose_keypoints']), 'cnn')
source_data[activity_name] = np.copy(frame_data)
print(' sample {}: {}'.format(activity_name,
source_data[activity_name].shape))
return source_data
def detect(self, text_proposals, scores, size):
"""
Detecting texts from an image
:return: the bounding boxes of the detected texts
"""
# 删除得分较低的proposal
# text_proposals, scores=self.text_proposal_detector.detect(im, cfg.MEAN)
keep_inds = np.where(scores > self.config.TEXT_PROPOSALS_MIN_SCORE)[0]
text_proposals, scores = text_proposals[keep_inds], scores[keep_inds] # choose that score > 0.7
# 按得分排序
sorted_indices = np.argsort(scores.ravel())[::-1]
text_proposals, scores = text_proposals[sorted_indices], scores[sorted_indices] # sort
# 对proposal做nms
# nms for text proposals
keep_inds = nms(np.hstack((text_proposals, scores)), self.config.TEXT_PROPOSALS_NMS_THRESH)
text_proposals, scores = text_proposals[keep_inds], scores[keep_inds] # nms
# 获取检测结果
scores = normalize(scores)
text_lines = self.connector.get_text_lines(text_proposals, scores, size)
# 过滤boxes
keep_inds = self.filter_boxes(text_lines)
text_lines = text_lines[keep_inds]
# 对lines做nms
if text_lines.shape[0] != 0:
keep_inds = nms(text_lines, self.config.TEXT_LINE_NMS_THRESH)
text_lines = text_lines[keep_inds]
return text_lines
def get_height(self, x, sy=0):
x = normalize(x)
h = sy
for y in range(sy, MAP_H):
if self.collision_map[y][x]:
return h
h += 1
return h
def control(self, dt):
if self.final_x > self.x + 500:
self.final_x -= MAP_W
if self.x > self.final_x + 500:
self.final_x += MAP_W
if self.x != self.final_x:
self.x = normalize(lerp(self.x, self.final_x, dt*7))
super().control(dt)
def predict(obj, newdata, **kwargs):
df_treat = newdata.copy()
df_control = newdata.copy()
df_treat['treated'] = 1
df_control['treated'] = 0
global normalize_vars
df_treat, _ = normalize(df_treat, normalize_vars)
df_control, _ = normalize(df_control, normalize_vars)
pred_treat = [val[0] for val in obj.predict(df_treat)]
pred_control = [val[0] for val in obj.predict(df_control)]
pred_df = pd.DataFrame({
"pr_y1_t1": pred_treat,
"pr_y1_t0": pred_control,
})
return pred_df
def feature_extractor(self, y, sr):
mfccs = get_mfcc_v2(y, sr, delta=True, delta_delta=True)
if mfccs.shape[0] < self.frames:
return None
features = np.zeros(shape=(mfccs.shape[0] - self.frames,
mfccs.shape[1] * self.frames))
for i in range(mfccs.shape[0] - self.frames):
features[i] = mfccs[i:i + self.frames].reshape(
1, mfccs.shape[1] * self.frames)
return normalize(features).reshape(-1, self.frames, mfccs.shape[1])
def fit_ground_plane_from_obj_points(points_3d,
ground_plane_default=GP_DEFAULT,
log=False):
"""
fit ground planes for all frames from object 3d points
:param points_3d: 3d points from all frames <list>[n_frames]
:param ground_plane_default: default ground plane, useful when no object points exists
:param log: print log information to terminal
:return: ground planes for all frames <list>[n_frames]
"""
# TODO: calculate CAM_GND_POINT from given ground plane (instead of using default)
# cam_gnd_default = calculate_cam_gnd(ground_plane_default)
ground_planes = []
for frame_id, points_3d_in_frame in enumerate(points_3d):
# iterate for 3d points for different frames
if points_3d_in_frame is not None:
points_3d_in_frame = points_3d_in_frame.T
# at least one 3d point in current frame
n_points = points_3d_in_frame.shape[0]
if n_points == 1:
ground_plane = calculate_ground_plane_from_one_point(
points_3d_in_frame[0])
elif n_points == 2:
ground_plane = calculate_ground_plane_from_two_points(
points_3d_in_frame[0], points_3d_in_frame[1])
else:
ground_plane = calculate_ground_plane_from_mul_points(
points_3d_in_frame)
else:
# no 3d point in current frame
if ground_plane_default is None:
ground_plane = normalize(GP_DEFAULT)
else:
ground_plane = normalize(ground_plane_default)
if log:
print("Ground plane fitting for frame %s:" % frame_id,
ground_plane)
ground_planes.append(ground_plane)
ground_planes = np.array(ground_planes)
return ground_planes
def _calc_trajectory(self, game, data):
x = normalize(data['start_x'])
y = data['start_y']
dt = 1 / 240
t = dt
px, py = 0, 0
while not game['map'].check_collision(int(px), int(py)):
px = normalize(x +
cos(radians(data['angle'])) * data['velocity'] * t)
py = y + sin(radians(data['angle'])) * data['velocity'] * t + \
(GRAVITY*t*t)/2
t += dt
if game['map'].check_collision(int(px), int(py)):
game['map'].explode(int(px), int(py), data['r'])
data['x'] = px
data['y'] = py
return data, t
def __load_embeddding(model, data_iter, args, **kwargs):
stats = args['input_data_stats']
for x in data_iter:
#x[:,:,:6] = 0
if 'ignore_name' in kwargs and kwargs['ignore_name']:
x[:, :, -model.name_dim:] = 0
x = utils.normalize(x, stats, args['normalization_method'])
model.load_embedding(x, **kwargs)
if args['random_embedding']:
break # this gives a random sample of the embedding with the data_iter size
def Load_data(self):
'''
Loading data
return:
- source_data: [samples, self.max_len(steps), input_size]
- target_data: [samples, decoder_steps, self.max_len]
'''
print('==> Loading data...\n')
source_data = {}
print('Source data shape (samples, max_data_steps, input_size):')
for activity_name, frames_list in self.source_path.items():
if self.model == 'cnn':
frame_data = np.zeros(
(len(frames_list), self.num_joint, self.coord_dim),
dtype=np.float32) # cnn
else:
frame_data = np.zeros((len(frames_list), self.input_size),
dtype=np.float32) # rnn
for i, frame in enumerate(frames_list):
with open(frame) as json_file:
data = json.load(json_file)
frame_data[i] = utils.normalize(
np.array(data['people'][0]['pose_keypoints']),
self.model)
source_data[activity_name] = np.copy(frame_data)
print(' sample {}: {}'.format(activity_name,
source_data[activity_name].shape))
target_data = {}
print('Target data shape (samples, decoder_steps, max_data_steps):')
for activity_name, label_list in self.target_path.items():
loaded = np.load(label_list)
lf = np.zeros((self.decoder_steps, loaded.shape[0]),
dtype=np.float32)
# ns = [2, 1, 0.25] # less accurate -> more accurate
# ns = [2, 1, 0.5] # less accurate -> more accurate
ns = [2, 2, 2] # less accurate -> more accurate
assert len(
ns
) == self.decoder_steps, 'length of \'ns\' != \'decoder_steps\'.'
for s in range(self.decoder_steps):
if self.model == 'cnn':
lf[s] = utils.gaussian_like_weighted(loaded) # cnn
else:
lf[s] = utils.gaussian_like_weighted(loaded) # cnn
# lf[s] = utils.gaussian_weighted(loaded, ns[s]) # rnn
target_data[activity_name] = np.copy(lf)
print(' sample {}: {}'.format(activity_name,
target_data[activity_name].shape))
print('\n')
return source_data, target_data
def parse_posiciones(tabla, posiciones=None):
posiciones = int(posiciones[0]) if posiciones else 10
LIMIT = 4
# ['#', 'Equipo', 'Pts', 'PJ']
headers = [th.text for th in tabla.thead.find_all('th')[:LIMIT]]
a = []
for row in tabla.tbody.find_all('tr')[:posiciones]:
b = [normalize(r.text) for r in row.find_all('td')[:LIMIT]]
a.append(b)
a.insert(0, headers)
return a
def _show_trajectory(self):
if sf.Keyboard.is_key_pressed(sf.Keyboard.M) and \
self.hwnd.has_focus():
self.cheat_active = not self.cheat_active
sleep(0.5)
if self.cheat_active:
x, y = self._calc_trajectory(self.tanks[self.tank_id].x,
self.tanks[self.tank_id].y - 11, 60,
True)
x = normalize(x + self.map_scroll)
rect = create_rect(x - 2, y - 2, 4, 4, sf.Color.CYAN)
self.hwnd.draw(rect)
def visualize(self):
# Using PCA (Principal Components Analysis) to recognize faces
# Face recognizer just in openCV version 2.4x, not in version 3.0 (alpha + beta)
# cv2.createEigenFaceRecognizer()
[X, y] = read_images(self._facePath)
# get k principal components
[D, W, mu] = pca(as_row_matrix(X), y)
# to check how many principal components (eigenfaces) - which has the same dimension with observed vector
# print(len(W[1, :]))
# print(len(W[:, 1]))
# Visualize eigenfaces
E = []
# take at most 16 people
for i in xrange(min(len(X), 16)):
e = W[:, i].reshape(X[0].shape)
# normalize value of eigenvectors in [0, 255] to display on image
E.append(normalize(e, 0, 255))
# display k principal components (k eigenvectors)
# eigenfaces encode facial features + illumination of image
subplot(title="Eigencefaces AT&T", images=E, rows=4, cols=4, sptitle="Eigenface", colormap=cm.gray,
filename="pca_eigenface.png")
# Reconstructor image from eigenfaces
# array of vector number [10, 30, 50 ..., min(len(X), 320)]
steps = [i for i in xrange(10, min(len(X), 320), 20)]
E = []
# take at most 16 eigenvectors of first person
for i in xrange(min(len(steps), 16)):
num_eigenvectors = steps[i]
# project each vector x1, x2, ... xn to num_eigenvectors
P = project(W[:, 0:num_eigenvectors], X[0].reshape(1, -1), mu)
# reconstruct image from num_eigenvectors
R = reconstruct(W[:, 0:num_eigenvectors], P, mu)
R = R.reshape(X[0].shape)
E.append(normalize(R, 0, 255))
# reconstruct image from k (10, 30, ...) eigenvector
subplot(title="Reconstruction AT&T", images=E, rows=4, cols=4, sptitle="EigenVectors", sptitles=steps,
colormap=cm.gray, filename="pca_reconstruction.png")
def get_minimal_movie(movie, trim_description=True):
"""Return image, title, synopsis, and Torrents from a movie."""
title = movie['title_long']
imdb = movie['imdb_code']
yt_trailer = movie['yt_trailer_code']
if trim_description:
synopsis = normalize(movie['synopsis'], limit=150, trim_end='..')
else:
synopsis = movie['synopsis']
rating = movie['rating']
image = movie['large_cover_image']
return title, synopsis, rating, imdb, yt_trailer, image
def _calc_trajectory(self, x, y, fps=60, draw=False):
rect = create_rect(0, 0, 2, 2, sf.Color(0, 0, 0, 50))
x = normalize(x)
y = y
px, py = 0, 0
dt = 1 / fps
t = dt
angle = self.tanks[self.tank_id].aim_angle
w = self.ui.get_widget('power_slider')
if w is None:
return
velocity = w.get_value() * 540
while not self.map.check_collision(int(px), int(py)):
px = normalize(x + cos(radians(angle)) * velocity * t)
py = y + sin(radians(angle)) * velocity * t + \
0.5*(GRAVITY*t*t)
t += dt
if draw:
rect.position = (normalize(px + self.map_scroll) - 1, py - 1)
self.hwnd.draw(rect)
return (px, py)
def predict_img(net, img, gpu):
img = img[:, :, :3] # alphachannelを削除
img = utils.normalize(img)
img = np.transpose(img, axes=[2, 0, 1])
X = torch.FloatTensor(img).unsqueeze(0)
X = Variable(X, volatile=True)
if gpu:
X = X.cuda()
y_hat = F.sigmoid(net(X))
y_hat = np.asarray((y_hat > 0.5).data)
y_hat = y_hat.reshape((y_hat.shape[2], y_hat.shape[3]))
return y_hat
def eval_tgt_robust(encoder, classifier, critic, data_loader):
"""Evaluate model for target domain with attack on labels and domains"""
# Set eval state for Dropout and BN layers
encoder.eval()
classifier.eval()
critic.eval()
# Init loss and accuracy
loss, acc = 0, 0
test_robust_loss, test_robust_acc = 0, 0
# Set loss function
criterion = nn.CrossEntropyLoss()
# Evaluate network
for (images, labels) in data_loader:
images = make_variable(images)
labels = make_variable(labels)
domain_tgt = make_variable(torch.ones(images.size(0)).long())
delta_src = attack_pgd(encoder, classifier, images, labels)
delta_domain = attack_pgd(encoder, critic, images, domain_tgt)
delta_src = delta_src.detach()
delta_domain = delta_domain.detach()
# Compute loss
robust_images = normalize(
torch.clamp(images + delta_src[:images.size(0)] +
delta_domain[:images.size(0)],
min=params.lower_limit,
max=params.upper_limit))
robust_preds = classifier(encoder(robust_images))
test_robust_loss += criterion(robust_preds, labels).item()
out = classifier(encoder(images))
loss += criterion(out, labels).item()
test_robust_acc += torch.sum(
robust_preds.max(1)[1] == labels.data).double()
acc += torch.sum(out.max(1)[1] == labels.data).double()
loss /= len(data_loader)
test_robust_loss /= len(data_loader)
acc = acc / len(data_loader.dataset)
test_robust_acc = test_robust_acc / len(data_loader.dataset)
print(
"Avg Evaluation Loss: {:.4f}, Avg Evaluation Accuracy: {:.4%}, Ave Evaluation Robust Loss: {:.4f}, "
"Ave Robust Accuracy: {:.4%}".format(loss, acc, test_robust_loss,
test_robust_acc))
def move(self, dt):
if self.move_limit <= 0:
return
move_amount = dt*Tank.VELOCITY
if sf.Keyboard.is_key_pressed(sf.Keyboard.A):
self.x -= move_amount
self.move_limit -= abs(move_amount)
if sf.Keyboard.is_key_pressed(sf.Keyboard.D):
self.x += move_amount
self.move_limit -= abs(move_amount)
self.x = normalize(self.x)
def pretty_print_dolar(cotizaciones, limit=7):
"""Returns dolar rates separated by newlines and with code markdown syntax.
```
Banco Nacion | $30.00 | $40.00
Banco Galicia | $30.00 | $40.00
...
```
"""
return monospace(
'\n'.join(
"{:8} | {:7} | {:7}".format(
normalize(banco, limit), valor['compra'], valor['venta']
)
for banco, valor in cotizaciones.items()
)
)
def __init__(self, map, x, y, angle, vel, final_pos=None):
self.map = map
self.texture = texture_manager.textures[TEXTURE.MISSLE]
self.sprite = sf.Sprite(self.texture)
self.sprite.origin = (2, 2)
self.enemy_missle = True if final_pos is not None else False
self.final_pos = final_pos
self.start_x = normalize(x)
self.start_y = y
self.x = self.start_x
self.y = y
self.angle = radians(angle)
self.vel = vel
self.clock = None
self.should_remove = False
self.r = 24
self.t = 0
def calculate_ground_plane_from_mul_points(points_3d,
cam_gnd=CAM_GND_DEFAULT,
use_cam_gnd=True):
if use_cam_gnd:
points_3d = np.vstack((points_3d, cam_gnd))
n_points = points_3d.shape[0]
params, residuals, _, _ = np.linalg.lstsq(points_3d,
-np.ones((n_points, 1)),
rcond=-1)
params = np.squeeze(params)
params = np.append(params, 1.0)
params = normalize(params)
# print(params, residuals)
# TODO: how to use residuals?
return params
def control(self, dt):
if self.should_remove:
return
if self.map.check_collision(int(self.x), int(self.y)):
if self.final_pos is not None:
self.x = self.final_pos[0]
self.y = self.final_pos[1]
self.final_pos = None
self.map.explode(int(self.x), int(self.y), self.r)
self.should_remove = True
return
self.t += dt
self.x = normalize(self.start_x + cos(self.angle) * self.vel * self.t)
self.y = self.start_y + sin(self.angle) * self.vel * self.t + \
0.5*(GRAVITY*self.t*self.t)
self.sprite.rotate(dt*180)
def main():
data = datasets.load_digits()
X = normalize(data.data)
y = data.target
# data preprocess: One-hot encoding of nominal y-values
y = to_categorical(y)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33)
clf = Perceptron(n_iterations=5000, learning_rate=0.001, loss=CrossEntropy, activation_function=Sigmoid)
clf.fit(X_train, y_train)
y_pred = np.argmax(clf.predict(X_test), axis=1)
y_test = np.argmax(y_test, axis=1)
accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy}")
Plot().plot_in_2d(X_test, y_pred, title="perceptron", accuracy=accuracy, legend_labels=np.unique(y))
def pre_processing(pure_freq_file, unified_file, forward_file):
phrase_dict = {}
forward_list = []
with open(pure_freq_file, 'r') as f:
for line in f:
elems = line.strip(' \n').split(':')
# print line
tokens = elems[1].split(',')
phrases_in_doc = []
for token in tokens:
phrase = normalize(token.split('|')[0])
# only keep n-grams
if ' ' not in phrase:
continue
phrase_dict[phrase] = 1 if phrase not in phrase_dict else phrase_dict[phrase] + 1
phrases_in_doc.append(phrase)
forward_list.append(phrases_in_doc)
# sort the forward list by frequency of phrase
forward_list_true = []
idx = 0
for phrases_in_doc in forward_list:
idx += 1
print idx
temp_list = {}
for phrase in phrases_in_doc:
occur = phrase_dict[phrase]
temp_list[phrase] = occur
ranked_list = sorted(temp_list, key=temp_list.get, reverse=False)
forward_list_true.append(ranked_list)
with open(unified_file, 'w+') as f:
for phrase in phrase_dict:
f.write(phrase + '\t' + str(phrase_dict[phrase]) + '\n')
with open(forward_file, 'w+') as f:
for phrases_in_doc in forward_list_true:
f.write(','.join(phrases_in_doc) + '\n')
def draw(self, hwnd, map_scroll):
x = normalize(self.x + map_scroll)
positions = get_border_positions(x, 50)
for x in positions:
self.bar_green.position = (x-5, self.y-22)
self.bar_red.position = (x-5+self.bar_green_len, self.y-22)
self.barrel_sprite.position = (x, self.y-10)
self.sprite.position = (x, self.y-8)
self.crosshair_sprite.position = (
x + 35*cos(radians(self.aim_angle)),
self.y - 12 + 35*sin(radians(self.aim_angle)))
hwnd.draw(self.barrel_sprite)
hwnd.draw(self.sprite)
hwnd.draw(self.bar_green)
hwnd.draw(self.bar_red)
self.rect = create_rect(
x-1, self.y-1, 2, 2, sf.Color(255, 255, 255))
hwnd.draw(self.rect)
def get_firm_choice(self, firms_idx, prices):
"""choice function"""
consume = len(prices) > 0
if consume:
price = min(prices) # Choose minimum price
self.firm_choice = np.random.choice(firms_idx[prices == price])
else:
price = 0
self.firm_choice = -1
exploration_cost = self.t_cost * self.extra_view
self.utility = int(consume) * self.u_consumption - (exploration_cost + price)
self.network_target = normalize(self.utility, min_=self.utility_min, max_=self.utility_max)
self._learn()
return self.firm_choice
def fit(x, y, t, **kwargs):
lr = kwargs.get('lr')
epochs = kwargs.get('epochs')
batch_size = kwargs.get('batch_size')
decay = kwargs.get('decay')
method = kwargs.get('method')
activation = 'sigmoid' if method == 'logistic' else 'linear'
init_tf(1234)
df = x.copy()
df['treated'] = t
global normalize_vars
df, normalize_vars = normalize(df)
model = build_model(df.shape[1], 1, activation)
model = set_optimizer(model, lr, activation, decay)
model.fit(df, y, epochs=epochs, batch_size=batch_size, validation_split=0.2, verbose=2)
return model
def predict(self, X):
X = normalize(polynomial_features(X, degree=self.degree))
super(ElasticNet, self).predict(X)
def readBBox(self, scene):
'''
ReadBBox(self, scene): -> bbox, origin, vu, vv, vw, depth, width, height
'''
(bboxName, topMatName, leftMatName, frontMatName) = self.getFixBBoxParams()
# read the bbox from scene
bbox = MXS.getObject(scene, bboxName)
if bbox.isNull():
raise ("cannot find the object named {}".format(bboxName))
# hide the bbox
MXS.setObjectInvisible(bbox)
# read the top, left and right planes
topTriIds = MXS.getObjectTrianglesByMat(bbox, topMatName)
leftTriIds = MXS.getObjectTrianglesByMat(bbox, leftMatName)
frontTriIds = MXS.getObjectTrianglesByMat(bbox, frontMatName)
if len(topTriIds) ==0 or len(leftTriIds) == 0 or len(frontTriIds) == 0:
raise ("cannot correct find min_box")
# read the bbox geometry information
points = MXS.getObjectVertices(bbox)
triangles = MXS.getObjectTriangles(bbox)
# make points set of three planes
topPtsSet = set()
for topTriId in topTriIds:
vs = triangles[topTriId]
topPtsSet.add(vs[0])
topPtsSet.add(vs[1])
topPtsSet.add(vs[2])
leftPtsSet = set()
for leftTriId in leftTriIds:
vs = triangles[leftTriId]
leftPtsSet.add(vs[0])
leftPtsSet.add(vs[1])
leftPtsSet.add(vs[2])
frontPtsSet = set()
for frontTriId in frontTriIds:
vs = triangles[frontTriId]
frontPtsSet.add(vs[0])
frontPtsSet.add(vs[1])
frontPtsSet.add(vs[2])
# find origin, u, v, w
oPtId = topPtsSet & leftPtsSet & frontPtsSet
uPtId = (topPtsSet & leftPtsSet ) - oPtId
vPtId = (topPtsSet & frontPtsSet) - oPtId
wPtId = (leftPtsSet& frontPtsSet) - oPtId
oPtId = oPtId.pop()
uPtId = uPtId.pop()
vPtId = vPtId.pop()
wPtId = wPtId.pop()
# normalize the vector
origin = points[oPtId]
vu = points[uPtId] - origin
vv = points[vPtId] - origin
vw = points[wPtId] - origin
depth = Utils.norm2(vu)
width = Utils.norm2(vv)
height = Utils.norm2(vw)
vu = Utils.normalize(vu)
vv = Utils.normalize(vv)
vw = Utils.normalize(vw)
print("box depth: "+str(depth))
print("box width: "+str(width))
print("box height: "+str(height))
return (bbox, points, triangles, origin, vu, vv, vw, depth, width, height)
def fit(self, X, y):
X = normalize(polynomial_features(X, degree=self.degree))
super(ElasticNet, self).fit(X, y)
def predict(self, X):
X = normalize(polynomial_features(X, degree=self.degree))
return super(LassoRegression, self).predict(X)
def fit(self, X, y):
X = normalize(polynomial_features(X, degree=self.degree))
super(PolynomialRidgeRegression, self).fit(X, y)
def compute(self, score_type='ALL'):
'''
-- score_type --
ALL: all three factors
POP: only popularity
DIS: only distinctive
INT: only integrity
NOPOP: no populairty
NODIS: no distinctive
NOINT: no integrity
'''
scores = {}
multiplier = 1
sum_self = self.sum_cnt
num_context_cells = len(self.sum_cnt_context) + 1
total_sum = sum(self.sum_cnt_context.values()) + sum_self
avgdl = total_sum / float(num_context_cells)
# method 1
for phrase in self.phrase_cnt:
lower_phrase = phrase.lower()
score = 1
nor_phrase = normalize(lower_phrase)
self_cnt = self.phrase_cnt[phrase]
self_df = self.phrase_df[phrase]
group = [(self_df, self.max_df, self_cnt, sum_self)]
self.context_groups[phrase] = []
for phrase_group, phrase_values in self.phrase_cnt_context.items():
context_df = self.phrase_df_context[phrase_group].get(phrase, 0)
sum_context = self.sum_cnt_context[phrase_group]
context_cnt = phrase_values.get(phrase, 0)
maxdf_context = self.max_df_context[phrase_group]
if (context_cnt > 0):
group.append((context_df, maxdf_context, context_cnt, sum_context))
self.context_groups[phrase].append((context_df, maxdf_context, context_cnt, sum_context))
score_list = []
for record in group:
score_list.append(self.bm25_df_paper(record[0], record[1], record[2], record[3], avgdl))
distinct = self.softmax_paper(score_list)[0]
# score_list = map(prettyfloat, score_list)
# log_str = lower_phrase.encode('utf-8') + ':' + str(prettyfloat(score)) + '\t' + str(group) + '\t' + str(score_list) + '\n'
# log_strs[lower_phrase] = log_str
# log_scores[lower_phrase] = score
# distinct = score
popularity = math.log(1 + self_df, 2)
try:
integrity = float(self.global_scores[nor_phrase])
except:
integrity = 0.8
if score_type == 'ALL':
score = distinct * popularity * integrity
elif score_type == 'POP':
score = popularity
elif score_type == 'DIS':
score = distinct
elif score_type == 'INT':
score = integrity
elif score_type == 'NOPOP':
score = distinct * integrity
elif score_type == 'NODIS':
score = popularity * integrity
elif score_type == 'NOINT':
score = popularity * distinct
else:
score = 0
scores[phrase] = score
ranked_list = [(phrase, scores[phrase]) for phrase in sorted(scores, key=scores.get, reverse=True)]
print 'OLAPORP DONE'
return ranked_list
def update_computing(self, score_type='ALL'):
scores = {}
multiplier = 1
sum_self = self.sum_cnt
num_context_cells = len(self.sum_cnt_context) + 1
total_sum = sum(self.sum_cnt_context.values()) + sum_self
avgdl = total_sum / float(num_context_cells)
# method 1
for phrase in self.phrase_cnt:
lower_phrase = phrase.lower()
score = 1
nor_phrase = normalize(lower_phrase)
self_cnt = self.phrase_cnt[phrase]
self_df = self.phrase_df[phrase]
group = list(self.context_groups[phrase])
group.append((self_df, self.max_df, self_cnt, sum_self))
score_list = []
for record in group:
score_list.append(self.bm25_df_paper(record[0], record[1], record[2], record[3], avgdl))
distinct = self.softmax_paper(score_list)[-1]
# score_list = map(prettyfloat, score_list)
# log_str = lower_phrase.encode('utf-8') + ':' + str(prettyfloat(score)) + '\t' + str(group) + '\t' + str(score_list) + '\n'
# log_strs[lower_phrase] = log_str
# log_scores[lower_phrase] = score
# distinct = score
popularity = math.log(1 + self_df, 2)
try:
integrity = float(self.global_scores[nor_phrase])
except:
integrity = 0.8
if score_type == 'ALL':
score = distinct * popularity * integrity
elif score_type == 'POP':
score = popularity
elif score_type == 'DIS':
score = distinct
elif score_type == 'INT':
score = integrity
elif score_type == 'NOPOP':
score = distinct * integrity
elif score_type == 'NODIS':
score = popularity * integrity
elif score_type == 'NOINT':
score = popularity * distinct
else:
score = 0
scores[phrase] = score
ranked_list = [(phrase, scores[phrase]) for phrase in sorted(scores, key=scores.get, reverse=True)]
self.ranked_list = ranked_list
print 'OLAPORP DONE'
return ranked_list
def predict(self, X):
X = normalize(polynomial_features(X, degree=self.degree))
super(PolynomialRidgeRegression, self).predict(X)
