def main(npzout: str, npzin: str = None):
collection = []
with open("./resources/Collection.txt") as fileinput:
for row in fileinput:
collection.append(Counter(row.split()))
if npzin is None:
p_wt = normalize(cp.random.rand(LEXICON_SIZE, TOPIC_SIZE), axis=0)
p_td = normalize(cp.random.rand(COLLECTION_SIZE, TOPIC_SIZE), axis=0)
else:
npzfile = cp.load(npzin)
assert filecheck(npzfile)
p_wt = npzfile["p_wt"]
p_td = npzfile["p_td"]
baseline_likelihood = log_likelihood(collection, p_wt, p_td)
print("likelihood(baseline): %f" % (baseline_likelihood))
prev_likelihood = baseline_likelihood
for index in range(1000):
p_wt, p_td = em(collection, p_wt, p_td)
cp.savez(npzout, p_wt=p_wt, p_td=p_td)
likelihood = log_likelihood(collection, p_wt, p_td)
print("likelihood(%d): %f" % (index + 1, likelihood))
if (likelihood -
prev_likelihood) / abs(prev_likelihood) < UPDATE_THRESHOLD:
break
prev_likelihood = likelihood
def main():
n, d, epochs, ny, seed_nr, m = 100, 1000, 200, 3, 14, [200, 400, 800, 1600, 3200]
save_weights, plt_fig, save_fig, timer,verbose = "no", "no", "no", "no", 0
cp.random.seed(seed_nr)
epoch_vec = cp.arange(epochs + 1)
if timer =="yes":
time_all()
loss_k, pattern_change, max_dist, least_eig = iterate(epochs, m, n, d, ny,verbose)
if save_weights == "yes":
cp.savez("Model"+str(np.datetime64("now")), loss_k=loss_k, epoch_vec=epoch_vec, m=m,
pattern_change=pattern_change, max_dist=max_dist,
least_eig=least_eig, ny=ny, n=n, d=d, seed_nr=seed_nr)
if plt_fig == "yes":
plot_fig(loss_k, epoch_vec, m, pattern_change, max_dist, least_eig, n, d,save_fig)
def save(self, path: str):
data = {f"p{i}": p.data for i, p in enumerate(self.params)}
xp.savez(path, **data)
P_NN = NN_softmax_form(dist_mtx, args.epsilon, axis=1)
p_nn = compute_accuracy(P_NN, y_gallery, y_query, args.majority_vote)
print("NN test accuracy (top-[1, 5, 10]): {}%".format(p_nn), flush=True)
# ISF
P_ISF, hp_isf = isoftmax(dist_mtx, args.epsilon, axis=1)
p_isf = compute_accuracy(P_ISF, y_gallery, y_query, args.majority_vote)
print('ISF test accuracy (top-[1, 5, 10]): {}%'.format(p_isf), flush=True)
# HNN primal
P_HNN0 = HNN_primal(dist_mtx, args.epsilon, args.iters)
p_hnn0 = compute_accuracy(P_HNN0, y_gallery, y_query, args.majority_vote)
print('HNN primal test accuracy (top-[1, 5, 10]): {}%'.format(p_hnn0),
flush=True)
# HNN dual
print("Running HNN dual ...", flush=True)
HNN_dual = HNN(X_query, X_gallery, dist_function, args.epsilon)
HNN_dual.gallery_weight(args.iters, batch=128, lr=100)
HNN_dual.get_full_plan()
hp_hnn = -HNN_dual.beta / args.epsilon
P_HNN1 = HNN_dual.P
p_hnn1 = compute_accuracy(P_HNN1, y_gallery, y_query, args.majority_vote)
print('HNN dual test accuracy (top-[1, 5, 10]): {}%'.format(p_hnn1),
flush=True)
if args.save_matrices:
xp.savez(args.save_matrices, P_NN=P_NN, P_ISF=P_ISF,
P_HNN_primal=P_HNN0, P_HNN_dual=P_HNN1,
hp_isf=hp_isf, hp_hnn=hp_hnn)
def gen_data_npz(fimg, img, mask, config, ntiles=1000, save_dir='train'):
"""
Extract random patches from cupy arrays.
Args:
fimg (str): data filename
img (cupy.array): cupy array with data
mask (cupy.array): cupy array with mask
save_dir (str): directory to save output
Return:
save dataset to save_dir.
----------
Example
----------
gen_data_npz('image.tif', arr, mask, config, 8000, 'output')
"""
# set dimensions of the input image array, and get desired tile size
z_dim, x_dim, y_dim = img.shape
tsz = config.TILE_SIZE
# placeholders for final datasets
img_cp = cp.empty((ntiles, tsz, tsz, z_dim), dtype=cp.float32)
mask_np = np.empty((ntiles, tsz, tsz, config.N_CLASSES), dtype=np.float16)
# generate n number of tiles
for i in tqdm(range(ntiles)):
# Generate random integers from image
xc = random.randint(0, x_dim - tsz)
yc = random.randint(0, y_dim - tsz)
# verify data is not on nodata region
while cp.any(img[:, xc:(xc + tsz),
yc:(yc + tsz)] == config.NODATA_VAL):
xc = random.randint(0, x_dim - tsz)
yc = random.randint(0, y_dim - tsz)
# change order to (h, w, c)
tile_img = cp.moveaxis(img[:, xc:(xc + tsz), yc:(yc + tsz)], 0, -1)
# TODO: replace with cuml One-hot encoder on future date when they fix
# a bug on the output types. Using to_categorical in the meantime
# Converts labels into one-hot encoding labels
tile_mask = to_categorical(cp.asnumpy(mask[xc:(xc + tsz),
yc:(yc + tsz)]),
num_classes=config.N_CLASSES,
dtype='float16')
# maybe standardize here? depends on performance of single img vs batch
img_cp[i, :, :, :] = tile_img
mask_np[i, :, :, :] = tile_mask
# normalize
if config.NORMALIZE:
img_cp = img_cp / config.normalization_factor
# standardize
if config.STANDARDIZE:
img_cp = batch_normalize(img_cp, axis=(0, 1), c=1e-8)
# save dataset into local disk, npz format with x and y labels
cp.savez(f'{save_dir}/{fimg[:-4]}.npz', x=img_cp, y=cp.asarray(mask_np))
# if times % 1000000 * Annealing[0] * Annealing[1] == 0:
# L = L / Annealing[1]
# Annealing[0] += 1
# if L < 0.000001:
# plt.show()
print()
print("第%d次訓練(學習率:%f):" % (times, L))
print("output:\n", output[2])
print("總誤差:", error)
print(expect_data.shape)
print("輸出位置:", output[1])
print("輸出位置對應答案的值", result)
print("答對筆數/總筆數: %d/%d" % (k, train_datas))
# plt.plot(x, y)
# plt.show()
cp.savez("weight_%f.npz" % (L), weight, weight2,
weight3, weight4, baise, baise2, baise3, baise4)
# with open("weight_%f.txt" % (L), 'w', newline='') as csvfile:
# spamwriter = csv.writer(csvfile)
# for i in weight:
# spamwriter.writerow(map(str, i))
# with open("weight2_%f.txt" % (L), 'w', newline='') as csvfile:
# spamwriter = csv.writer(csvfile)
# for i in weight2:
# spamwriter.writerow(map(str, i))
# with open("baise_%f.txt" % (L), 'w', newline='') as csvfile:
# spamwriter = csv.writer(csvfile)
# for i in baise:
# spamwriter.writerow(map(str, i))
# with open("baise2_%f.txt" % (L), 'w', newline='') as csvfile:
# spamwriter = csv.writer(csvfile)
# for i in baise2:
plt.rcParams['grid.linewidth'] = 0.3
plt.rcParams["legend.markerscale"] = 2
plt.rcParams["legend.fancybox"] = False
plt.rcParams["legend.edgecolor"] = 'black'
for i in range(10):
plt.plot([0, 0.5, 1, 1.5, 2, 2.5, 3],
rt.v_to_dbm(abs(test[i]), 50),
label=f'ant1.y={i*0.1}')
plt.title('ant1=(0, 0.0-0.1), ant2=(1.2, 1.5) [m]')
plt.ylabel('rx power [dBm]')
plt.xlabel('mesurement point x [m], (y=0 [m])')
plt.grid()
plt.legend()
plt.show()
# シリアライズしたデータの順番
# shape = (30, 30, 30, 30, 7)
# (x1_position, y1_position, x2_position, y2_position, rx_power)
if __name__ == '__main__':
deg_start = sys.argv[1]
deg_stop = sys.argv[2]
print(f'processing {deg_start} from {deg_stop}')
# temp = cp.empty([int(deg_stop)+1, const.x_num, const.y_num, const.x_num,
# const.y_num, const.rx_antenna_num])
os.makedirs("traning_data", exist_ok=True)
# rangeはendpointが含まれないので，stop+1している
for deg in tqdm(range(int(deg_start), int(deg_stop) + 1, 1)):
cp.savez("/tmp/training_data/training_data_" + str(deg),
calc_antennas_vector(deg))
def time_vb_savez_squares(self):
np.savez('tmp.npz', self.squares)
def update(self):
"""
Where the magic happens. Finds a threshold that will limit the number of params in the network
to the tracked_size, and resets those params to the initial value to emulate how DropBack would
work in real hardware.
Chainer will calculate all grads, and this updater inserts itself before the next
forward pass can occur to set the parameters back to what they should be. Only the params with the largest
current-initial value will not be reset to initial. This emulates the accumulated gradient updates of the actual
algorithm.
:return:
"""
if self.first_iter:
self.first_iter = False
self.params = [i for i in self.opt.target.params()]
for i, p in enumerate(self.params):
self.init_params.append(xp.copy(p.data))
if not os.path.exists(self.output_dir):
os.makedirs(self.output_dir)
xp.savez(
os.path.join(self.output_dir,
'init_params_{0}'.format(self.time_stamp)),
self.init_params)
if self.tracked_size:
self.frozen_masks = [None] * len(self.params)
super(DropBack, self).update()
if self.decay_init and not self.first_iter:
for i, _ in enumerate(self.init_params):
self.init_params[i] = self.init_params[i] * .90
if self.tracked_size:
if not self.freeze:
abs_values = []
for i, param in enumerate(self.params):
if param.name == 'b':
values = (xp.abs(param.data).flatten()).copy()
else:
values = (
xp.abs(param.data -
self.init_params[i]).flatten()).copy()
abs_values.append(values)
abs_vals = xp.concatenate(abs_values)
thresh = xp.partition(abs_vals,
self.tracked_size)[-self.tracked_size]
for i, param in enumerate(self.params):
if param.name == 'b':
if self.freeze:
mask = self.frozen_masks[i]
else:
mask = xp.abs(param.data) > thresh
param.data = mask * param.data
else:
if self.freeze:
mask = self.frozen_masks[i]
else:
mask = xp.abs(param.data -
self.init_params[i]) > thresh
param.data = mask * param.data + self.init_params[i] * ~mask
self.frozen_masks[i] = mask
if self.iteration == 3465:
print("Checking inv...")
total_sum = sum([
xp.count_nonzero(p.data != self.init_params[i])
for i, p in enumerate(self.params)
])
print(
"********\n\n Total non zero is: {}\n\n1*********".format(
total_sum))
assert total_sum <= self.tracked_size * 1.1
if self.track:
if (self.iteration - 1) % 100 == 0:
flat_now = xp.concatenate(
[i.array.ravel() for i in self.params])
flat_0 = xp.concatenate([i.ravel() for i in self.init_params])
xp.savez(
os.path.join(self.output_dir, f'l2_{self.iteration-1}'),
xp.linalg.norm(flat_now - flat_0))
xp.savez(
os.path.join(self.output_dir,
f'param_hist_{self.iteration-1}'),
xp.concatenate([
i.array.ravel() for i in self.params
if i.name == 'b' or i.name == 'W'
]))