def client():
import json
with open("../src/config/settings.json", "r") as f:
settings = json.load(f)
load_model(settings)
app = activate_endpoint(settings)
app.config["TESTING"] = True
with app.test_client() as client:
yield client
def test_predict(client):
main.load_model() ## load model for predicting ##
response = client.post('/results',
json={
'sepal_length': 1,
'sepal_width': 1,
'petal_length': 1,
'petal_width': 1
})
assert response.json == '1'
def parseCommon(sentence, model_dir_new, dset_dir, gpu, model_dir, data, model,
seg):
if "common" == model_dir:
data.generate_instance_with_gaz(sentence, 'sentence')
decode_results = main.parse_text(model, data, 'raw', gpu, seg)
result = data.write_decoded_results_back(decode_results, 'raw')
result_output = js.dumps(result)
else:
model_dir = "common"
haveDset = os.path.exists("/app/data/CommonNER/common.dset")
haveModel = os.path.exists("/app/data/CommonNER/common.35.model")
if haveDset and haveModel:
dset_dir = "/app/data/CommonNER/common.dset"
one_model_dir = "/app/data/CommonNER/common.35.model"
#初始化
data = main.load_data_setting(dset_dir)
model = main.load_model(one_model_dir, data, gpu)
#处理sentence
data.generate_instance_with_gaz(sentence, 'sentence')
decode_results = main.parse_text(model, data, 'raw', gpu, seg)
result = data.write_decoded_results_back(decode_results, 'raw')
result_output = js.dumps(result)
else:
print "have not predefine model"
return model_dir, dset_dir, data, model, result_output
def get_models(self, num=2, epochs=[-1, -1], cpu=False):
assert num == len(epochs)
N = num
weights, params = [], []
model_files = glob.glob(os.path.join(self.models_dir, '*'))
random.shuffle(model_files)
for i, f in enumerate(model_files):
if not N:
break
name = f.split('/')[1]
ord_files = sorted(glob.glob(os.path.join(f, '*')),
key=lambda x: int(x.split('_')[-1][:-3]))
if i >= len(epochs):
break
network, network_params = [], []
#for j, epoch_W in enumerate(ord_files):
for j, epoch_W in enumerate([ord_files[epochs[i]]]):
self.model_files.append(epoch_W)
layers, layer_keys, model_dict = [], [], {}
model_dict['model'], loss, correct, total = load_model(
epoch_W, cpu)
network_params.append([loss, correct, total])
if self.pytorch_model:
model = model_dict['model']
network.append(model)
layer_keys = model.keys()
else:
for key in model_dict['model']:
if 'num_batches_tracked' not in key:
layer_keys.append(key)
layers.append(model_dict['model'][key])
network.append(layers)
params.append(network_params)
weights.append(network)
return weights, params, layer_keys
def run(args, gpu_id=None, return_model=False, return_time_series=False):
random.seed(args.seed)
torch.manual_seed(args.seed)
torch.cuda.manual_seed(args.seed)
np.random.seed(args.seed)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
running_device = "cpu" if gpu_id is None \
else torch.device('cuda:{}'.format(gpu_id) if torch.cuda.is_available() else 'cpu')
best_val_perf = 0.
test_perf_at_best_val = 0.
best_test_perf = 0.
best_test_perf_at_best_val = 0.
link_test_perf_at_best_val = 0.
val_loss_deque = deque(maxlen=args.early_stop_queue_length)
val_perf_deque = deque(maxlen=args.early_stop_queue_length)
dataset_kwargs = {}
if args.dataset_class == "ENSPlanetoid":
dataset_kwargs["neg_sample_ratio"] = args.neg_sample_ratio
if args.dataset_name == "ogbn-arxiv":
dataset_kwargs["to_undirected"] = args.to_undirected
if args.dataset_name == "ogbn-products":
dataset_kwargs["size"] = args.data_sampling_size
dataset_kwargs["num_hops"] = args.data_sampling_num_hops
dataset_kwargs["shuffle"] = True
_data_attr = get_dataset_or_loader(
args.dataset_class,
args.dataset_name,
args.data_root,
batch_size=args.batch_size,
seed=args.seed,
**dataset_kwargs,
)
if _data_attr[-1] is None:
train_d, val_d, test_d = _data_attr
loader = None
dataset_or_loader = train_d
eval_dataset_or_loader = None
else:
train_d, train_loader, eval_loader = _data_attr
val_d, test_d = None, None
dataset_or_loader = (train_d, train_loader)
eval_dataset_or_loader = (train_d, eval_loader)
net_cls = _get_model_cls(args.model_name)
net = net_cls(args, train_d)
net = net.to(running_device)
loaded = load_model(net, args, target_epoch=None)
if loaded is not None:
net, other_state_dict = loaded
best_val_perf = other_state_dict["perf"]
args.start_epoch = other_state_dict["epoch"]
loss_func = eval(str(args.loss)) or nn.CrossEntropyLoss(
) # nn.BCEWithLogitsLoss(), nn.CrossEntropyLoss()
adam_optim = optim.Adam(net.parameters(),
lr=args.lr,
weight_decay=args.l2_lambda)
evaluator = Evaluator(name=args.dataset_name)
ret = {}
val_perf_list, test_perf_list, val_loss_list = [], [], []
perf_task_for_val = getattr(args, "perf_task_for_val", "Node")
for current_iter, epoch in enumerate(
tqdm(range(args.start_epoch, args.start_epoch + args.epochs))):
train_loss = train_model(running_device,
net,
dataset_or_loader,
loss_func,
adam_optim,
epoch=epoch,
_args=args)
if args.verbose >= 2 and epoch % args.val_interval == 0:
print("\n\t- Train loss: {}".format(train_loss))
# Validation.
if epoch % args.val_interval == 0:
val_perf, val_loss, test_perf, test_loss = test_model(
running_device,
net,
eval_dataset_or_loader or dataset_or_loader,
loss_func,
evaluator=evaluator,
_args=args,
val_or_test="val",
verbose=args.verbose,
run_link_prediction=(perf_task_for_val == "Link"),
)
garbage_collection_cuda()
if args.save_plot:
val_perf_list.append(val_perf)
test_perf_list.append(test_perf)
val_loss_list.append(val_loss.item())
if test_perf > best_test_perf:
best_test_perf = test_perf
if val_perf >= best_val_perf:
print_color = "yellow"
best_val_perf = val_perf
test_perf_at_best_val = test_perf
if test_perf_at_best_val > best_test_perf_at_best_val:
best_test_perf_at_best_val = test_perf_at_best_val
if args.task_type == "Link_Prediction":
link_test_perf, _ = test_model(running_device,
net,
test_d or train_d,
loss_func,
_args=args,
val_or_test="test",
verbose=0,
run_link_prediction=True)
link_test_perf_at_best_val = link_test_perf
if args.save_model:
save_model(net, args, target_epoch=epoch, perf=val_perf)
else:
print_color = None
ret = {
"best_val_perf": best_val_perf,
"test_perf_at_best_val": test_perf_at_best_val,
"best_test_perf": best_test_perf,
"best_test_perf_at_best_val": best_test_perf_at_best_val,
}
if args.verbose >= 1:
cprint_multi_lines("\t- ", print_color, **ret)
# Check early stop condition
if args.use_early_stop and current_iter > args.early_stop_patience:
recent_val_loss_mean = float(np.mean(val_loss_deque))
val_loss_change = abs(recent_val_loss_mean -
val_loss) / recent_val_loss_mean
recent_val_perf_mean = float(np.mean(val_perf_deque))
val_perf_change = abs(recent_val_perf_mean -
val_perf) / recent_val_perf_mean
if (val_loss_change < args.early_stop_threshold_loss) or \
(val_perf_change < args.early_stop_threshold_perf):
if args.verbose >= 1:
cprint("Early Stopped at epoch {}".format(epoch),
"red")
cprint(
"\t- val_loss_change is {} (thres: {}) | {} -> {}".
format(
round(val_loss_change, 6),
round(args.early_stop_threshold_loss, 6),
recent_val_loss_mean,
val_loss,
), "red")
cprint(
"\t- val_perf_change is {} (thres: {}) | {} -> {}".
format(
round(val_perf_change, 6),
round(args.early_stop_threshold_perf, 6),
recent_val_perf_mean,
val_perf,
), "red")
break
val_loss_deque.append(val_loss)
val_perf_deque.append(val_perf)
if args.task_type == "Link_Prediction":
ret = {"link_test_perf_at_best_val": link_test_perf_at_best_val, **ret}
if args.save_plot:
save_loss_and_perf_plot([val_loss_list, val_perf_list, test_perf_list],
ret,
args,
columns=["val_loss", "val_perf", "test_perf"])
if return_model:
return net, ret
if return_time_series:
return {
"val_loss_list": val_loss_list,
"val_perf_list": val_perf_list,
"test_perf_list": test_perf_list,
**ret
}
return ret
f = st.file_uploader('', type, key='12')
btn = st.button('Run')
if not btn:
st.stop()
fg = tempfile.NamedTemporaryFile(delete=False)
fg.write(f.read())
fg.close()
else:
text = 'webcam'
if text == 'video':
bg = cv.imread(bg.name)
bg = cv.cvtColor(bg, cv.COLOR_BGR2RGB)
coef = main.load_model()
vf = cv.VideoCapture(fg.name)
stframe = st.empty()
while vf.isOpened():
ret, frame = vf.read()
# if frame is read correctly ret is True
if not ret:
print("Can't receive frame (stream end?). Exiting ...")
break
frame = cv.cvtColor(frame, cv.COLOR_BGR2RGB)
processed_frame = main.remove_green(frame, coef, bg)
stframe.image(processed_frame, width=682)
elif text == 'webcam':
from main import load_model
from evaluate import evaluate_image
from detection import box, display, detection_table
parameters = struct(model=param('',
required=True,
help="model checkpoint to use for detection"),
input=param('', required=True, help="input image"),
threshold=param(0.5, "detection threshold"))
args = parse_args(parameters, "image evaluation",
"image evaluation parameters")
device = torch.cuda.current_device()
model, encoder, model_args = load_model(args.model)
print("model parameters:")
pprint_struct(model_args)
classes = model_args.dataset.classes
model.to(device)
encoder.to(device)
frame = cv.imread_color(args.input)
nms_params = detection_table.nms_defaults._extend(nms=args.threshold)
pprint_struct(nms_params)
detections = evaluate_image(model,
frame,
import os
import torchvision.utils as vutils
from PIL import Image
import main
opt = main.get_app_arguments()
valid_ext = ['.jpg', '.png']
if not os.path.exists(opt.output_dir):
os.mkdir(opt.output_dir)
# load pretrained model
model = main.load_model()
for files in os.listdir(opt.input_dir):
ext = os.path.splitext(files)[1]
if ext not in valid_ext:
continue
# load image
input_image = Image.open(os.path.join(opt.input_dir, files)).convert("RGB")
output_image = main.process_image(input_image)
# save
vutils.save_image(
output_image,
os.path.join(opt.output_dir, files[:-4] + '_' + opt.style + '.jpg'))
print('Done!')
def process_image(img_base64_str):
img = base64_cv2(img_base64_str)
height, width, _ = img.shape
scale = 0
if height > width:
scale = height / 512
else:
scale = width / 512
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img = img.astype(np.float32) / 255.
img = cv2.resize(img, (512, 512))
new_image = np.zeros((512, 512, 3))
new_image[0:512, 0:512] = img
new_image = torch.from_numpy(new_image)
new_image = new_image.permute(2, 0, 1).float().unsqueeze(dim=0)
return new_image, scale
if __name__ == "__main__":
global_var.model = main.load_model("../checkpoint/efficientdet.pt", False)
img_base64_str = img_base64('../images/shape_test/36001.jpg')
img = process_image(img_base64_str)
with torch.no_grad():
boxes = global_var.model(img)
if boxes.shape[0] > 0:
for box_id in range(boxes.shape[0]):
xmin, ymin, xmax, ymax = boxes[box_id, :]
print(boxes.size())
plt.imshow(prediction[i])
plt.clim(0, 1)
plt.colorbar()
plt.title(CLASS_ORDER[i])
plt.tight_layout()
return fig
if __name__ == '__main__':
from main import load_model
import torch
import torch.nn.functional as F
from dataprep import GLOBHEDataset, ToTensor
model, device = load_model('unet_2019-09-29_1251.pth')
with torch.no_grad():
train_dataset = GLOBHEDataset('data', 'train')
sample = train_dataset[8]
sample = ToTensor()(sample)
mask = sample['bitmap'].cpu().numpy()
image_tensor = sample['image'].to(device).unsqueeze(0)
out_bitmap, out_percentages = model(image_tensor)
output_soft = F.softmax(out_bitmap, dim=1)
draw_class_bitmaps(mask,
output_soft.detach().numpy()[0],
sample['image'].detach().numpy())
def main():
netconfig, _, _ = config()
model = SELUNet(dropout=netconfig["alphadropout"])
netconfig["model_resume_file"] = "model3/saved_models/model_20.pt"
model = load_model(model, netconfig["model_resume_file"])
model.eval()
train_data = AudioDataset(
"bdl_speech.npz", "bdl_egg.npz", netconfig["window"], netconfig["window"]
)
data = [train_data[i] for i in range(10)]
speech = th.cat([d[0] for d in data])
peak_arr = th.cat([d[1] for d in data])
idx = np.random.choice(len(speech), 2000, replace=False)
speech = speech[idx].unsqueeze_(1)
with th.no_grad():
features = model.feature_extractor(speech)
print(f"speech shape {speech.shape} features shape {features.shape}")
features = features.view(features.size(0), -1).numpy()
labels = peak_arr[:, 1][idx].numpy()
features_tsne = TSNE(perplexity=70, n_iter=2000).fit_transform(features)
print(f"features tsne shape {features_tsne.shape}")
positive_idx = labels == 1
negative_idx = labels == 0
print(
f"positive samples: {np.count_nonzero(positive_idx)} negative samples: {np.count_nonzero(negative_idx)}"
)
positive_coords = features_tsne[positive_idx]
negative_coords = features_tsne[negative_idx]
positive_distances = peak_arr[:, 0][idx].numpy()[positive_idx]
# bins = np.linspace(0, netconfig["window"], 5)
# markers = [".", "v", "^", "*"]
# colors = ["b", "r", "k", "m"]
# inds = np.digitize(positive_distances, bins)
fig, ax = plt.subplots()
# ax.set_title("TSNE L2 plot")
sc = ax.scatter(
positive_coords[:, 0],
positive_coords[:, 1],
c=positive_distances / (netconfig["window"] - 1),
# label=f"++",
marker="o",
cmap="viridis",
)
# ax.scatter(
# negative_coords[:, 0], negative_coords[:, 1], c="g", label="--", marker="."
# )
cbar = plt.colorbar(sc)
cbar.set_ticks([0, 1])
cbar.set_ticklabels(["$1$", "$w_d$"])
# ax.legend(
# ncol=2,
# framealpha=0.2,
# loc="upper center",
# bbox_to_anchor=(0.5, 1.15),
# mode=None,
# markerscale=4,
# )
ax.tick_params(
axis="both",
which="both",
bottom="off",
top="off",
labelbottom="off",
right="off",
left="off",
labelleft="off",
)
fig.set_tight_layout(True)
# ax.set_xlabel("Dimension 1")
# ax.set_ylabel("Dimension 2")
# mng = plt.get_current_fig_manager()
# mng.window.showMaximized()
# plt.show()
model_folder = os.path.join(netconfig["model_resume_file"].split("/")[0], "plots")
os.makedirs(model_folder, exist_ok=True)
curtime = dt.now()
plt.savefig(
os.path.join(
model_folder,
f"fig_{curtime.day}_{curtime.hour}_{curtime.minute}_{curtime.second}.eps",
),
format="eps",
dpi=300,
)
def parse(sentence, model_dir_new, dset_dir, gpu, model_dir, data, model, seg):
result_output = ""
if model_dir_new == model_dir:
data.generate_instance_with_gaz(sentence, 'sentence')
decode_results = main.parse_text(model, data, 'raw', gpu, seg)
result = data.write_decoded_results_back(decode_results, 'raw')
result_output = js.dumps(result)
else:
dset_dir_new = "/app/data/" + model_dir_new + "/" + model_dir_new + ".train.dset"
haveModel = os.path.exists("/app/data/" + model_dir_new)
haveDset = os.path.exists(dset_dir_new)
if haveModel and haveDset:
#处理文件路径
dirs = os.listdir("/app/data/" + model_dir_new + "/")
maxValue = 0
for file in dirs:
strArray = file.split('.')
strArrayLen = len(strArray)
if strArrayLen > 1 and strArray[strArrayLen - 1] == 'model':
index_int = int(strArray[strArrayLen - 2])
if maxValue < index_int:
maxValue = index_int
one_model_dir_new = "/app/data/" + model_dir_new + "/" + model_dir_new + ".train." + str(
maxValue) + ".model"
print one_model_dir_new
haveModel = os.path.exists(one_model_dir_new)
if haveModel:
model_dir = model_dir_new
dset_dir = dset_dir_new
one_model_dir = one_model_dir_new
#初始化
data = main.load_data_setting(dset_dir)
model = main.load_model(one_model_dir, data, gpu)
#处理sentence
data.generate_instance_with_gaz(sentence, 'sentence')
decode_results = main.parse_text(model, data, 'raw', gpu, seg)
result = data.write_decoded_results_back(decode_results, 'raw')
result_output = js.dumps(result)
else:
print "can not fine the model"
print "use default model"
model_dir, dset_dir, data, model, result_output = parseCommon(
sentence, model_dir_new, dset_dir, gpu, model_dir, data,
model, seg)
else:
print "can not fine the model"
print "use default model"
model_dir, dset_dir, data, model, result_output = parseCommon(
sentence, model_dir_new, dset_dir, gpu, model_dir, data, model,
seg)
return model_dir, dset_dir, data, model, result_output
args = ap.parse_args()
cuda_flag = torch.cuda.is_available()
device = torch.device('cuda' if cuda_flag else 'cpu')
_, test_loader = get_mnist_loaders(cuda_flag=cuda_flag,
dataset_path='data/',
batch_size=4,
test_batch_size=5,
num_test_images=10)
zero_limit = 1e-5
for f in glob.glob(os.path.join(args.models_dir, '*')):
modelw, _, _, _ = load_model(f, cpu=not cuda_flag)
model = Net()
model.load_state_dict(modelw)
model = model.to(device)
x, y = next(iter(test_loader))
x, y = x.to(device), y.to(device)
l = torch.nn.functional.cross_entropy(model(x), y)
for n, p in model.named_parameters():
hess = hessian(l, p)
eigvals, eigvecs = torch.eig(hess)
ctx = 0
for e in eigvals:
if e[0] < zero_limit and e[1] < zero_limit:
from pika import connection
from main import evaluate_model, load_model
import numpy as np
import skimage
import json
from functools import singledispatch
import numpy as np
from contextlib import redirect_stdout
import pika, sys, os, io
import traceback
rabbitmq_url = os.getenv('RABBITMQ_URL')
model = load_model()
def get_rabbit_connection():
if rabbitmq_url:
connection = pika.BlockingConnection(pika.URLParameters(rabbitmq_url))
else:
connection = pika.BlockingConnection(pika.ConnectionParameters('rabbitmq'))
return connection
def save_output(queue, ids, outputs, type='SAVE'):
connection = get_rabbit_connection()
channel = connection.channel()
for id, output in zip (ids, outputs):
message = {
'id': id,
def main():
netconfig, _, _ = config()
model = SELUNet(dropout=netconfig["alphadropout"])
netconfig["model_resume_file"] = "model3/saved_models/model_20.pt"
model = load_model(model, netconfig["model_resume_file"])
model.eval()
train_data = AudioDataset("bdl_speech.npz", "bdl_egg.npz",
netconfig["window"], netconfig["window"])
data = [train_data[i] for i in range(10)]
speech = th.cat([d[0] for d in data])
peak_arr = th.cat([d[1] for d in data])
idx = np.random.choice(len(speech), 2000, replace=False)
speech = speech[idx].unsqueeze_(1)
with th.no_grad():
features = model.feature_extractor(speech)
print(f"speech shape {speech.shape} features shape {features.shape}")
features = features.view(features.size(0), -1).numpy()
labels = peak_arr[:, 1][idx].numpy()
features_tsne = TSNE().fit_transform(features)
print(f"features tsne shape {features_tsne.shape}")
positive_idx = labels == 1
negative_idx = labels == 0
print(
f"positive samples: {np.count_nonzero(positive_idx)} negative samples: {np.count_nonzero(negative_idx)}"
)
positive_coords = features_tsne[positive_idx]
negative_coords = features_tsne[negative_idx]
positive_distances = peak_arr[:, 0][idx].numpy()[positive_idx]
bins = np.linspace(0, netconfig["window"], 5)
markers = [".", "v", "^", "*"]
colors = ["b", "r", "k", "m"]
inds = np.digitize(positive_distances, bins)
fig, ax = plt.subplots()
ax.set_title("TSNE L2 plot")
for i, m, c in zip(range(len(bins) - 1), markers, colors):
indices = inds == i
ax.scatter(
positive_coords[indices, 0],
positive_coords[indices, 1],
c=c,
label=f"++ {(bins[i], bins[i+1])}",
marker=m,
)
ax.scatter(negative_coords[:, 0], negative_coords[:, 1], c="g", label="--")
ax.legend(loc=1)
fig.set_tight_layout(True)
ax.set_xlabel("Dimension 1")
ax.set_ylabel("Dimension 2")
mng = plt.get_current_fig_manager()
mng.window.showMaximized()
plt.show()
ap.add_argument('factor',
type=float,
help='Factor to use for scalar multiplication')
ap.add_argument(
'layer',
type=int,
nargs='+',
help=
'Layer (and layer+1) of network to apply transforms * N followed by * 1/N'
)
args = ap.parse_args()
devc = "cuda:0" if torch.cuda.is_available() else "cpu"
device = torch.device(devc)
modelw, _, _, _ = load_model(args.model, cpu=devc == "cpu")
model = Net()
model.load_state_dict(modelw)
model = model.to(device)
_, test_loader = get_mnist_loaders(cuda_flag=devc != "cpu",
dataset_path='data/',
batch_size=4,
test_batch_size=100)
loss, correct = test(model, test_loader, device)
print("Number of correct predictions before scaling: %d" % (correct))
for layer in args.layer:
scale_by_constant(model, args.factor, layer)
def Main(args):
train_set = get_dataset(args.data_dir)
image_list, _ = get_image_paths_and_labels(train_set)
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Graph().as_default():
with tf.Session(config=config) as sess:
# Load the model
main.load_model(args.model_dir)
# Get input and output tensors
images_placeholder = tf.get_default_graph().get_tensor_by_name(
"input:0")
embeddings = tf.get_default_graph().get_tensor_by_name(
"embeddings:0")
phase_train_placeholder = tf.get_default_graph(
).get_tensor_by_name("phase_train:0")
# Run forward pass to calculate embeddings
nrof_images = len(image_list)
print('Number of images: ', nrof_images)
batch_size = 50
if nrof_images % batch_size == 0:
nrof_batches = nrof_images // batch_size
else:
nrof_batches = (nrof_images // batch_size) + 1
print('Number of batches: ', nrof_batches)
embedding_size = embeddings.get_shape()[1]
emb_array = np.empty((0, embedding_size), int)
id_labels = np.array([])
start_time = time.time()
for i in range(nrof_batches):
if i == nrof_batches - 1:
n = nrof_images
else:
n = i * batch_size + batch_size
# Get images for the batch
images, id_names = load_and_align_data(
image_list[i * batch_size:n], 160, 44, 1.0)
feed_dict = {
images_placeholder: images,
phase_train_placeholder: False
}
id_labels = np.append(id_labels, id_names)
# Use the facenet model to calcualte embeddings
embed = sess.run(embeddings, feed_dict=feed_dict)
emb_array = np.append(emb_array, embed, axis=0)
print('Completed batch', i + 1, 'of', nrof_batches)
run_time = time.time() - start_time
print('Run time: ', run_time)
# export emedings and labels
np.save(os.path.join(args.data_dir, args.embeddings_name),
emb_array)
np.save(os.path.join(args.data_dir, args.labels_strings_name),
id_labels)
def main():
print(torch.__version__)
# torch.autograd.set_detect_anomaly(True)
global opt, model
opt = parser.parse_args()
print(opt)
param_suffix = f"{opt.prefix}_bs={opt.batchSize}_beta={opt.weight_rec}_KL={opt.weight_kl}_KLneg={opt.weight_neg}_fd={opt.flow_depth}_m={opt.m_plus}_lambda_me={opt.lambda_me}_kernel={opt.kernel}_tanh={opt.tanh_flag}_C={opt.C}_linearb={opt.linear_benchmark}_J={opt.J}"
opt.outf = f'results{param_suffix}/'
try:
os.makedirs(opt.outf)
except OSError:
pass
if opt.manualSeed is None:
opt.manualSeed = random.randint(1, 10000)
print("Random Seed: ", opt.manualSeed)
random.seed(opt.manualSeed)
torch.manual_seed(opt.manualSeed)
if opt.cuda:
torch.cuda.manual_seed_all(opt.manualSeed)
base_gpu_list= GPUtil.getAvailable(order='memory',limit=2)
if 5 in base_gpu_list:
base_gpu_list.remove(5)
base_gpu = base_gpu_list[0]
cudnn.benchmark = True
elif torch.cuda.is_available() and not opt.cuda:
print("WARNING: You have a CUDA device, so you should probably run with --cuda")
#--------------build models -------------------------
model = DIF_netv2(flow_C=opt.C,
flow_depth=opt.flow_depth,
tanh_flag=opt.tanh_flag,
cdim=opt.cdim,
hdim=opt.hdim,
channels=str_to_list(opt.channels),
image_size=opt.output_height).cuda(base_gpu)
if opt.pretrained:
load_model(model, opt.pretrained)
print(model)
# optimizerE = optim.Adam(chain(model.encoder.parameters(),model.flow.parameters()), lr=opt.lr_e)
# optimizerG = optim.Adam(model.decoder.parameters(), lr=opt.lr_g)
optimizerE = optim.Adam(model.encoder.parameters(), lr=opt.lr_e)
optimizerG = optim.Adam(model.decoder.parameters(), lr=opt.lr_g)
if opt.fp_16:
scaler = GradScaler()
#-----------------load dataset--------------------------
train_data = pd.read_csv(opt.class_indicator_file,random_state=0)
train_data = train_data.sample(frac=1)
train_list = train_data['file_name'].values.tolist()[:opt.trainsize]
property_indicator = train_data['class'].values.tolist()[:opt.trainsize]
#swap out the train files
assert len(train_list) > 0
train_set = ImageDatasetFromFile_DIF(property_indicator,train_list, opt.dataroot, input_height=None, crop_height=None, output_height=opt.output_height, is_mirror=True,is_gray=opt.cdim!=3)
train_data_loader = torch.utils.data.DataLoader(train_set, batch_size=opt.batchSize, shuffle=True, num_workers=int(opt.workers))
min_features = 0
if opt.lambda_me!=0:
if opt.linear_benchmark:
me_obj = linear_benchmark(d=opt.hdim).cuda(base_gpu)
else:
me_obj = MEstat(J=opt.J,
test_nx=len(train_set.property_indicator)-sum(train_set.property_indicator),
test_ny=sum(train_set.property_indicator),
asymp_n=opt.asymp_n,
kernel_type=opt.kernel).cuda(base_gpu)
min_features = 1./opt.J
if opt.tensorboard:
from tensorboardX import SummaryWriter
writer = SummaryWriter(log_dir=opt.outf)
start_time = time.time()
cur_iter = 0
def train_vae(epoch, iteration, batch,c,cur_iter):
if len(batch.size()) == 3:
batch = batch.unsqueeze(0)
real= Variable(batch).cuda(base_gpu)
info = "\n====> Cur_iter: [{}]: Epoch[{}]({}/{}): time: {:4.4f}: ".format(cur_iter, epoch, iteration, len(train_data_loader), time.time()-start_time)
loss_info = '[loss_rec, loss_margin, lossE_real_kl, lossE_rec_kl, lossE_fake_kl, lossG_rec_kl, lossG_fake_kl,]'
#=========== Update E ================
def VAE_forward():
# real_mu, real_logvar, z_real, rec, flow_log_det_real, xi_real = model(real)
real_mu, real_logvar, z_real, rec = model(real)
loss_rec = model.reconstruction_loss(rec, real, True)
loss_kl = model.kl_loss(real_mu, real_logvar).mean() #- flow_log_det_real.mean()
if opt.lambda_me==0:
T = torch.zeros_like(loss_rec)
else:
T = me_obj(z_real, c)*opt.lambda_me
loss = loss_rec + loss_kl - T
return loss,loss_rec,loss_kl,rec,T
if opt.fp_16:
with autocast():
loss,loss_rec,loss_kl,rec,T = VAE_forward()
optimizerG.zero_grad()
optimizerE.zero_grad()
scaler.scale(loss).backward()
scaler.step(optimizerE) # .step()
scaler.step(optimizerG) # .step()
scaler.update()
else:
loss,loss_rec,loss_kl,rec,T = VAE_forward()
loss.backward()
optimizerE.step()
optimizerG.step()
info += 'Rec: {:.4f}, KL: {:.4f}, ME: {:.4f} '.format(loss_rec.item(), loss_kl.item(),T.item())
print(info)
if cur_iter % opt.test_iter is 0:
if opt.tensorboard:
record_scalar(writer, eval(loss_info), loss_info, cur_iter)
if cur_iter % 1000 == 0:
record_image(writer, [real, rec], cur_iter)
else:
vutils.save_image(torch.cat([real, rec], dim=0).data.cpu(), '{}/vae_image_{}.jpg'.format(opt.outf, cur_iter),nrow=opt.nrow)
def train(epoch, iteration, batch,c, cur_iter):
if len(batch.size()) == 3:
batch = batch.unsqueeze(0)
batch_size = batch.size(0)
c = c.cuda(base_gpu)
noise = torch.randn(batch_size, opt.hdim).cuda(base_gpu)
# noise_logvar = torch.zeros_like(noise)
real= batch.cuda(base_gpu)
info = "\n====> Cur_iter: [{}]: Epoch[{}]({}/{}): time: {:4.4f}: ".format(cur_iter, epoch, iteration, len(train_data_loader), time.time()-start_time)
loss_info = '[loss_rec, loss_margin, lossE_real_kl, lossE_rec_kl, lossE_fake_kl, lossG_rec_kl, lossG_fake_kl,]'
#Problem is flow is trained with competing objectives on the same entity? Still unstable training!
# Tune parameters?! Fake part is giving me a hard time...
def update_E():
# fake = model.sample(noise,noise_logvar)
fake = model.sample(noise)
# real_mu, real_logvar, z_real, rec,flow_log_det_real,xi_real = model(real)
real_mu, real_logvar, z, rec = model(real)
# rec_mu, rec_logvar,z_recon, flow_log_det_recon,xi_recon = model.encode_and_flow(rec.detach())
# fake_mu, fake_logvar,z_fake, flow_log_det_fake,xi_fake = model.encode_and_flow(fake.detach())
rec_mu, rec_logvar = model.encode(rec.detach())
fake_mu, fake_logvar = model.encode(fake.detach())
loss_rec = model.reconstruction_loss(rec, real, True)
lossE_real_kl = model.kl_loss(real_mu, real_logvar).mean()#-flow_log_det_real.mean()
lossE_rec_kl = model.kl_loss(rec_mu, rec_logvar).mean()#-flow_log_det_recon.mean()
lossE_fake_kl = model.kl_loss(fake_mu, fake_logvar).mean()#-flow_log_det_fake.mean()
loss_margin = lossE_real_kl +(torch.relu(opt.m_plus-lossE_rec_kl)+torch.relu(opt.m_plus-lossE_fake_kl)) * 0.5 * opt.weight_neg
# + \
if opt.lambda_me==0:
T = torch.zeros_like(loss_rec)
else:
T = me_obj(z, c)*opt.lambda_me
# Also, ok might want to add more parametrization of hyper parameters.
#weight neg should control adversarial objective. Want fakes and (reconstructions?!) to deviate from prior, want reals to be close to prior.
#Don't know why reconstructions should be adversarial... Might want to rebalance
lossE = loss_rec * opt.weight_rec + loss_margin * opt.weight_kl-T
return lossE,rec,fake,loss_rec,lossE_real_kl,\
lossE_rec_kl,lossE_fake_kl,real_logvar,rec_logvar,loss_margin,T
#=========== Update E ================
if opt.fp_16:
with autocast():
lossE,rec,fake,loss_rec,lossE_real_kl,\
lossE_rec_kl,lossE_fake_kl,\
real_logvar,rec_logvar,loss_margin,T_loss= update_E()
optimizerG.zero_grad()
optimizerE.zero_grad()
scaler.scale(lossE).backward(retain_graph=True)
else:
lossE,rec,fake,loss_rec,lossE_real_kl,lossE_rec_kl,\
lossE_fake_kl,real_logvar\
,rec_logvar,loss_margin,T_loss = update_E()
optimizerG.zero_grad()
optimizerE.zero_grad()
lossE.backward(retain_graph=True)
# def flow_separate_backward():
# # z_real = model.flow_forward_only(xi_real.detach(),real_logvar.detach())
# # z_recon = model.flow_forward_only(xi_recon.detach(),rec_logvar.detach())
# T_real = me_obj(xi_real,c)
# # T_recon = me_obj(z_recon,c)
# return T_real#+T_recon
# if opt.fp_16:
# with autocast():
# T_loss = -opt.lambda_me*flow_separate_backward()
# scaler.scale(T_loss).backward()
# else:
# T_loss = -opt.lambda_me*flow_separate_backward()
# T_loss.backward()
#Backprop everything on everything... NOT! Make sure the FLOW trains only one ONE of the saddlepoint objectives!
# nn.utils.clip_grad_norm(model.encoder.parameters(), 1.0)
for m in model.encoder.parameters():
m.requires_grad=False
# for m in model.flow.parameters(): #Controls whether which objectives apply to flow
# m.requires_grad=False
#========= Update G ==================
def update_G():
# rec_mu, rec_logvar, z_recon, flow_log_det_recon,xi_recon = model.encode_and_flow(rec)
# fake_mu, fake_logvar, z_fake, flow_log_det_fake,xi_fake = model.encode_and_flow(fake)
rec_mu, rec_logvar = model.encode(rec)
fake_mu, fake_logvar = model.encode(fake)
lossG_rec_kl = model.kl_loss(rec_mu, rec_logvar).mean() #- flow_log_det_recon.mean()
lossG_fake_kl = model.kl_loss(fake_mu, fake_logvar).mean() #- flow_log_det_fake.mean()
lossG = (lossG_rec_kl + lossG_fake_kl) * 0.5 * opt.weight_kl
return lossG,lossG_rec_kl,lossG_fake_kl
if opt.fp_16:
with autocast():
lossG,lossG_rec_kl,lossG_fake_kl = update_G()
scaler.scale(lossG).backward()
# nn.utils.clip_grad_norm(model.decoder.parameters(), 1.0)
scaler.step(optimizerE) # .step()
scaler.step(optimizerG) # .step()
scaler.update()
else:
lossG,lossG_rec_kl,lossG_fake_kl = update_G()
lossG.backward()
# nn.utils.clip_grad_norm(model.decoder.parameters(), 1.0)
optimizerE.step()
optimizerG.step()
for m in model.encoder.parameters():
m.requires_grad = True
# for m in model.flow.parameters(): #Controls whether which objectives apply to flow
# m.requires_grad=True
#Write down setups, carefully consider gradient updates to avoid positive feedback loop!
#. The key is to hold the regularization term LREG in Eq. (11) and Eq. (12) below the margin value m for most of the time
info += 'Rec: {:.4f}, '.format(loss_rec.item()*opt.weight_rec)
info += 'Margin loss: {:.4f}, '.format(opt.weight_kl*loss_margin.item())
info += 'Total loss E: {:.4f}, '.format(lossE.item())
info += 'Total loss G: {:.4f}, '.format(lossG.item())
info += 'Kl_E: {:.4f}, {:.4f}, {:.4f}, '.format(lossE_real_kl.item(),
lossE_rec_kl.item(), lossE_fake_kl.item())
info += 'Kl_G: {:.4f}, {:.4f}, '.format(lossG_rec_kl.item(), lossG_fake_kl.item())
info += 'ME_flow: {:.4f}'.format(T_loss.item())
print(info)
if cur_iter % opt.test_iter is 0:
if opt.tensorboard:
record_scalar(writer, eval(loss_info), loss_info, cur_iter)
if cur_iter % 1000 == 0:
record_image(writer, [real, rec, fake], cur_iter)
else:
vutils.save_image(torch.cat([real, rec, fake], dim=0).data.cpu(), '{}/image_{}.jpg'.format(opt.outf, cur_iter),nrow=opt.nrow)
#----------------Train by epochs--------------------------
for epoch in range(opt.start_epoch, opt.nEpochs + 1):
#save models
if epoch % opt.save_iter == 0:
save_checkpoint(model, epoch, cur_iter, '', folder_name=f"model{param_suffix}")
model.train()
for iteration, (batch,c) in enumerate(train_data_loader, 0):
if (c.sum()<min_features) or ((~c).sum()<min_features):
print('skip')
continue
else:
#--------------train------------
if epoch < opt.num_vae:
train_vae(epoch, iteration, batch,c, cur_iter)
else:
train(epoch, iteration, batch,c, cur_iter)
cur_iter += 1
else:
device = torch.device('cpu')
cuda = False
model_handler = TrainedModels('models', pytorch_model=True)
weights, params, layer_keys = model_handler.get_models()
# min, max
m, M = 0, 0
# loss values comparison
if params[0][0][0] > params[1][0][0]:
m = 1
else:
M = 1
src_model = Model(load_model(weights[M][0], weight=True), params[M][0][0],
params[M][0][1], params[M][0][2])
tgt_model = Model(load_model(weights[m][0], weight=True), params[m][0][0],
params[m][0][1], params[m][0][2])
p = PathFinder(src_model,
tgt_model,
device,
step_min=1e-3,
del_loss=1e-3,
split_size=50)
p = p.to(device)
if m != 1:
model_handler.model_files = [