def test():
# learnin curve
train_loss = np.array([i["train_loss"] for i in net1.train_history_])
valid_loss = np.array([i["valid_loss"] for i in net1.train_history_])
pyplot.plot(train_loss, linewidth=3, label="train")
pyplot.plot(valid_loss, linewidth=3, label="valid")
pyplot.grid()
pyplot.legend()
pyplot.xlabel("epoch")
pyplot.ylabel("loss")
pyplot.ylim(1e-3, 1e-2)
pyplot.yscale("log")
pyplot.show()
# plot samples
X, _ = load(isTrain=False)
y_pred = net1.predict(X)
fig = pyplot.figure(figsize=(6, 6))
fig.subplots_adjust(
left=0, right=1, bottom=0, top=1, hspace=0.05, wspace=0.05)
for i in range(16):
ax = fig.add_subplot(4, 4, i + 1, xticks=[], yticks=[])
plot_sample(X[i], y_pred[i], ax)
pyplot.show()
for data in face_dataset_test:
resized_input = data['image'].reshape(-1, 1, 96, 96)
_tensor = torch.from_numpy(resized_input)
outputs = run_subsets(_tensor,
settings=utils.SETTINGS,
load_from_file=True)
this_output = outputs.numpy()
numpy_out = this_output[0] * 48 + 48
numpy_out = numpy_out.clip(0, 96)
output_list.append(numpy_out)
if plot_index < 16:
ax = fig.add_subplot(4, 4, plot_index + 1, xticks=[], yticks=[])
with torch.no_grad():
plot_sample(data['image'], (outputs).reshape(30, 1), ax)
plot_index = plot_index + 1
#plt.show()
columns = ()
for cols in utils.SPECIALIST_SETTINGS:
columns += cols['columns']
print columns.index('mouth_left_corner_x')
#df = DataFrame(numpy_out, columns=columns)
lookup_table = read_csv(utils.FLOOKUP)
values = []
for index, row in lookup_table.iterrows():
values.append((
row['RowId'],
D_real = discriminator(X)
D_fake = discriminator(G, reuse=True)
return G, D_real, D_fake
# Define constants
NUM_EPOCHS = 100
BATCH_SIZE = 128
LEARNING_RATE = 0.0002
BETA1 = 0.5
NOISE_DIM = 100
SAMPLE_SIZE = 100
# Load mnist data
X_train = utils.load_mnist_data()
utils.plot_sample(X_train[:SAMPLE_SIZE], "output/mnist_data.png")
X_train = utils.preprocess_images(X_train)
mini_batches = utils.random_mini_batches(X_train, BATCH_SIZE)
# Create DCGAN
X = tf.placeholder(tf.float32, shape=(None, X_train.shape[1], X_train.shape[2], X_train.shape[3]))
Z = tf.placeholder(tf.float32, [None, NOISE_DIM])
G, D_real, D_fake = create_gan(X, Z)
# Create training steps
G_loss_func, D_loss_func = utils.create_loss_funcs(D_real, D_fake)
G_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope="Generator")
D_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope="Discriminator")
G_train_step = tf.train.AdamOptimizer(learning_rate=LEARNING_RATE, beta1=BETA1).minimize(G_loss_func, var_list=G_vars)
D_train_step = tf.train.AdamOptimizer(learning_rate=LEARNING_RATE, beta1=BETA1).minimize(D_loss_func, var_list=D_vars)
def train(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.plots_path, args.weights_path, args.csv_path
]
for path in paths:
make_dirs(path)
# Prepare Data #
data = pd.read_csv(args.data_path)[args.column]
# Pre-processing #
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)
# Prepare Networks #
D = Discriminator(args.ts_dim).to(device)
G = Generator(args.latent_dim, args.ts_dim,
args.conditional_dim).to(device)
# Loss Function #
if args.criterion == 'l2':
criterion = nn.MSELoss()
elif args.criterion == 'wgangp':
pass
else:
raise NotImplementedError
# Optimizers #
D_optim = torch.optim.Adam(D.parameters(), lr=args.lr, betas=(0.5, 0.9))
G_optim = torch.optim.Adam(G.parameters(), lr=args.lr, betas=(0.5, 0.9))
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()
if args.criterion == 'l2':
n_critics = 1
elif args.criterion == 'wgangp':
n_critics = 5
#######################
# Train Discriminator #
#######################
for j in range(n_critics):
series, start_dates = get_samples(X, label, 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)
fake_series = torch.cat(
(series[:, :, :args.conditional_dim].float(),
fake_series.float()),
dim=2)
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)
fake_series = torch.cat(
(series[:, :, :args.conditional_dim].float(), fake_series.float()),
dim=2)
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())
####################
# Print Statistics #
####################
print("Epochs [{}/{}] | D Loss {:.4f} | G Loss {:.4f}".format(
epoch + 1, args.num_epochs, np.average(D_losses),
np.average(G_losses)))
# Adjust Learning Rate #
D_optim_scheduler.step()
G_optim_scheduler.step()
# Save Model Weights and Series #
if (epoch + 1) % args.save_every == 0:
torch.save(
G.state_dict(),
os.path.join(
args.weights_path,
'TimeSeries_Generator_using{}_Epoch_{}.pkl'.format(
args.criterion.upper(), epoch + 1)))
series, fake_series = generate_fake_samples(
X, label, G, scaler_1, scaler_2, args, device)
plot_sample(series, fake_series, epoch, args)
make_csv(series, fake_series, epoch, args)
print("Training finished.")
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)
im_height = 512
im_width = 512
input_img = Input((im_height, im_width, 1), name='img')
model = unet(input_img, n_filters=32, dropout=0.5, batchnorm=True)
model.compile(optimizer=Adam(), loss=dice_coef_loss, metrics=[dice_coef])
callbacks = [
ReduceLROnPlateau(factor=0.1, patience=5, min_lr=0.0001, verbose=1),
ModelCheckpoint('UNet256.h5', verbose=1, save_best_only=True, save_weights_only=True)
]
results = model.fit(X_train, y_train, batch_size=32, epochs=100, callbacks=callbacks, validation_data=(X_valid, y_valid))
# Model evaluations
# load the best model
model.load_weights('UNet256.h5')
# Evaluate on train set
model.evaluate(X_train, y_train, verbose=1)
# Evaluate on validation set
model.evaluate(X_valid, y_valid, verbose=1)
# Predict on train, val
preds_train = model.predict(X_train, verbose=1)
preds_val = model.predict(X_valid, verbose=1)
# Threshold predictions
preds_train_t = (preds_train > 0.5).astype(np.uint8)
preds_val_t = (preds_val > 0.5).astype(np.uint8)
# Randomly visualize the predictions & corresponding dice coefficient
plot_sample(X_train, y_train, preds_train, preds_train_t)
plot_sample(X_valid, y_valid, preds_val, preds_val_t)
from model import resolve_single
from model.edsr import edsr
from utils import load_image, plot_sample
model = edsr(scale=4, num_res_blocks=16)
model.load_weights('weights/edsr-16-x4/weights.h5')
lr = load_image('demo/frame-1214_frame_blend')
sr = resolve_single(model, lr)
plot_sample(lr, sr)
# ava_dataset.labels.to_csv(AVA_LABEL_CLEANED_FILEPATH)
# # training, validation and test sets
# labels_train, labels_val, labels_test = train_val_test_split(
# dataset=ava_dataset.labels, val_ratio=VAL_RATIO, test_ratio=TEST_RATIO
# )
# labels_train.to_csv(AVA_TRAIN_LABEL_FILEPATH)
# labels_val.to_csv(AVA_VAL_LABEL_FILEPATH)
# labels_test.to_csv(AVA_TEST_LABEL_FILEPATH)
ava_dataset.labels = AVA_LABEL_CLEANED_FILEPATH
ava_dataset.image_root = AVA_IMAGE_ROOT
print("-" * 20)
print("AVA dataset labels:")
print("-" * 20)
print(ava_dataset.labels.sample(10))
print(ava_dataset.labels.describe())
# samples
for idx in range(len(ava_dataset)):
print(idx)
sample = ava_dataset[idx]
plot_sample(sample=sample)
if idx == 3:
break
#%%
def run(arg):
torch.manual_seed(7)
np.random.seed(7)
print("lr %f, epoch_num %d, decay_rate %f gamma %f" % (arg.lr, arg.epochs, arg.decay, arg.gamma))
print("====>Loading data")
if arg.dataset == 'mnist':
train_data = get_mnist_dataset("train", arg.batch_size)
G_output_dim = config.mnist_G_output_dim
D_input_dim = config.mnist_D_input_dim
elif arg.dataset == 'cifar':
train_data = get_cifar_dataset("train", arg.batch_size)
G_output_dim = config.cifar_G_output_dim
D_input_dim = config.cifar_D_input_dim
print("====>Building model")
if arg.net == "DCGAN":
g_net = DC_Generator(config.G_input_dim, config.num_filters, G_output_dim, verbose=False)
d_net = DC_Discriminator(D_input_dim, config.num_filters[::-1], config.D_output_dim, verbose=False)
# g_net = Generator()
# d_net = Discriminator()
g_net = g_net.to(config.device)
d_net = d_net.to(config.device)
g_optimizer = optim.Adam(g_net.parameters(), lr=arg.lr, betas=(0.5, 0.9))
d_optimizer = optim.Adam(d_net.parameters(), lr=arg.lr, betas=(0.5, 0.9))
if arg.mul_gpu:
g_net = nn.DataParallel(g_net)
d_net = nn.DataParallel(d_net)
if arg.checkpoint is not None:
print("load pre train model")
g_pretrained_dict = torch.load(os.path.join(config.checkpoint_path, arg.dataset + "_" +
arg.net + "_g_net_" + arg.checkpoint + '.pth'))
d_pretrained_dict = torch.load(os.path.join(config.checkpoint_path, arg.dataset + "_" +
arg.net + "_d_net_" + arg.checkpoint + '.pth'))
g_net = load_weight(g_pretrained_dict, g_net)
d_net = load_weight(d_pretrained_dict, d_net)
# 日志系统
logger = get_logger()
criterion = nn.BCELoss()
print('Total params: %.2fM' % ((sum(p.numel() for p in g_net.parameters()) +
sum(p.numel() for p in d_net.parameters())) / 1000000.0))
print("start training: ", datetime.now())
start_epoch = 0
fix_noise = torch.autograd.Variable(torch.randn(config.nrow ** 2, config.G_input_dim).view(-1, config.G_input_dim,
1, 1).cuda())
g_losses = []
d_losses = []
for epoch in range(start_epoch, arg.epochs):
prev_time = datetime.now()
g_loss, d_loss = train(train_data, g_net, d_net, criterion, g_optimizer, d_optimizer, epoch, logger)
now_time = datetime.now()
time_str = count_time(prev_time, now_time)
print("train: current (%d/%d) batch g_loss is %f d_loss is %f time "
"is %s" % (epoch, arg.epochs, g_loss, d_loss, time_str))
g_losses.append(g_loss)
d_losses.append(d_loss)
plot_loss(d_losses, g_losses, epoch, arg.net, arg.dataset)
plot_sample(g_net, fix_noise, epoch, net_name=arg.net, dataset_name=arg.dataset)
if epoch % 2 == 0:
save_checkpoint(arg.dataset, arg.net, epoch, g_net, d_net)
save_checkpoint(arg.dataset, arg.net, arg.epochs, g_net, d_net)
def eval_model(self, device, model, eval_loader, save_folder, save_images,
is_validation, plot_seg):
model.eval()
dsize = self.cfg.INPUT_WIDTH, self.cfg.INPUT_HEIGHT
res = []
predictions, ground_truths = [], []
for data_point in eval_loader:
image, seg_mask, seg_loss_mask, _, sample_name = data_point
image, seg_mask = image.to(device), seg_mask.to(device)
is_pos = (seg_mask.max() > 0).reshape((1, 1)).to(device).item()
prediction, pred_seg = model(image)
pred_seg = nn.Sigmoid()(pred_seg)
prediction = nn.Sigmoid()(prediction)
prediction = prediction.item()
image = image.detach().cpu().numpy()
pred_seg = pred_seg.detach().cpu().numpy()
seg_mask = seg_mask.detach().cpu().numpy()
predictions.append(prediction)
ground_truths.append(is_pos)
res.append((prediction, None, None, is_pos, sample_name[0]))
if not is_validation:
if save_images:
image = cv2.resize(
np.transpose(image[0, :, :, :], (1, 2, 0)), dsize)
image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
pred_seg = cv2.resize(pred_seg[0, 0, :, :], dsize) if len(
pred_seg.shape) == 4 else cv2.resize(
pred_seg[0, :, :], dsize)
seg_mask = cv2.resize(seg_mask[0, 0, :, :], dsize)
if self.cfg.WEIGHTED_SEG_LOSS:
seg_loss_mask = cv2.resize(
seg_loss_mask.numpy()[0, 0, :, :], dsize)
utils.plot_sample(sample_name[0],
image,
pred_seg,
seg_loss_mask,
save_folder,
decision=prediction,
plot_seg=plot_seg)
else:
utils.plot_sample(sample_name[0],
image,
pred_seg,
seg_mask,
save_folder,
decision=prediction,
plot_seg=plot_seg)
if is_validation:
metrics = utils.get_metrics(np.array(ground_truths),
np.array(predictions))
FP, FN, TP, TN = list(
map(sum, [
metrics["FP"], metrics["FN"], metrics["TP"], metrics["TN"]
]))
self._log(
f"VALIDATION || AUC={metrics['AUC']:f}, and AP={metrics['AP']:f}, with best thr={metrics['best_thr']:f} "
f"at f-measure={metrics['best_f_measure']:.3f} and FP={FP:d}, FN={FN:d}, TOTAL SAMPLES={FP + FN + TP + TN:d}"
)
return metrics["AP"], metrics["accuracy"]
else:
utils.evaluate_metrics(res, self.run_path, self.run_name)
st.subheader("Try it")
upload = st.file_uploader("Upload an iamge", type=["png", "jpg", "jpeg"])
if upload == None:
st.write("Please upload the file")
else:
st.write("")
st.write("")
if st.button("Submit"):
with st.spinner("Upscaling image..."):
model = generator()
model.load_weights('weights/srgan/weights_final.h5')
lr = load_image(upload)
sr = resolve_single(model, lr)
st.subheader("Comparison")
st.pyplot(plot_sample(lr, sr))
sp = int(sr.shape[0]*sr.shape[1])
lp = int(lr.shape[0]*lr.shape[1])
st.write("Original Image: ",lp,"pixels")
st.write("Upscaled Image: ",sp,"pixels")
st.text("")
st.write("Designed and Developed by **Tarun Venkatesh H**")
hide_streamlit_style = """
<style>
#MainMenu {visibility: hidden;}
footer {visibility: hidden;}
</style>
"""
st.markdown(hide_streamlit_style, unsafe_allow_html=True)
X, _ = load2d(ftestf, test=True)
y_pred = net.predict(X)
# try to display the estimated landmarks on images
paths = loadCSV(ftestf)
fileNames = extract_fileNames(paths)
for i in range(len(y_pred)):
predi = y_pred[i]
#filename = FSAVEFOLDER + FNAMES[i]
write_file(flandmarks, predi)
#write_file(filename,"\n")
saveImg = FSAVEIMAGES + fileNames[i]
fig = pyplot.figure()
ax = fig.add_subplot(1, 1, 1, xticks=[], yticks=[])
plot_sample(X[i], predi, ax)
fig.savefig(saveImg)
pyplot.close(fig)
print('Finish!')
'''
# plot the landmarks on the images
fig = pyplot.figure(figsize=(4, 4))
fig.subplots_adjust(
left=0, right=1, bottom=0, top=1, hspace=0.05, wspace=0.05)
for i in range(16):
ax = fig.add_subplot(4, 4, i + 1, xticks=[], yticks=[])
plot_sample(X[i], y_pred[i], ax)
pyplot.show()
def resolve_and_plot(lr_image_path):
lr = load_image(lr_image_path)
#plot_sample_no_treatment(lr)
sr = resolve_single(model,lr)
plot_sample(lr,sr)
X1,y1 = load2d(FTRAINF,test=False)
#=================================================================
# Load the parameters into list of layer, create a new network and train
newlayers = set_weights(FMODEL)
net2 = build_fine_tuning_model(newlayers)
net2.fit(X1,y1)
# Save the fine-tuning model
sys.setrecursionlimit(150000)
with open('/data3/linhlv/2018/saveModels/cnnmodel_all_10000_pronotum_fine_tune_v19.pickle','wb') as f:
pickle.dump(net2,f,-1)
# draw the loss
draw_loss(net2)
# test the fine-tuning network and draw the results
X, _ = load2d(FTESTF,test=True)
y_pred = net2.predict(X)
fig = pyplot.figure(figsize=(4, 4))
fig.subplots_adjust(
left=0, right=1, bottom=0, top=1, hspace=0.05, wspace=0.05)
for i in range(16):
ax = fig.add_subplot(4, 4, i + 1, xticks=[], yticks=[])
plot_sample(X[i], y_pred[i], ax)
pyplot.show()
# plot samples
X, _ = load(isTrain=False)
y_pred = net1.predict(X)
fig = pyplot.figure(figsize=(6, 6))
fig.subplots_adjust(
left=0, right=1, bottom=0, top=1, hspace=0.05, wspace=0.05)
for i in range(16):
ax = fig.add_subplot(4, 4, i + 1, xticks=[], yticks=[])
plot_sample(X[i], y_pred[i], ax)
pyplot.show()
if __name__ == '__main__':
X, y = load()
print("X.shape == {}; X.min == {:.3f}; X.max == {:.3f}".format(
X.shape, X.min(), X.max()))
print("y.shape == {}; y.min == {:.3f}; y.max == {:.3f}".format(
y.shape, y.min(), y.max()))
net1.fit(X, y)
test()
plot_sample()
