def __btn_genEuDM(self):
self.plotClear()
self.coords = dataSource.get_rand_data((1, self.N, 2), isInt=True,
maxXY=maxXY, minXY=minXY)
self.coords = utils.minmax_norm(self.coords)[0]
data = utils.get_distanceSq_matrix(self.coords) ** 0.5
data = utils.minmax_norm(data)[0]
self.fillEntry(data=data, entrylist=self.genDmViews)
self.coords = self.etm.norm(self.coords[0].detach().numpy())
self.showingTrueLabel = False
self.toggleTrueLabel()
self.resetResult()
def __btn_rsCoord_fun(self, method_name=None):
dm = self.getEntry(self.genDmViews).reshape(self.N, self.N)
method_name = self.opt_method.get() if method_name is None else method_name
if method_name == 'Deep MDS':
if self.window_deepMDS is not None:
return
self.plotRemove(method_name)
self.__buildDeepMDSWindow()
self.master.wait_window(self.window_deepMDS)
self.window_deepMDS = None
data, time = utils.time_measure(self.methods[method_name], [dm])
data = torch.tensor(data)
data = utils.minmax_norm(data.view(1, -1))[0]
self.fillEntry(data=data, entrylist=self.rsCoordViews)
coords = data.reshape(self.N, self.d)
self.plotData(x=coords[:, 0], y=coords[:, 1], label=method_name)
dm = torch.tensor(dm)
rs_dm = utils.get_distanceSq_matrix(coords) ** 0.5
rs_dm = utils.minmax_norm(rs_dm)[0] * torch.max(dm)
loss = torch.mean(torch.abs(dm - rs_dm.view_as(dm)))
self.label_loss.config(text='Loss = %s (%ss)' % (
str(round(float(loss), 10)), str(round(time, 4))
))
self.fillEntry(data=rs_dm, entrylist=self.rsDmViews)
self.colorized = not self.colorized
self.toggleColorizeDiff(self.rsDmViews)
def __init__(self, N, d, test_size):
self.N = N
self.d = d
self.n_d = int(N * (N - 1) / 2)
self.test_size = test_size
self.etm = Algorithm(N, d)
self.lossFun = CoordsToDMLoss(
N=N, lossFun=nn.L1Loss(reduction='mean'))
self.test_data = dataSource.generate_rand_DM(
self.N, self.test_size, isInt=True, sample_space=(1000, 1))
self.test_data = utils.minmax_norm(self.test_data, dmin=0)[0]
def __call__(self, x):
prep_x = x
if self.add_noise:
prep_x = add_noise_to_dm(prep_x)
if self.scale:
prep_x = utils.minmax_norm(prep_x, dmin=0)[0]
if self.flatten:
prep_x = prep_x.view(prep_x.size()[0], 1, -1)
prep_x = prep_x.clone().detach().requires_grad_(True)
return prep_x, x
def __btn_genDM_fun(self):
self.plotClear()
self.coords = None
data = dataSource.generate_rand_DM(
N=self.N, sample_size=1, isInt=True, sample_space=(maxXY, minXY))
data = utils.minmax_norm(data)[0]
self.fillEntry(data=data, entrylist=self.genDmViews)
self.showingTrueLabel = True
self.toggleTrueLabel()
self.resetResult()
def validation_step(self, batch, batch_idx):
image = batch['image']
label = batch['label']
with torch.no_grad():
logit, _ = self.forward(image)
dice = self.dice_metric(logit, label)
if batch_idx == 0:
image = image.detach().cpu()
image = minmax_norm(image)
label = label.detach().cpu()
output = logit.argmax(dim=1).detach().cpu()
n_images = min(self.config.save.n_save_images, image.size(0))
save_modalities = ['t1ce']
if 'flair' in self.config.dataset.modalities:
save_modalities.append('flair')
save_series = []
for modality in save_modalities:
idx = self.config.dataset.modalities.index(modality)
save_image = image[:n_images, ...][:, idx, ...][:, np.newaxis,
...]
save_series.append(save_image)
label = label[:n_images, ...].float()[:, np.newaxis, ...]
output = output[:n_images, ...].float()[:, np.newaxis, ...]
max_label_val = self.config.metric.n_classes - 1
label /= max_label_val
output /= max_label_val
save_series.append(label)
save_series.append(output)
label_grid = torch.cat(save_series)
self.logger.log_images('segmentation',
label_grid,
self.current_epoch,
self.global_step,
nrow=n_images)
return dice
def main():
# Option Parser
if (len(sys.argv) <= 1):
print("train.py -h or --help to get guideline of input options")
exit()
use = "Usage: %prog [options] filename"
parser = OptionParser(usage=use)
parser.add_option("-d",
"--input-dir",
dest="input_dir",
action="store",
type="string",
help="input data dir")
parser.add_option("-o",
"--output-dir",
dest="ckpt_dir",
action="store",
type="string",
help="ckpt data dir")
parser.add_option("-t",
"--timesteps",
dest="timesteps",
action="store",
type="int",
help="timesteps")
parser.add_option("-n",
"--num-input",
dest="num_input",
action="store",
type="int",
help="number of input (input vector's width)")
(options, args) = parser.parse_args()
input_dir = options.input_dir
timesteps = options.timesteps
num_input = options.num_input
ckpt_dir = options.ckpt_dir
X = np.fromfile(input_dir + '/X.dat', dtype=float)
cardinality = int(X.shape[0] / (timesteps * num_input))
X = X.reshape([cardinality, timesteps * num_input])
Y = np.fromfile(input_dir + '/Y.dat', dtype=float)
train_x, val_x, test_x, train_y, val_y, test_y = utl.train_val_test_split(
X, Y, split_frac=0.80)
#print("Data Set Size")
#print("Train set: \t\t{}".format(train_x.shape),
# "\nValidation set: \t{}".format(val_x.shape),
# "\nTest set: \t\t{}".format(test_x.shape))
# In[ ]:
# Training Parameters
learning_rate = 0.0015
epochs = 200
batch_size = 40
#display_step = 200
# Network Parameters
#num_input = 2
#timesteps = 480
num_hidden = 2048
num_classes = 1
print("### Network Parameters ###")
print("Learning Rate: {}".format(learning_rate))
print("Batch Size: {}".format(batch_size))
print("Size of Hidden Layer: {}".format(num_hidden))
print("Timestep: {}".format(timesteps))
print("------------------")
X_ = tf.placeholder("float", [None, timesteps, num_input])
Y_ = tf.placeholder("float", [None, num_classes])
lr = tf.placeholder("float")
weights = {'out': tf.Variable(tf.random_normal([num_hidden, num_classes]))}
biases = {'out': tf.Variable(tf.random_normal([num_classes]))}
prediction = RNN(X_, weights, biases, timesteps, num_hidden)
loss_op = tf.losses.mean_squared_error(Y_, prediction)
#optimizer = tf.train.AdadeltaOptimizer(lr).minimize(loss_op)
#optimizer = tf.train.AdamOptimizer(lr).minimize(loss_op)
optimizer = tf.train.GradientDescentOptimizer(lr).minimize(loss_op)
correct_pred = tf.equal(
tf.cast((prediction / 1.8) - tf.round(prediction / 1.8), tf.float32),
tf.cast((prediction / 1.8) - tf.round(Y_ / 1.8), tf.float32))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
init = tf.global_variables_initializer()
with tf.Session() as sess:
# Run the initializer
sess.run(init)
saver = tf.train.Saver()
n_batches = len(train_x) // batch_size
for e in range(epochs):
if epochs % 30 == 0:
learning_rate = learning_rate * 0.95
train_acc = []
for ii, (x, y) in enumerate(
utl.get_batches(train_x, train_y, batch_size), 1):
x = x.reshape((batch_size, timesteps, num_input))
x_norm = utl.minmax_norm(x)
feed = {X_: x_norm, Y_: y[:, None], lr: learning_rate}
loss, acc, _ = sess.run([loss_op, accuracy, optimizer],
feed_dict=feed)
train_acc.append(acc)
if (ii + 1) % n_batches == 0:
val_acc = []
for xx, yy in utl.get_batches(val_x, val_y, batch_size):
xx = xx.reshape((batch_size, timesteps, num_input))
xx_norm = utl.minmax_norm(xx)
feed = {
X_: xx_norm,
Y_: yy[:, None],
lr: learning_rate
}
val_batch_loss = sess.run([loss_op], feed_dict=feed)
val_acc.append(val_batch_loss)
print(
"Epoch: {}/{}...".format(e + 1, epochs),
"Batch: {}/{}...".format(ii + 1, n_batches),
"Train Loss: {:.3f}...".format(loss),
#"Train Accruacy: {:.3f}...".format(np.mean(train_acc)),
"Val Loss: {:.3f}".format(np.mean(val_acc)))
test_data = test_x.reshape((-1, timesteps, num_input))
test_norm = utl.minmax_norm(test_data)
test_label = test_y
print(
"Testing Loss:",
sess.run(loss_op,
feed_dict={
X_: test_norm,
Y_: test_label[:, None],
lr: learning_rate
}))
# Model Checkpoint
saver.save(sess, ckpt_dir)
def test(net, config, logger, test_loader, test_info, step, model_file=None):
with torch.no_grad():
net.eval()
if model_file is not None:
net.load_state_dict(torch.load(model_file))
final_res = {}
final_res['version'] = 'VERSION 1.3'
final_res['results'] = {}
final_res['external_data'] = {
'used': True,
'details': 'Features from I3D Network'
}
num_correct = 0.
num_total = 0.
load_iter = iter(test_loader)
for i in range(len(test_loader.dataset)):
# _data: 视频特征 _label : 视频标签 vid_name: 视频名称 vid_num_seg:视频特征序列实际长度
_data, _label, _, vid_name, vid_num_seg = next(load_iter)
_data = _data.cuda()
_label = _label.cuda()
"""
cas_base: (1,T,21)
score_supp: (1,21)
cas_supp: (1,T,21)
fore_weights: (1,T,1)
"""
_, cas_base, score_supp, cas_supp, fore_weights = net(_data)
label_np = _label.cpu().numpy()
score_np = score_supp[
0, :-1].cpu().data.numpy() #获取动作类的得分，不考虑背景类 (1,20)
score_np[np.where(
score_np < config.class_thresh)] = 0 # cls_thresh = 0.25
score_np[np.where(score_np >= config.class_thresh)] = 1
correct_pred = np.sum(
label_np == score_np,
axis=1) # 统计的是预测的类别和label能够对应上的数目，只有20个类别全部预测正确才认为这个视频预测正确
num_correct += np.sum((correct_pred == config.num_classes).astype(
np.float32)) # 预测正确的视频数1
num_total += correct_pred.shape[0] # 视频数
# 对数值进行限定，更加稳定
cas_base = utils.minmax_norm(cas_base) # (B,T,C+1)
cas_supp = utils.minmax_norm(cas_supp) # (B,T,C+1)
pred = np.where(
score_np > config.class_thresh)[0] # 0.25， 当前视频预测动作类别索引
if pred.any():
cas_pred = cas_supp[0].cpu().numpy()[:, pred] # (T, C+1)-->T
cas_pred = np.reshape(cas_pred,
(config.num_segments, -1, 1)) # (T,1,1)
# [[[-0.035]],[[-0.025]],.....[[0.0029]]] (18000,1,1)
cas_pred = utils.upgrade_resolution(cas_pred,
config.scale) # scale:24
proposal_dict = {}
for i in range(len(config.act_thresh)
): #act_thresh = np.arange(0.0, 0.25, 0.025)
cas_temp = cas_pred.copy() # (18000,1,1)
# [0,1,2,3,1531,1532,.......9910]
zero_location = np.where(
cas_temp[:, :, 0] < config.act_thresh[i])
cas_temp[zero_location] = 0
# cas_temp: (18000,len(pred),1) 其中len(pred)为满足条件的类别数目
seg_list = [
] # [[],[],..[]] # 保存每个类别的预测结果,其中每一个子列表中保存对应类别着pos的索引
for c in range(len(pred)):
pos = np.where(
cas_temp[:, c, 0] > 0) # [4,5,6,.....17999]
seg_list.append(pos)
# [[[5,0.0025,169.42,169.6]]] ：(class, score, start, end)
proposals = utils.get_proposal_oic(seg_list, cas_temp, score_np, pred, config.scale, \
vid_num_seg[0].cpu().item(), config.feature_fps, config.num_segments)
for i in range(len(proposals)):
class_id = proposals[i][0][0]
if class_id not in proposal_dict.keys():
proposal_dict[class_id] = []
proposal_dict[class_id] += proposals[i]
final_proposals = []
for class_id in proposal_dict.keys():
final_proposals.append(
utils.nms(proposal_dict[class_id], 0.7))
final_res['results'][vid_name[0]] = utils.result2json(
final_proposals)
test_acc = num_correct / num_total
json_path = os.path.join(config.output_path, 'temp_result.json')
with open(json_path, 'w') as f:
json.dump(final_res, f)
f.close()
tIoU_thresh = np.linspace(0.1, 0.9, 9)
anet_detection = ANETdetection(config.gt_path,
json_path,
subset='test',
tiou_thresholds=tIoU_thresh,
verbose=False,
check_status=False)
mAP, average_mAP = anet_detection.evaluate()
logger.log_value('Test accuracy', test_acc, step)
for i in range(tIoU_thresh.shape[0]):
logger.log_value('mAP@{:.1f}'.format(tIoU_thresh[i]), mAP[i], step)
logger.log_value('Average mAP', average_mAP, step)
test_info["step"].append(step)
test_info["test_acc"].append(test_acc)
test_info["average_mAP"].append(average_mAP)
for i in range(tIoU_thresh.shape[0]):
test_info["mAP@{:.1f}".format(tIoU_thresh[i])].append(mAP[i])
def test(net, config, logger, test_loader, test_info, step, model_file=None):
with torch.no_grad():
net.eval()
if model_file is not None:
net.load_state_dict(torch.load(model_file))
final_res = {}
final_res['version'] = 'VERSION 1.3'
final_res['results'] = {}
final_res['external_data'] = {
'used': True,
'details': 'Features from I3D Network'
}
num_correct = 0.
num_total = 0.
load_iter = iter(test_loader)
for i in range(len(test_loader.dataset)):
_data, _label, _, vid_name, vid_num_seg = next(load_iter)
_data = _data.cuda()
_label = _label.cuda()
vid_num_seg = vid_num_seg[0].cpu().item()
num_segments = _data.shape[1]
score_act, _, feat_act, feat_bkg, features, cas_softmax = net(
_data)
feat_magnitudes_act = torch.mean(torch.norm(feat_act, dim=2),
dim=1)
feat_magnitudes_bkg = torch.mean(torch.norm(feat_bkg, dim=2),
dim=1)
label_np = _label.cpu().data.numpy()
score_np = score_act[0].cpu().data.numpy()
pred_np = np.zeros_like(score_np)
pred_np[np.where(score_np < config.class_thresh)] = 0
pred_np[np.where(score_np >= config.class_thresh)] = 1
correct_pred = np.sum(label_np == pred_np, axis=1)
num_correct += np.sum(
(correct_pred == config.num_classes).astype(np.float32))
num_total += correct_pred.shape[0]
feat_magnitudes = torch.norm(features, p=2, dim=2)
feat_magnitudes = utils.minmax_norm(feat_magnitudes,
max_val=feat_magnitudes_act,
min_val=feat_magnitudes_bkg)
feat_magnitudes = feat_magnitudes.repeat(
(config.num_classes, 1, 1)).permute(1, 2, 0)
cas = utils.minmax_norm(cas_softmax * feat_magnitudes)
pred = np.where(score_np >= config.class_thresh)[0]
if len(pred) == 0:
pred = np.array([np.argmax(score_np)])
cas_pred = cas[0].cpu().numpy()[:, pred]
cas_pred = np.reshape(cas_pred, (num_segments, -1, 1))
cas_pred = utils.upgrade_resolution(cas_pred, config.scale)
proposal_dict = {}
feat_magnitudes_np = feat_magnitudes[0].cpu().data.numpy()[:, pred]
feat_magnitudes_np = np.reshape(feat_magnitudes_np,
(num_segments, -1, 1))
feat_magnitudes_np = utils.upgrade_resolution(
feat_magnitudes_np, config.scale)
for i in range(len(config.act_thresh_cas)):
cas_temp = cas_pred.copy()
zero_location = np.where(
cas_temp[:, :, 0] < config.act_thresh_cas[i])
cas_temp[zero_location] = 0
seg_list = []
for c in range(len(pred)):
pos = np.where(cas_temp[:, c, 0] > 0)
seg_list.append(pos)
proposals = utils.get_proposal_oic(seg_list, cas_temp, score_np, pred, config.scale, \
vid_num_seg, config.feature_fps, num_segments)
for i in range(len(proposals)):
class_id = proposals[i][0][0]
if class_id not in proposal_dict.keys():
proposal_dict[class_id] = []
proposal_dict[class_id] += proposals[i]
for i in range(len(config.act_thresh_magnitudes)):
cas_temp = cas_pred.copy()
feat_magnitudes_np_temp = feat_magnitudes_np.copy()
zero_location = np.where(feat_magnitudes_np_temp[:, :, 0] <
config.act_thresh_magnitudes[i])
feat_magnitudes_np_temp[zero_location] = 0
seg_list = []
for c in range(len(pred)):
pos = np.where(feat_magnitudes_np_temp[:, c, 0] > 0)
seg_list.append(pos)
proposals = utils.get_proposal_oic(seg_list, cas_temp, score_np, pred, config.scale, \
vid_num_seg, config.feature_fps, num_segments)
for i in range(len(proposals)):
class_id = proposals[i][0][0]
if class_id not in proposal_dict.keys():
proposal_dict[class_id] = []
proposal_dict[class_id] += proposals[i]
final_proposals = []
for class_id in proposal_dict.keys():
final_proposals.append(utils.nms(proposal_dict[class_id], 0.6))
final_res['results'][vid_name[0]] = utils.result2json(
final_proposals)
test_acc = num_correct / num_total
json_path = os.path.join(config.output_path, 'result.json')
with open(json_path, 'w') as f:
json.dump(final_res, f)
f.close()
tIoU_thresh = np.linspace(0.1, 0.7, 7)
anet_detection = ANETdetection(config.gt_path,
json_path,
subset='test',
tiou_thresholds=tIoU_thresh,
verbose=False,
check_status=False)
mAP, average_mAP = anet_detection.evaluate()
logger.log_value('Test accuracy', test_acc, step)
for i in range(tIoU_thresh.shape[0]):
logger.log_value('mAP@{:.1f}'.format(tIoU_thresh[i]), mAP[i], step)
logger.log_value('Average mAP', average_mAP, step)
test_info["step"].append(step)
test_info["test_acc"].append(test_acc)
test_info["average_mAP"].append(average_mAP)
for i in range(tIoU_thresh.shape[0]):
test_info["mAP@{:.1f}".format(tIoU_thresh[i])].append(mAP[i])
def main():
if (len(sys.argv) <= 1):
print("infer.py -h or --help to get guideline of input options")
exit()
use = "Usage: %prog [options] filename"
parser = OptionParser(usage = use)
parser.add_option("-d", "--input-dir", dest="input_dir", action="store", type="string", help="input data dir")
parser.add_option("-t", "--timesteps", dest="timesteps", action="store", type="int", help="timesteps")
parser.add_option("-n", "--num-input", dest="num_input", action="store", type="int", help="number of input (input vector's width)")
parser.add_option("-c", "--ckpt-dir", dest="ckpt_dir", action="store", type="string", help="directory of checkpoint")
(options, args) = parser.parse_args()
input_dir = options.input_dir
timesteps = options.timesteps
num_input = options.num_input
#ckpt_dir = options.ckpt_dir
X = np.fromfile(input_dir + '/X.dat', dtype=float)
cardinality = int(X.shape[0]/(timesteps * num_input))
X = X.reshape([cardinality, timesteps, num_input])
Y = np.fromfile(input_dir + '/Y.dat', dtype=float)
train_x, val_x, test_x, train_y, val_y, test_y = utl.train_val_test_split(X, Y, split_frac=0.80)
# Training Parameters
learning_rate = 0.001
epochs =800
batch_size = 40
#display_step = 200
# Network Parameters
#num_input = 2
#timesteps = 480
num_hidden = 2048
num_classes = 1
print("### Network Parameters ###")
print("Learning Rate: {}".format(learning_rate))
print("Batch Size: {}".format(batch_size))
print("Size of Hidden Layer: {}".format(num_hidden))
print("Timestep: {}".format(timesteps))
print("------------------")
X_ = tf.placeholder("float", [None, timesteps, num_input])
Y_ = tf.placeholder("float", [None, num_classes])
lr = tf.placeholder("float")
weights = {
'out':tf.Variable(tf.random_normal([num_hidden,num_classes])),
}
biases = {
'out':tf.Variable(tf.random_normal([num_classes]))
}
prediction = RNN(X_, weights, biases, timesteps, num_hidden)
loss_op = tf.losses.mean_squared_error(Y_, prediction)
#optimizer = tf.train.AdadeltaOptimizer(lr).minimize(loss_op)
#optimizer = tf.train.AdamOptimizer(lr).minimize(loss_op)
optimizer = tf.train.GradientDescentOptimizer(lr).minimize(loss_op)
correct_pred = tf.equal(tf.cast( (prediction/1.8) - tf.round(prediction/1.8), tf.float32), tf.cast( (prediction/1.8)-tf.round(Y_/1.8), tf.float32))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
# Restore the ckpt
SAVER_DIR = options.ckpt_dir
saver = tf.train.Saver()
checkpoint_path = os.path.join(SAVER_DIR, SAVER_DIR)
ckpt = tf.train.get_checkpoint_state(SAVER_DIR)
init = tf.global_variables_initializer()
with tf.Session() as sess:
#new_saver = tf.train.import_meta_graph('ckpt.meta')
saver.restore(sess, ckpt.model_checkpoint_path)
test_norm = utl.minmax_norm(test_x)
print("loss test: %f" % loss_op.eval(feed_dict = {X_:test_norm, Y_:test_y[:, None]}))
X_norm = utl.minmax_norm(X)
pred = np.array(prediction.eval(feed_dict = {X_:X_norm, Y_:Y[:, None]}))
pred_diagnosis = [1 if x[0]>=1.8 else 0 for x in list(pred)]
y_diagnosis = [1 if x>=1.8 else 0 for x in list(Y)]
evaluation = np.equal(pred_diagnosis, y_diagnosis)
print(np.mean(evaluation))
f = open(SAVER_DIR + '/result.txt', 'w')
for i in range(0, len(Y)):
f.write(str(pred[i][0]) + ', ' + str(Y[i])+'\n')
f2 = open(SAVER_DIR + '/result_diagnosis.txt', 'w')
for i in range(0, len(Y)):
f2.write(str(pred_diagnosis[i]) + ', ' + str(y_diagnosis[i])+'\n')
f2.close()
f.close()
output_volume = None
for file in dataset.get_patient_samples(patient_id):
sample = dataset.load_file(file)
patient_id = sample['patient_id']
n_slice = sample['n_slice']
image = sample['image'].unsqueeze(0)
label = sample['label'].unsqueeze(0)
with torch.no_grad():
lat = encoder(image)
qlat, l_lat, ids = vq(lat)
logit = decoder(qlat)
image = image.detach().cpu()[0, 1, ...]
image = minmax_norm(image)
label = label.detach().cpu()[0, ...]
output = logit.argmax(dim=1).detach().cpu()[0, ...]
label_volume = concat(label_volume, label)
output_volume = concat(output_volume, output)
dice_result = calc_dice(label_volume, output_volume,
index_to_class_name)
dice_result.update({
'patient_id': patient_id,
})
result_summary['patient_id'].append(dice_result['patient_id'])
result_summary['Background'].append(dice_result['Background'])
result_summary['NET'].append(dice_result['NET'])
from torch import nn, Tensor
from datetime import datetime
torch.set_default_tensor_type('torch.DoubleTensor')
batch = 16
test_size = 1000
ss, N, d = 3200, 10, 2
n_dist = int(N * (N - 1) / 2)
test_data = dataSource.generate_rand_DM(N,
sample_size=test_size,
isInt=True,
sample_space=(1000, 1))
test_data = utils.minmax_norm(test_data, dmin=0)[0]
def test(helper, test_data):
rs, target = helper._predict(test_data)
loss = helper.lossFun(rs, target)
return loss
def train(helper, dlr, logFilePath):
EPOCH = 100
print("Training ", helper.id)
def add_noise_to_dm(x):
noise = torch.randn(x.size()) * torch.mean(x) * 0.5
x = x + torch.abs(noise)
return utils.minmax_norm(x, dmin=0)[0]
def reload_custom(self, dist_func, n_arg):
self.test_data = dataSource.custom_distance(
self.N, n_arg, self.test_size, isInt=True, sample_space=(1000, 1), dist_func=dist_func)
self.test_data = utils.minmax_norm(self.test_data, dmin=0)[0]
def reload_rand(self):
self.test_data = dataSource.generate_rand_DM(
self.N, self.test_size, isInt=True, sample_space=(1000, 1))
self.test_data = utils.minmax_norm(self.test_data, dmin=0)[0]
R = R - numpy.tile(numpy.mean(R, axis=1), (N, 1)).T
_, vects = linalg.eigh(R.dot(R.T))
return vects[:, ::-1].T.dot(R).T
#%%
import torch
import utils
if __name__ == "__main__":
torch.set_default_tensor_type('torch.DoubleTensor')
pts = torch.tensor([[0, 2], [2, 5], [6, 8], [8, 7], [9, 10]])
dm = utils.get_distanceSq_matrix(pts)[0]**0.5
dm = utils.minmax_norm(dm)[0]
print(dm)
dm = numpy.array(dm)
rs = landmarkMDS(dm, 5, 2)
rs = torch.tensor(rs)
rs_dm = utils.get_distanceSq_matrix(rs)[0]**0.5
rs_dm = utils.minmax_norm(rs_dm)[0]
print(rs_dm)
print(torch.sum(((rs_dm - torch.tensor(dm))**2)))
# %%
from torch import nn
from mds.cmds import classicalMDS
from lossFunction import CoordsToDMLoss
torch.set_default_tensor_type('torch.DoubleTensor')
dist_func = lambda p1, p2: torch.sum(torch.abs((p2 - p1)))
cus = custom_distance(10,
3,
1000,
isInt=True,
sample_space=(1000, 1),
dist_func=dist_func)
lossFun = CoordsToDMLoss(N=10, d=2, lossFun=nn.L1Loss(reduction='mean'))
coords, dms = cus
dms = utils.minmax_norm(dms, dmin=0)[0] + 1e-8
dms = dms.detach().requires_grad_(True)
cmds_rs = []
for d in dms:
d1 = numpy.array(d.data)
cmds_rs.append(torch.tensor(classicalMDS(d1, 2)))
cmds_rs = torch.stack(cmds_rs)
print("cmds_loss: \t", lossFun(cmds_rs, dms))
def forward(self, rs, target):
rs = utils.minmax_norm(rs, dmin=0)[0]
target = utils.minmax_norm(target, dmin=0)[0]
return self.lossFun(rs, target)
