def do_detect(model, img, conf_thresh, nms_thresh, use_cuda=1):
model.eval()
t0 = time.time()
if type(img) == np.ndarray and len(img.shape) == 3: # cv2 image
img = torch.from_numpy(img.transpose(
2, 0, 1)).float().div(255.0).unsqueeze(0)
elif type(img) == np.ndarray and len(img.shape) == 4:
img = torch.from_numpy(img.transpose(0, 3, 1, 2)).float().div(255.0)
else:
print("unknow image type")
exit(-1)
if use_cuda:
img = img.cuda()
img = torch.autograd.Variable(img)
t1 = time.time()
output = model(img)
t2 = time.time()
print('-----------------------------------')
print(' Preprocess : %f' % (t1 - t0))
print(' Model Inference : %f' % (t2 - t1))
print('-----------------------------------')
out0 = output[0].cpu().detach().numpy()
out1 = output[1].cpu().detach().numpy()
output = [out0, out1]
return utils.post_processing(conf_thresh, nms_thresh, out0, out1)
def main():
aug = get_aug([
A.HorizontalFlip(p=.5),
A.RandomSizedBBoxSafeCrop(width=448,
height=448,
erosion_rate=0,
interpolation=cv2.INTER_CUBIC),
A.RGBShift(p=.5),
A.Blur(blur_limit=5, p=0.5),
A.RandomBrightnessContrast(p=0.5),
A.CLAHE(p=0.5),
])
voc = VOCDataset(cfg.DATASET_PATH,
classes_list=cfg.CLASSES,
image_set='train',
transforms=aug)
for i in range(1000):
image, out = voc[i]
boxes = post_processing(out)
im_size = image.shape[0]
for det in boxes:
pt1 = (det[0] - det[2] / 2, det[1] - det[3] / 2)
pt2 = (det[0] + det[2] / 2, det[1] + det[3] / 2)
pt1 = (int(pt1[0] * im_size), int(pt1[1] * im_size))
pt2 = (int(pt2[0] * im_size), int(pt2[1] * im_size))
cv2.rectangle(image, pt1, pt2, (255, 33, 44))
image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
cv2.imshow("test", image)
cv2.waitKeyEx(-1)
def create_dataset():
"""read the config file"""
with open("/root/config.json", "r") as f:
config = json.load(f)
# create environmental variables
for (key, value) in config.items():
os.environ[key] = str(value)
# run blender
command = '/usr/lib/blender/blender {} --python {} --background'.\
format("/root/models/default.blend", "/root/rendering.py")
os.system(command)
# post processing
post_processing()
def train(self, epoch, trainloader, print_every=100):
'''
method for training
'''
self.model.train()
loss_batch = 0
if epoch % 100 == 0 and epoch > 0:
self.adjust_lr(step=0.1)
TP, FP, FN, TN = 0, 0, 0, 0
for b_idx, (train_data, train_labels, actual_centers) in enumerate(trainloader):
if self.use_gpu:
train_data = train_data.cuda(non_blocking=True)
train_labels = train_labels.cuda()
output = self.model(train_data)
loss = self.loss(output, train_labels)
if self.l2:
loss = self.l2_regularization(loss, self.l2)
self.optimizer.zero_grad()
loss.backward()
self.optimizer.step()
output = output.cpu().detach().squeeze()
if len(output.shape)<3:
output = output.unsqueeze(0)
_, predicted_centers, maps_area = post_processing(output.numpy(), self.threshold)
TP_t, FP_t, TN_t, FN_t = tp_fp_tn_fn_alt(actual_centers, predicted_centers, maps_area, self.min_radius)
TP += TP_t
FP += FP_t
FN += FN_t
TN += TN_t
if b_idx % opt.print_every == 0:
print('Train Epoch: {0} [{1}/{2} ({3:.0f}%)]\t Loss {4}'.
format(epoch, b_idx * len(train_data),
len(trainloader.dataset),
100. * b_idx / len(trainloader), loss))
loss_ = loss.item()
self.iter_loss_train.append(loss_)
loss_batch += loss_
FDR_train, RC_train, accuracy_train = performance_metric(TP, FP, FN, TN)
self.fdr_train.append(FDR_train)
self.accuracy_train.append(accuracy_train)
self.RC_train.append(RC_train)
loss_batch /= len(trainloader)
print('Epoch = {} Train TP {} FP {} TN {} FN {} '.format(epoch, TP, FP, TN, FN))
print('Train loss = {0} FDR = {1:.4f} , RC {2:.4f} =, accuracy = {3:.4f}'.format(loss_batch, FDR_train, RC_train, accuracy_train))
self.train_loss.append(loss_batch)
def do_detect(model, img, conf_thresh, n_classes, nms_thresh, use_cuda=1):
model.eval()
t0 = time.time()
if isinstance(img, Image.Image):
width = img.width
height = img.height
img = torch.ByteTensor(torch.ByteStorage.from_buffer(img.tobytes()))
img = img.view(height, width,
3).transpose(0, 1).transpose(0, 2).contiguous()
img = img.view(1, 3, height, width)
img = img.float().div(255.0)
elif type(img) == np.ndarray and len(img.shape) == 3: # cv2 image
img = torch.from_numpy(img.transpose(
2, 0, 1)).float().div(255.0).unsqueeze(0)
elif type(img) == np.ndarray and len(img.shape) == 4:
img = torch.from_numpy(img.transpose(0, 3, 1, 2)).float().div(255.0)
else:
print("unknow image type")
exit(-1)
if use_cuda:
img = img.cuda()
img = torch.autograd.Variable(img)
t1 = time.time()
boxes_and_confs = model(img)
# print(boxes_and_confs)
output = []
for i in range(len(boxes_and_confs)):
output.append([])
output[-1].append(boxes_and_confs[i][0].cpu().detach().numpy())
output[-1].append(boxes_and_confs[i][1].cpu().detach().numpy())
output[-1].append(boxes_and_confs[i][2].cpu().detach().numpy())
t2 = time.time()
print('-----------------------------------')
print(' Preprocess : %f' % (t1 - t0))
print(' Model Inference : %f' % (t2 - t1))
print('-----------------------------------')
'''
for i in range(len(boxes_and_confs)):
output.append(boxes_and_confs[i].cpu().detach().numpy())
'''
return utils.post_processing(img, conf_thresh, n_classes, nms_thresh,
output)
def testing(net, test_loader, device):
net.eval()
predict = []
for idx, sample in enumerate(test_loader):
data = torch.Tensor(sample['data'])
data_lens = sample['data_lens']
vocal_pitch = sample['vocal_pitch']
_range = sample['range']
data_length = list(data.shape)[0]
data = data.to(device, dtype=torch.float)
output = net(data)
answer = post_processing(output, vocal_pitch, _range)
predict.extend(answer)
print(len(predict))
return predict
def predict_with_model(self, model_name):
model = load_model('../Models/' + model_name,
custom_objects={
'binary_crossentropy_valid':
binary_crossentropy_valid
})
test = self.dataset.test.copy()
if len(test.shape) == 3:
test = np.expand_dims(test, -1)
predict = model.predict(test)
predict = predict[:, :, :, 0]
out = []
for i in range(predict.shape[0]):
pred = square_to_original(predict[i, ],
self.dataset.test_shape[i, ])
out.append(post_processing(pred))
return out
def real_time_lrp(conf):
"""Method to display feature relevance scores in real time.
Args:
conf: Dictionary consisting of configuration parameters.
"""
record_video = conf["playback"]["record_video"]
webcam = Webcam()
lrp = RelevancePropagation(conf)
if record_video:
recorder = VideoRecorder(conf)
while True:
t0 = time.time()
frame = webcam.get_frame()
heatmap = lrp.run(frame)
heatmap = post_processing(frame, heatmap, conf)
cv2.imshow("LRP", heatmap)
if record_video:
recorder.record(heatmap)
t1 = time.time()
fps = 1.0 / (t1 - t0)
print("{:.1f} FPS".format(fps))
if cv2.waitKey(1) % 256 == 27:
print("Escape pressed.")
break
if record_video:
recorder.release()
webcam.turn_off()
cv2.destroyAllWindows()
def test(self, epoch, testloader):
'''
method for testing
'''
self.model.eval()
TP, FP, FN, TN = 0, 0, 0, 0
with torch.no_grad():
batch_loss = 0
for test_data, test_labels, actual_centers in testloader:
if self.use_gpu:
test_data, test_labels = test_data.cuda(), test_labels.cuda()
output = self.model(test_data)
loss_ = self.loss(output, test_labels)
output = output.cpu().squeeze()
if len(output.shape)<3:
output = output.unsqueeze(0)
_, predicted_centers, maps_area = post_processing(output.numpy(), self.threshold)
TP_test, FP_test, TN_test, FN_test = tp_fp_tn_fn_alt(actual_centers, predicted_centers, maps_area, self.min_radius)
TP += TP_test
FP += FP_test
FN += FN_test
TN += TN_test
self.iter_loss_test.append(loss_)
batch_loss += loss_
batch_loss /= len(testloader)
FDR_test, RC_test, accuracy_test = performance_metric(TP, FP, FN, TN)
self.fdr_test.append(FDR_test)
self.accuracy_test.append(accuracy_test)
self.RC_test.append(RC_test)
print('epoch {} Test TP {} FP {} TN {} FN {}'.format(epoch, TP, FP, TN, FN))
print('Test loss = {0} FDR = {1:.4f} , RC {2:.4f} =, accuracy = {3:.4f}'.format(batch_loss, FDR_test, RC_test, accuracy_test))
self.test_loss.append(batch_loss)
test_net.train()
if count>=steps:
return
plt.show()
plt.imshow(utils.get_numpy_image_to_plot(style_img_tensor.cpu().detach().numpy())[0])
train(0,100)
# Model saving,reloading
#torch.save(test_net.state_dict(), "saved_model")
# the_model = TheModelClass(*args, **kwargs)
# the_model.load_state_dict(torch.load(PATH))
#for testing
for x, _ in test_train_loader:
test_new_content = x.to(device)
break
img_output = test_net(test_new_content)
plt.imshow(utils.get_numpy_image_to_plot(test_new_content.cpu().detach().numpy())[0])
plt.imshow(utils.get_numpy_image_to_plot(img_output.cpu().detach().numpy())[0])
history = utils.post_processing()
'Model Comparison of Decoding Probability of Success_RT_features.png'),
dpi=500,
bbox_inches='tight')
id_vars = [
'model',
'score',
'sub',
'window',
]
value_vars = [
'RT_correct',
'RT_awareness',
'RT_confidence',
]
df_post = post_processing(df, id_vars, value_vars)
c = df_post.groupby(['Subjects', 'Models', 'Window',
'Attributes']).mean().reset_index()
g = sns.catplot(x='Window',
y='Values',
hue='Attributes',
hue_order=value_vars,
row='Models',
row_order=['DecisionTreeClassifier', 'LogisticRegression'],
data=c,
aspect=3,
sharey=False,
dodge=0.1,
kind='point')
(g.set_axis_labels(
'Trials look back', ''
config.direction,
config.cell_type,
str(config.layers))
config.model_dir = join(config.output_dir, config.model_name)
if not exists(config.output_dir):
mkdir(config.output_dir)
if not exists(config.model_dir):
mkdir(config.model_dir)
model = RNN_Model(config)
if config.testing:
test_ids, test_data, _ = load_timit(config, data_set='test')
test_ids = np.expand_dims(test_ids, 1)
predictions = model.test(test_data)
predictions = np.expand_dims(
post_processing(config, predictions, threshold=2), 1)
outputs = np.append(test_ids, predictions, axis=1)
df = pd.DataFrame(outputs).to_csv(join(
config.model_dir, '{}.csv'.format(config.model_name)),
index=False,
header=['id', 'phone_sequence'])
else:
train_ids, train_data, train_labels = load_timit(config,
data_set='train')
model.train(train_data, train_labels)
def main(args):
# Device Configuration #
device = torch.device(
f'cuda:{args.gpu_num}' if torch.cuda.is_available() else 'cpu')
# Fix Seed for Reproducibility #
random.seed(args.seed)
np.random.seed(args.seed)
torch.manual_seed(args.seed)
torch.cuda.manual_seed(args.seed)
# Samples, Plots, Weights and CSV Path #
paths = [
args.samples_path, args.weights_path, args.csv_path,
args.inference_path
]
for path in paths:
make_dirs(path)
# Prepare Data #
data = pd.read_csv(args.data_path)[args.column]
# Prepare Data #
scaler_1 = StandardScaler()
scaler_2 = StandardScaler()
preprocessed_data = pre_processing(data, scaler_1, scaler_2, args.constant,
args.delta)
train_X, train_Y, test_X, test_Y = prepare_data(data, preprocessed_data,
args)
train_X = moving_windows(train_X, args.ts_dim)
train_Y = moving_windows(train_Y, args.ts_dim)
test_X = moving_windows(test_X, args.ts_dim)
test_Y = moving_windows(test_Y, args.ts_dim)
# Prepare Networks #
if args.model == 'conv':
D = ConvDiscriminator(args.ts_dim).to(device)
G = ConvGenerator(args.latent_dim, args.ts_dim).to(device)
elif args.model == 'lstm':
D = LSTMDiscriminator(args.ts_dim).to(device)
G = LSTMGenerator(args.latent_dim, args.ts_dim).to(device)
else:
raise NotImplementedError
#########
# Train #
#########
if args.mode == 'train':
# Loss Function #
if args.criterion == 'l2':
criterion = nn.MSELoss()
elif args.criterion == 'wgangp':
pass
else:
raise NotImplementedError
# Optimizers #
if args.optim == 'sgd':
D_optim = torch.optim.SGD(D.parameters(), lr=args.lr, momentum=0.9)
G_optim = torch.optim.SGD(G.parameters(), lr=args.lr, momentum=0.9)
elif args.optim == 'adam':
D_optim = torch.optim.Adam(D.parameters(),
lr=args.lr,
betas=(0., 0.9))
G_optim = torch.optim.Adam(G.parameters(),
lr=args.lr,
betas=(0., 0.9))
else:
raise NotImplementedError
D_optim_scheduler = get_lr_scheduler(D_optim, args)
G_optim_scheduler = get_lr_scheduler(G_optim, args)
# Lists #
D_losses, G_losses = list(), list()
# Train #
print(
"Training Time Series GAN started with total epoch of {}.".format(
args.num_epochs))
for epoch in range(args.num_epochs):
# Initialize Optimizers #
G_optim.zero_grad()
D_optim.zero_grad()
#######################
# Train Discriminator #
#######################
if args.criterion == 'l2':
n_critics = 1
elif args.criterion == 'wgangp':
n_critics = 5
for j in range(n_critics):
series, start_dates = get_samples(train_X, train_Y,
args.batch_size)
# Data Preparation #
series = series.to(device)
noise = torch.randn(args.batch_size, 1,
args.latent_dim).to(device)
# Adversarial Loss using Real Image #
prob_real = D(series.float())
if args.criterion == 'l2':
real_labels = torch.ones(prob_real.size()).to(device)
D_real_loss = criterion(prob_real, real_labels)
elif args.criterion == 'wgangp':
D_real_loss = -torch.mean(prob_real)
# Adversarial Loss using Fake Image #
fake_series = G(noise)
prob_fake = D(fake_series.detach())
if args.criterion == 'l2':
fake_labels = torch.zeros(prob_fake.size()).to(device)
D_fake_loss = criterion(prob_fake, fake_labels)
elif args.criterion == 'wgangp':
D_fake_loss = torch.mean(prob_fake)
D_gp_loss = args.lambda_gp * get_gradient_penalty(
D, series.float(), fake_series.float(), device)
# Calculate Total Discriminator Loss #
D_loss = D_fake_loss + D_real_loss
if args.criterion == 'wgangp':
D_loss += args.lambda_gp * D_gp_loss
# Back Propagation and Update #
D_loss.backward()
D_optim.step()
###################
# Train Generator #
###################
# Adversarial Loss #
fake_series = G(noise)
prob_fake = D(fake_series)
# Calculate Total Generator Loss #
if args.criterion == 'l2':
real_labels = torch.ones(prob_fake.size()).to(device)
G_loss = criterion(prob_fake, real_labels)
elif args.criterion == 'wgangp':
G_loss = -torch.mean(prob_fake)
# Back Propagation and Update #
G_loss.backward()
G_optim.step()
# Add items to Lists #
D_losses.append(D_loss.item())
G_losses.append(G_loss.item())
# Adjust Learning Rate #
D_optim_scheduler.step()
G_optim_scheduler.step()
# Print Statistics, Save Model Weights and Series #
if (epoch + 1) % args.log_every == 0:
# Print Statistics and Save Model #
print("Epochs [{}/{}] | D Loss {:.4f} | G Loss {:.4f}".format(
epoch + 1, args.num_epochs, np.average(D_losses),
np.average(G_losses)))
torch.save(
G.state_dict(),
os.path.join(
args.weights_path,
'TS_using{}_and_{}_Epoch_{}.pkl'.format(
G.__class__.__name__, args.criterion.upper(),
epoch + 1)))
# Generate Samples and Save Plots and CSVs #
series, fake_series = generate_fake_samples(
test_X, test_Y, G, scaler_1, scaler_2, args, device)
plot_series(series, fake_series, G, epoch, args,
args.samples_path)
make_csv(series, fake_series, G, epoch, args, args.csv_path)
########
# Test #
########
elif args.mode == 'test':
# Load Model Weights #
G.load_state_dict(
torch.load(
os.path.join(
args.weights_path, 'TS_using{}_and_{}_Epoch_{}.pkl'.format(
G.__class__.__name__, args.criterion.upper(),
args.num_epochs))))
# Lists #
real, fake = list(), list()
# Inference #
for idx in range(0, test_X.shape[0], args.ts_dim):
# Do not plot if the remaining data is less than time dimension #
end_ix = idx + args.ts_dim
if end_ix > len(test_X) - 1:
break
# Prepare Data #
test_data = test_X[idx, :]
test_data = np.expand_dims(test_data, axis=0)
test_data = np.expand_dims(test_data, axis=1)
test_data = torch.from_numpy(test_data).to(device)
start = test_Y[idx, 0]
noise = torch.randn(args.val_batch_size, 1,
args.latent_dim).to(device)
# Generate Fake Data #
with torch.no_grad():
fake_series = G(noise)
# Convert to Numpy format for Saving #
test_data = np.squeeze(test_data.cpu().data.numpy())
fake_series = np.squeeze(fake_series.cpu().data.numpy())
test_data = post_processing(test_data, start, scaler_1, scaler_2,
args.delta)
fake_series = post_processing(fake_series, start, scaler_1,
scaler_2, args.delta)
real += test_data.tolist()
fake += fake_series.tolist()
# Plot, Save to CSV file and Derive Metrics #
plot_series(real, fake, G, args.num_epochs - 1, args,
args.inference_path)
make_csv(real, fake, G, args.num_epochs - 1, args, args.inference_path)
derive_metrics(real, fake, args)
else:
raise NotImplementedError
def do_training(on_net, off_net, train_loader, val_loader, device):
num_epoch = 60
criterion_set = nn.BCELoss()
#criterion_pitch = nn.SmoothL1Loss()
#criterion_pitch = nn.CrossEntropyLoss()
train_loss = 0.0
total_length = 0
best_f1 = 0
best_val_loss = 100
optimizer = optim.AdamW(list(on_net.parameters()) +
list(off_net.parameters()),
lr=2e-3)
scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer,
'max',
factor=0.5,
patience=4)
for epoch in range(num_epoch):
total_length = 0.0
start_time = time.time()
train_loss = 0.0
total_onset_loss = 0.0
total_offset_loss = 0.0
COn = 0
COnP = 0
COnPOff = 0
weighted_f1 = 0
count = 0
for param_group in optimizer.param_groups:
print("lr: {}".format(param_group['lr']))
on_net.train()
off_net.train()
for batch_idx, sample in enumerate(train_loader):
# print(len(sample['label']))
# print(sample['label'][0].shape)
# print(sample['label'][1].shape)
data = sample['data']
target = sample['label']
data_lens = sample['data_lens']
vocal_pitch = sample['vocal_pitch']
_range = sample['range']
data_length = list(data.shape)[0]
data = data.to(device, dtype=torch.float)
target = target.to(device, dtype=torch.float)
optimizer.zero_grad()
on_output = on_net(data)
off_output = off_net(data)
on_loss = criterion_set(
on_output, torch.narrow(target, dim=2, start=0, length=1))
off_loss = criterion_set(
off_output, torch.narrow(target, dim=2, start=1, length=1))
#loss = criterion_set(output, torch.narrow(target, dim= 2, start= 0, length= 2))
loss = on_loss + off_loss
loss.backward()
optimizer.step()
train_loss += loss.item()
total_length = total_length + 1
output = torch.cat([on_output, off_output], dim=2)
if epoch >= 10:
gt = np.array(sample['groundtruth'])
predict = post_processing(output, vocal_pitch, _range)
#predict = np.array(predict)
for i in range(len(predict)):
count += 1
tmp_predict = np.where(
np.array(predict[i]) > 0, np.array(predict[i]), 0.0001)
if tmp_predict.shape[0] == 0:
continue
score = mir_eval.transcription.evaluate(
gt[i][:, :2], gt[i][:, 2], tmp_predict[:, :2],
tmp_predict[:, 2])
COn = COn + score['Onset_F-measure']
COnP = COnP + score['F-measure_no_offset']
COnPOff = COnPOff + score['F-measure']
weighted_f1 = COn * 0.2 + COnP * 0.6 + COnPOff * 0.2
# if batch_idx % 50 == 0:
# print ("epoch %d, sample %d, loss %.6f" %(epoch, batch_idx, total_loss))
print('epoch %d, total loss: %.6f, training time: %.3f sec' %
(epoch, train_loss / total_length, time.time() - start_time))
if epoch >= 10:
print(
"epoch %d, COn %.6f, COnP %.6f, COnPOff %.6f, Training weighted_f1 %.6f"
% (epoch, COn / count, COnP / count, COnPOff / count,
weighted_f1 / count))
# evaluate
if epoch >= 10:
val_total_loss = 0
COn = 0
COnP = 0
COnPOff = 0
weighted_f1 = 0
count = 0
on_net.eval()
off_net.eval()
for idx, sample in enumerate(val_loader):
data = torch.Tensor(sample['data'])
target = torch.Tensor(sample['label'])
data_lens = sample['data_lens']
vocal_pitch = sample['vocal_pitch']
_range = sample['range']
data_length = list(data.shape)[0]
data = data.to(device, dtype=torch.float)
target = target.to(device, dtype=torch.float)
on_output = on_net(data)
off_output = off_net(data)
on_loss = criterion_set(
on_output, torch.narrow(target, dim=2, start=0, length=1))
off_loss = criterion_set(
off_output, torch.narrow(target, dim=2, start=1, length=1))
set_loss = on_loss + off_loss
val_total_loss += set_loss.item()
output = torch.cat([on_output, off_output], dim=2)
predict = post_processing(output, vocal_pitch, _range)
gt = np.array(sample['groundtruth'])
#predict = np.array(predict)
for i in range(len(predict)):
count += 1
tmp_predict = np.where(
np.array(predict[i]) > 0, np.array(predict[i]), 0.0001)
if tmp_predict.shape[0] == 0:
continue
score = mir_eval.transcription.evaluate(
gt[i][:, :2], gt[i][:, 2], tmp_predict[:, :2],
tmp_predict[:, 2])
COn = COn + score['Onset_F-measure']
COnP = COnP + score['F-measure_no_offset']
COnPOff = COnPOff + score['F-measure']
weighted_f1 = COn * 0.2 + COnP * 0.6 + COnPOff * 0.2
scheduler.step(weighted_f1)
if weighted_f1 > best_f1:
best_f1 = weighted_f1
#model_path= f'ST_{epoch}.pt'
torch.save(on_net.state_dict(), './onset_model.pkl')
torch.save(off_net.state_dict(), './offset_model.pkl')
if epoch >= 10:
print('epoch %d, total val loss: %.6f ' %
(epoch, val_total_loss / total_length))
print(
"epoch %d, COn %.6f, COnP %.6f, COnPOff %.6f, Validation weighted_f1 %.6f"
% (epoch, COn / count, COnP / count, COnPOff / count,
weighted_f1 / count))
return net
def generate_timeseries(args):
# Device Configuration #
device = torch.device(
f'cuda:{args.gpu_num}' if torch.cuda.is_available() else 'cpu')
# Inference Path #
make_dirs(args.inference_path)
# Prepare Generator #
if args.model == 'skip':
G = SkipGenerator(args.latent_dim, args.ts_dim,
args.conditional_dim).to(device)
G.load_state_dict(
torch.load(
os.path.join(
args.weights_path,
'TimeSeries_Generator_using{}_Epoch_{}.pkl'.format(
args.criterion.upper(), args.num_epochs))))
else:
raise NotImplementedError
# Prepare Data #
data = pd.read_csv(args.data_path)[args.column]
scaler_1 = StandardScaler()
scaler_2 = StandardScaler()
preprocessed_data = pre_processing(data, scaler_1, scaler_2, args.delta)
X = moving_windows(preprocessed_data, args.ts_dim)
label = moving_windows(data.to_numpy(), args.ts_dim)
# Lists #
real, fake = list(), list()
# Inference #
for idx in range(0, data.shape[0], args.ts_dim):
end_ix = idx + args.ts_dim
if end_ix > len(data) - 1:
break
samples = X[idx, :]
samples = np.expand_dims(samples, axis=0)
samples = np.expand_dims(samples, axis=1)
samples = torch.from_numpy(samples).to(device)
start_dates = label[idx, 0]
noise = torch.randn(args.val_batch_size, 1, args.latent_dim).to(device)
with torch.no_grad():
fake_series = G(noise)
fake_series = torch.cat((samples[:, :, :args.conditional_dim].float(),
fake_series.float()),
dim=2)
samples = np.squeeze(samples.cpu().data.numpy())
fake_series = np.squeeze(fake_series.cpu().data.numpy())
samples = post_processing(samples, start_dates, scaler_1, scaler_2,
args.delta)
fake_series = post_processing(fake_series, start_dates, scaler_1,
scaler_2, args.delta)
real += samples.tolist()
fake += fake_series.tolist()
plot_sample(real, fake, args.num_epochs - 1, args)
make_csv(real, fake, args.num_epochs - 1, args)
#g = sns.catplot( x = 'window',
# y = 'score',
# hue = 'model',
# data = df,
# aspect = 3,
# kind = 'point',
# hue_order = ['DecisionTreeClassifier','LogisticRegression'],
# ci = 95)
(g.set_axis_labels(
'Trials look back', 'Clasifi.Score (AUC ROC)').fig.suptitle(
'Model Comparison of Decoding Probability of Success'))
g.fig.savefig(os.path.join(
saving_dir, 'Model Comparison of Decoding Probability of Success.png'),
dpi=500,
bbox_inches='tight')
df_post = post_processing(df)
g = sns.factorplot(
x='Window',
y='Values',
hue='Attributes',
row='Models',
row_order=['DecisionTreeClassifier', 'LogisticRegression'],
data=df_post,
aspect=3,
sharey=False,
dodge=0.1)
# for seaborn 0.9.0
#g = sns.catplot( x = 'window',
# y = 'value',
# hue = 'Attributions',
# row = 'model',
pos = pd.read_csv('../results/Pos_3_1_features.csv')
att = pd.read_csv('../results/ATT_3_1_features.csv')
# pos
df = pos.copy()
id_vars = [
'model',
'score',
'sub',
'window',
]
value_vars = [
'correct',
'awareness',
'confidence',
]
df_post = post_processing(df[(df['window'] > 0) & (df['window'] < 5)],
id_vars, value_vars)
c = df_post.groupby(['Subjects', 'Models', 'Window',
'Attributes']).mean().reset_index()
# interaction
level_window = pd.unique(c['Window'])
level_attribute = pd.unique(c['Attributes'])
unique_levels = []
for w in level_window:
for a in level_attribute:
unique_levels.append([w, a])
results = []
for model_name, df_sub in c.groupby(['Models']):
# main effect of window
factor = 'Window'
result = posthoc_multiple_comparison_scipy(
df_sub,
help="the image to predict (default: %(default)s)")
parser.add_argument("--weight", required=True, metavar="/path/to/yolov4.weights", help="the path of weight file")
parser.add_argument("--save-img", metavar="predicted-img", help="the path to save predicted image")
args = parser.parse_args()
return args
if __name__ == "__main__":
args = parse_args()
img: Image.Image = Image.open(args.img_file)
img = img.resize((608, 608))
# C*H*W
img_data = to_image(img)
net = Darknet(img_data.size(0))
net.load_weights(args.weight)
net.eval()
with torch.no_grad():
boxes, confs = net(img_data.unsqueeze(0))
idxes_pred, boxes_pred, probs_pred = utils.post_processing(boxes, confs, 0.4, 0.6)
utils.plot_box(boxes_pred, args.img_file, args.save_img)
vgg.build(noise_img)
noise_layers_list = dict({0: vgg.conv1_1, 1: vgg.conv1_2, 2: vgg.pool1,
3: vgg.conv2_1, 4: vgg.conv2_2, 5: vgg.pool2,
6: vgg.conv3_1, 7: vgg.conv3_2, 8: vgg.conv3_3, 9: vgg.pool3,
10: vgg.conv4_1, 11: vgg.conv4_2, 12: vgg.conv4_3, 13: vgg.pool4,
14: vgg.conv5_1, 15: vgg.conv5_2, 16: vgg.conv5_3, 17: vgg.pool5})
# we define the same weight for each layer
m = [(0, 1), (1, 1), (2, 1), (3, 1), (4, 1), (5, 1),(6, 1), (7, 1), (8, 1), (9, 1), (10, 1), (11, 1), (12, 1),
(13, 1)]
# m = [(0, 1), (1, 1), (2, 1), (3, 1), (4, 1), (5, 1), (6, 1), (7, 1), (8, 1), (9, 1), (10, 1), (11, 1), (12, 1),
# (13, 1), (14, 1), (15, 1), (16, 1), (17, 1)]
loss = loss_function(m, feature_map, noise_layers_list)
optimizer = tf.train.AdamOptimizer().minimize(loss)
epochs = 10000
# init_image = keras.backend.eval(noise_img)
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
init_image = sess.run(noise_img)
for i in range(epochs):
_, s_loss = sess.run([optimizer, loss])
if (i+1)%100 == 0:
print("Epoch:{} / {}".format(i+1, epochs), "Loss:", s_loss)
final_noise = sess.run(noise_img)
init_noise = utils.post_processing(init_image, output_img, save_file=False)
final_image = utils.post_processing(final_noise, output_img, save_file=True)
