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 = [