def main(config): device = torch.device('cpu') if config.gpu_id < 0 else torch.device( 'cuda:%d' % config.gpu_id) x, y = load_mnist(is_train=True) x = x.view(x.size(0), -1) train_cnt = int(x.size(0) * config.train_rate) valid_cnt = x.size(0) - train_cnt indices = torch.randperm(x.size(0)) x = torch.index_select(x, dim=0, index=indices).to(device).split( [train_cnt, valid_cnt], dim=0) print("Train:", x[0].shape, y[0].shape) print("Valid:", x[1].shape, y[1].shape) model = ImageClassifier(28**2, 10).to(device) optimizer = optim.Adam(model.parameters()) crit = nn.CrossEntropyLoss() trainer = Trainer(model, optimizer, crit) trainer.train((x[0], y[0]), (x[1], y[1]), config) torch.save({ 'model': trainer.model.state_dict(), 'config': config, }, config.model_fn)
def main(config): # Set device based on user defined configuration. device = torch.device('cpu') if config.gpu_id < 0 else torch.device( 'cuda:%d' % config.gpu_id) x, y = load_mnist(is_train=True) # Reshape tensor to chunk of 1-d vectors. x = x.view(x.size(0), -1) train_cnt = int(x.size(0) * config.train_ratio) valid_cnt = x.size(0) - train_cnt # Shuffle dataset to split into train/valid set. indices = torch.randperm(x.size(0)) x = torch.index_select(x, dim=0, index=indices).to(device).split( [train_cnt, valid_cnt], dim=0) y = torch.index_select(y, dim=0, index=indices).to(device).split( [train_cnt, valid_cnt], dim=0) print("Train:", x[0].shape, y[0].shape) print("Valid:", x[1].shape, y[1].shape) model = ImageClassifier(28**2, 10).to(device) optimizer = optim.Adam(model.parameters()) crit = nn.NLLLoss() trainer = Trainer(model, optimizer, crit) trainer.train((x[0], y[0]), (x[1], y[1]), config) # Save best model weights. torch.save({ 'model': trainer.model.state_dict(), 'config': config }, config.model_fn)
def validate(val_loader: DataLoader, model: ImageClassifier, esem, source_classes: list, args: argparse.Namespace) -> float: # switch to evaluate mode model.eval() esem.eval() all_confidece = list() all_consistency = list() all_entropy = list() all_indices = list() all_labels = list() with torch.no_grad(): for i, (images, labels) in enumerate(val_loader): images = images.to(device) labels = labels.to(device) output, f = model(images) values, indices = torch.max(F.softmax(output, -1), 1) yt_1, yt_2, yt_3, yt_4, yt_5 = esem(f) confidece = get_confidence(yt_1, yt_2, yt_3, yt_4, yt_5) entropy = get_entropy(yt_1, yt_2, yt_3, yt_4, yt_5) consistency = get_consistency(yt_1, yt_2, yt_3, yt_4, yt_5) all_confidece.extend(confidece) all_consistency.extend(consistency) all_entropy.extend(entropy) all_indices.extend(indices) all_labels.extend(labels) all_confidece = norm(torch.tensor(all_confidece)) all_consistency = norm(torch.tensor(all_consistency)) all_entropy = norm(torch.tensor(all_entropy)) all_score = (all_confidece + 1 - all_consistency + 1 - all_entropy) / 3 counters = AccuracyCounter(len(source_classes) + 1) for (each_indice, each_label, score) in zip(all_indices, all_labels, all_score): if each_label in source_classes: counters.add_total(each_label) if score >= args.threshold and each_indice == each_label: counters.add_correct(each_label) else: counters.add_total(-1) if score < args.threshold: counters.add_correct(-1) print('---counters---') print(counters.each_accuracy()) print(counters.mean_accuracy()) print(counters.h_score()) return counters.mean_accuracy()
def main(): model_fn = "./model.pth" device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu') x, y = load_mnist(is_train=True, flatten=True) x, y = x.to(device), y.to(device) model = ImageClassifier(28 * 28, 10).to(device) model.load_state_dict(load(model_fn, device)) test(model, x[:20], y[:20], to_be_shown=True)
def main(argv=None): print("Parameters:") for k, v in FLAGS.__flags.items(): print(k, "=", v) print() #sess = tf.InteractiveSession() input_generator = inputs.train_pipeline(batch_size=FLAGS.batch_size, num_epochs=FLAGS.num_epochs) classifier_model = ImageClassifier(NUM_CLASSES, IMAGE_SIZE, batch_size=FLAGS.batch_size) sess = tf.Session() summary_dir = FLAGS.output_dir + FLAGS.summary_train_dir train_writer = tf.summary.FileWriter(summary_dir, sess.graph) coord = tf.train.Coordinator() with sess.as_default(): sess.run(tf.global_variables_initializer()) sess.run(tf.local_variables_initializer()) step = 0 start = datetime.now() for batch in input_generator: accuracy, loss, summary, run_metadata, embeddings = classifier_model.train( sess, batch) if step % FLAGS.report_every is 0: now = datetime.now() elapsed = now - start average = elapsed / step if not step is 0 else 0 print( "Step %08d, Accuracy %.6f, Loss %.6f, Average Time %s/step, Elapsed Time %s%s" % (step, accuracy * 100, loss, average, elapsed, ", Created Summary" if step % FLAGS.summary_every is 0 else "")) sys.stdout.flush() if step % FLAGS.summary_every is 0: train_writer.add_run_metadata(run_metadata, 'step%d' % step) train_writer.add_summary(summary, step) if step % FLAGS.checkpoint_every is 0: classifier_model.save(sess, global_step=step) step += 1
def main(config): device = torch.device('cpu') if config.gpu_id < 0 else torch.device('cuda:%d' % config.gpu_id) train_loader, valid_loader, test_loader = get_loaders(config) print("Train:", len(train_loader.dataset)) print("Valid:", len(valid_loader.dataset)) print("Test:", len(test_loader.dataset)) model = ImageClassifier(28**2, 10).to(device) optimizer = optim.Adam(model.parameters()) crit = nn.CrossEntropyLoss() trainer = Trainer(config) trainer.train(model, crit, optimizer, train_loader, valid_loader)
def main(config): device = torch.device('cpu') if config.gpu_id < 0 else torch.device( 'cuda : %d' % config.gpu_id) train_loader, valid_loader, test_loader = get_loaders(config) # get_loader를 통해 데이터를 받아옴 print('Train', len(train_loader.dataset)) print('Valid', len(valid_loader.dataset)) print('Test', len(test_loader.dataset)) model = ImageClassifier(28**2, 10).to(device) # input = (784)이고 10개의 클래스로 분류할 것 optimizer = optim.Adam(model.parameters()) crit = nn.CrossEntropyLoss() # Loss Function trainer = Trainer(config) trainer.train(model, crit, optimizer, train_loader, valid_loader)
def main(config): # Set device based on user defined configuration. device = torch.device('cpu') if config.gpu_id < 0 else torch.device('cuda:%d' % config.gpu_id) x, y = load_mnist(is_train=True, flatten=True) x, y = split_data(x.to(device), y.to(device), train_ratio=config.train_ratio) print("Train:", x[0].shape, y[0].shape) print("Valid:", x[1].shape, y[1].shape) input_size = int(x[0].shape[-1]) output_size = int(max(y[0])) + 1 model = ImageClassifier( input_size=input_size, output_size=output_size, hidden_sizes=get_hidden_sizes(input_size, output_size, config.n_layers), use_batch_norm=not config.use_dropout, dropout_p=config.dropout_p, ).to(device) optimizer = optim.Adam(model.parameters()) crit = nn.NLLLoss() if config.verbose >= 1: print(model) print(optimizer) print(crit) trainer = Trainer(model, optimizer, crit) trainer.train( train_data=(x[0], y[0]), valid_data=(x[1], y[1]), config=config ) # Save best model weights. torch.save({ 'model': trainer.model.state_dict(), 'opt': optimizer.state_dict(), 'config': config, }, config.model_fn)
def main(config): # Set device based on user defined configuration. device = torch.device('cpu') if config.gpu_id < 0 else torch.device( 'cuda:%d' % config.gpu_id) train_loader, valid_loader, test_loader = get_loaders(config) print("Train:", len(train_loader.dataset)) print("Valid:", len(valid_loader.dataset)) print("Test:", len(test_loader.dataset)) model = ImageClassifier(28**2, 10).to( device) # 입력은 784, 10개 클래스로 분류, GPU면 여기로 옮겨줘? optimizer = optim.Adam(model.parameters( )) # model.parameters() 하면 모델 내 웨이트 파라미터들이 이터레이티브하게 나온다 crit = nn.CrossEntropyLoss() # 분류를 해야하기 때문에 교차엔트로피 쓴다, 모델에서 소프트맥스로 끝나는 이유 trainer = Trainer(config) # 이그나이트를 써서 짜놓은 메서드 trainer.train(model, crit, optimizer, train_loader, valid_loader)
def main(config): # 연산 디바이스 설정 if config.gpu_id < 0: print("Device: CPU") device = torch.device('cpu') else: print("Device:", torch.cuda.get_device_name(0)) device = torch.device('cuda:%d' % config.gpu_id) # 입력값에 따라 학습, 검증 데이터 분할 x, y = load_mnist(is_train=True, flatten=True) train_cnt = int(x.size(0) * config.train_ratio) valid_cnt = x.size(0) - train_cnt # 각 데이터셋 셔플링 indices = torch.randperm(x.size(0)) x = torch.index_select(x, dim=0, index=indices).to(device).split( [train_cnt, valid_cnt], dim=0) y = torch.index_select(y, dim=0, index=indices).to(device).split( [train_cnt, valid_cnt], dim=0) print("Train:", x[0].shape, y[0].shape) print("Valid:", x[1].shape, y[1].shape) # 모델 선언 및 구조 결정 model = ImageClassifier(28 * 28, 10).to(device) optimizer = optim.Adam(model.parameters()) crit = nn.CrossEntropyLoss() # 학습 수행 trainer = Trainer(model, optimizer, crit) trainer.train(train_data=(x[0], y[0]), valid_data=(x[1], y[1]), config=config) #모델 저장 torch.save({ 'model': trainer.model.state_dict(), 'config': config }, config.model_fn)
def main(config): # 실행 장치 설정 device = torch.device('cpu') if config.gpu_id < 0 else torch.device( 'cuda:%d' % config.gpu_id) # 데이터 로드 x, y = load_mnist(is_train=True) x = x.view(x.size(0), -1) # flatten 된 형태 train_cnt = int(x.size(0) * config.train_ratio) valid_cnt = x.size(0) - train_cnt # Shuffle & Random Split indices = torch.randperm(x.size(0)) x = torch.index_select(x, dim=0, index=indices).to(device).split( [train_cnt, valid_cnt], dim=0) y = torch.index_select(y, dim=0, index=indices).to(device).split( [train_cnt, valid_cnt], dim=0) # split 되는 형태: [(train_cnt, 784) , (valid_cnt, 784)] print("Train : ", x[0].shape, y[0].shape) print("Valid : ", x[1].shape, y[1].shape) # load model, optimizer, criterion model = ImageClassifier(28**2, 10).to(device) optimizer = optim.Adam(model.parameters()) criterion = nn.CrossEntropyLoss() trainer = Trainer(model, optimizer, criterion) trainer.train((x[0], y[0]), (x[1], y[1]), config) # 베스트 모델 및 가중치 저장 torch.save({ 'model': trainer.model.state_dict(), 'config': config, }, config.model_fn)
def train(M, out_classes=3, cv_iters=100): m = ImageClassifier(M, out_classes) global_step = m.global_step train_op = tf.train.MomentumOptimizer(1e-2, 0.9).minimize( m.error, global_step=global_step) summary_op = tf.summary.merge_all() logdir = os.path.join("tflogs", m.name) sw = tf.summary.FileWriter(logdir) sv = tf.train.Supervisor(summary_op=None, summary_writer=None, logdir=logdir, global_step=global_step, save_model_secs=120) with sv.managed_session() as sess: data_gen = async_data_loader(size=(226, 226), start=0, end=1000, batch_size=32) sw.add_graph(sess.graph) while not sv.should_stop(): start_time = time.perf_counter() imgs, lbls = next(data_gen) print("\rData loading time: {}".format(time.perf_counter() - start_time), end="") lbls = np.array(convert_lbl_to_ind(lbls)) s, _ = sess.run([summary_op, train_op], feed_dict={ m.X: imgs, m.Y: lbls }) sw.add_summary(s, global_step=sess.run(global_step)) if sess.run(global_step) % cv_iters == 1: print() cvAcc, cvErr = evaluate_cv_stats(sess, 1000, 1318, m) cv_sum = tf.Summary(value=[ tf.Summary.Value(tag="cv_accuracy", simple_value=cvAcc), tf.Summary.Value(tag="cv_error", simple_value=cvErr) ]) sw.add_summary(cv_sum, global_step=sess.run(global_step)) print()
def main(args: argparse.Namespace): if args.seed is not None: random.seed(args.seed) torch.manual_seed(args.seed) cudnn.deterministic = True cudnn.benchmark = True # Data loading code normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) train_transform = transforms.Compose([ ResizeImage(256), transforms.RandomResizedCrop(224), transforms.RandomHorizontalFlip(), transforms.ToTensor(), normalize ]) val_tranform = transforms.Compose([ ResizeImage(256), transforms.CenterCrop(224), transforms.ToTensor(), normalize ]) a, b, c = args.n_share, args.n_source_private, args.n_total common_classes = [i for i in range(a)] source_private_classes = [i + a for i in range(b)] target_private_classes = [i + a + b for i in range(c - a - b)] source_classes = common_classes + source_private_classes target_classes = common_classes + target_private_classes dataset = datasets.Office31 train_source_dataset = dataset(root=args.root, data_list_file=args.source, filter_class=source_classes, transform=train_transform) train_source_loader = DataLoader(train_source_dataset, batch_size=args.batch_size, shuffle=True, num_workers=args.workers, drop_last=True) train_target_dataset = dataset(root=args.root, data_list_file=args.target, filter_class=target_classes, transform=train_transform) train_target_loader = DataLoader(train_target_dataset, batch_size=args.batch_size, shuffle=True, num_workers=args.workers, drop_last=True) val_dataset = dataset(root=args.root, data_list_file=args.target, filter_class=target_classes, transform=val_tranform) val_loader = DataLoader(val_dataset, batch_size=args.batch_size, shuffle=False, num_workers=args.workers) test_loader = val_loader train_source_iter = ForeverDataIterator(train_source_loader) train_target_iter = ForeverDataIterator(train_target_loader) esem_iter1, esem_iter2, esem_iter3, esem_iter4, esem_iter5 = esem_dataloader( args, source_classes) # create model backbone = resnet50(pretrained=True) classifier = ImageClassifier(backbone, train_source_dataset.num_classes).to(device) domain_discri = DomainDiscriminator(in_feature=classifier.features_dim, hidden_size=1024).to(device) esem = Ensemble(classifier.features_dim, train_source_dataset.num_classes).to(device) # define optimizer and lr scheduler optimizer = SGD(classifier.get_parameters() + domain_discri.get_parameters(), args.lr, momentum=args.momentum, weight_decay=args.weight_decay, nesterov=True) lr_scheduler = StepwiseLR(optimizer, init_lr=args.lr, gamma=0.001, decay_rate=0.75) optimizer_esem = SGD(esem.parameters(), args.lr, momentum=args.momentum, weight_decay=args.weight_decay, nesterov=True) lr_scheduler1 = StepwiseLR(optimizer_esem, init_lr=args.lr, gamma=0.001, decay_rate=0.75) lr_scheduler2 = StepwiseLR(optimizer_esem, init_lr=args.lr, gamma=0.001, decay_rate=0.75) lr_scheduler3 = StepwiseLR(optimizer_esem, init_lr=args.lr, gamma=0.001, decay_rate=0.75) lr_scheduler4 = StepwiseLR(optimizer_esem, init_lr=args.lr, gamma=0.001, decay_rate=0.75) lr_scheduler5 = StepwiseLR(optimizer_esem, init_lr=args.lr, gamma=0.001, decay_rate=0.75) optimizer_pre = SGD(esem.get_parameters() + classifier.get_parameters(), args.lr, momentum=args.momentum, weight_decay=args.weight_decay, nesterov=True) # define loss function domain_adv = DomainAdversarialLoss(domain_discri, reduction='none').to(device) pretrain(esem_iter1, esem_iter2, esem_iter3, esem_iter4, esem_iter5, classifier, esem, optimizer_pre, args) # start training best_acc1 = 0. for epoch in range(args.epochs): # train for one epoch train_esem(esem_iter1, classifier, esem, optimizer_esem, lr_scheduler1, epoch, args, index=1) train_esem(esem_iter2, classifier, esem, optimizer_esem, lr_scheduler2, epoch, args, index=2) train_esem(esem_iter3, classifier, esem, optimizer_esem, lr_scheduler3, epoch, args, index=3) train_esem(esem_iter4, classifier, esem, optimizer_esem, lr_scheduler4, epoch, args, index=4) train_esem(esem_iter5, classifier, esem, optimizer_esem, lr_scheduler5, epoch, args, index=5) source_class_weight = evaluate_source_common(val_loader, classifier, esem, source_classes, args) train(train_source_iter, train_target_iter, classifier, domain_adv, esem, optimizer, lr_scheduler, epoch, source_class_weight, args) # evaluate on validation set acc1 = validate(val_loader, classifier, esem, source_classes, args) # remember best acc@1 and save checkpoint if acc1 > best_acc1: best_model = copy.deepcopy(classifier.state_dict()) best_acc1 = max(acc1, best_acc1) print("best_acc1 = {:3.3f}".format(best_acc1)) # evaluate on test set classifier.load_state_dict(best_model) acc1 = validate(test_loader, classifier, esem, source_classes, args) print("test_acc1 = {:3.3f}".format(acc1))
def main(argv=None): print("Parameters:") for k, v in FLAGS.__flags.items(): print(k, "=", v) print() input_generator = inputs.test_pipeline() classifier_model = ImageClassifier( NUM_CLASSES, IMAGE_SIZE, batch_size=1, eval=True, checkpoint_file="output/model.ckpt-1000-5000-2500-1000") #sess = tf.Session() sess = tf.InteractiveSession() with sess.as_default(): sess.run(tf.global_variables_initializer()) sess.run(tf.local_variables_initializer()) classifier_model.load(sess) test_writer = tf.summary.FileWriter("output/eval/", sess.graph) emb = [] imgs = [] conf_matrix = [[0 for x in range(NUM_CLASSES)] for y in range(NUM_CLASSES)] total_pixels = 0 per_class_accuracy = [0 for i in range(NUM_CLASSES)] per_class_count = [0 for i in range(NUM_CLASSES)] try: step = 0 correct = 0 # counts correct predictions total = 0 # counts total evaluated start = datetime.now() for batch in input_generator: predictions, summary, image, label, class_img, image_tensor = classifier_model.evaluate_once( sess, batch) correct += np.sum(predictions) total += len(predictions) class_img.shape = [IMAGE_SIZE, IMAGE_SIZE] label.shape = [IMAGE_SIZE, IMAGE_SIZE] # calculate class-wise accuracies for actual, predicted in zip(label.flatten(), class_img.flatten()): per_class_count[lookup[unique[int(actual)]]] += 1 if lookup[unique[int(actual)]] == lookup[unique[int( predicted)]]: per_class_accuracy[lookup[unique[int(actual)]]] += 1 print(" ".join([ str(float(a) / float(b) * 100) + "%" if b else "100%" for a, b in zip(per_class_accuracy, per_class_count) ])) # generate confusion matrix for actual, predicted in zip(label.flatten(), class_img.flatten()): index_of_actual = lookup[unique[int(actual)]] index_of_predicted = lookup[unique[int(predicted)]] #print("Actual", names[index_of_actual], "Predicted", names[index_of_predicted]) conf_matrix[lookup[unique[int(actual)]]][lookup[unique[int( predicted)]]] += 1 image = Image.fromarray(np.uint8(np.asarray(image[0]))) label = np.vectorize(lambda x: unique[int(x)])(label) label.shape = [1, IMAGE_SIZE, IMAGE_SIZE] label = Image.fromarray(np.uint8(np.asarray(label[0]))) class_img = np.vectorize(lambda x: unique[int(x)])( class_img.flatten()) class_img.shape = [IMAGE_SIZE, IMAGE_SIZE] class_img = np.asarray(class_img, np.uint8) class_img = Image.fromarray(class_img, "L") predictions.shape = (IMAGE_SIZE, IMAGE_SIZE) error_img = Image.fromarray( np.asarray(predictions, dtype=np.uint8) * 255) label = label.convert(mode="RGB") label = label.point(color_lut) class_img = class_img.convert(mode="RGB") #class_img = class_img.point(lambda i: i * 1.2 + 10) class_img = class_img.point(color_lut) overlay_img = Image.blend(image, class_img, 0.4) images = [image, label, class_img, overlay_img, error_img] widths, heights = zip(*(i.size for i in images)) total_width = sum(widths) max_height = max(heights) new_im = Image.new('RGB', (total_width, max_height)) x_offset = 0 for im in images: new_im.paste(im, (x_offset, 0)) x_offset += im.size[0] new_im.save('classifications/%s.png' % step) if step % 10 is 0: now = datetime.now() elapsed = now - start average = elapsed / step if not step is 0 else 0 print( "Step %d, Evaluation Accuracy %g, Average Time %s/step, Elapsed Time %s" % (step, (correct / float(total)), average, elapsed)) sys.stdout.flush() if step % 10 is 0: test_writer.add_summary(summary, step) step += 1 except tf.errors.OutOfRangeError: pass #TODO: determine if this is still needed print() print("Done evaluating, completed in %d steps" % step) print("Per class accuracies:") print(" ".join([ str(float(a) / float(b) * 100) + "%" if b else "100%" for a, b in zip(per_class_accuracy, per_class_count) ])) print("Per class pixel counts:") print(" ".join([str(b) for b in per_class_count])) if FLAGS.confusion_matrix: with open("confusion_matrix.csv", "wb") as f: writer = csv.writer(f) for row in conf_matrix: writer.writerow(row)
def evaluate_source_common(val_loader: DataLoader, model: ImageClassifier, esem, source_classes: list, args: argparse.Namespace): temperature = 1 # switch to evaluate mode model.eval() esem.eval() common = [] target_private = [] all_confidece = list() all_consistency = list() all_entropy = list() all_labels = list() all_output = list() source_weight = torch.zeros(len(source_classes)).to(device) cnt = 0 with torch.no_grad(): for i, (images, labels) in enumerate(val_loader): images = images.to(device) # labels = labels.to(device) output, f = model(images) output = F.softmax(output, -1) / temperature yt_1, yt_2, yt_3, yt_4, yt_5 = esem(f) confidece = get_confidence(yt_1, yt_2, yt_3, yt_4, yt_5) entropy = get_entropy(yt_1, yt_2, yt_3, yt_4, yt_5) consistency = get_consistency(yt_1, yt_2, yt_3, yt_4, yt_5) all_confidece.extend(confidece) all_consistency.extend(consistency) all_entropy.extend(entropy) all_labels.extend(labels) for each_output in output: all_output.append(each_output) # for (each_output, each_score, label) in zip(output, score, labels): # if each_score >= args.threshold: # source_weight += each_output # cnt += 1 # if label in source_classes: # common.append(each_score) # else: # target_private.append(each_score) all_confidece = norm(torch.tensor(all_confidece)) all_consistency = norm(torch.tensor(all_consistency)) all_entropy = norm(torch.tensor(all_entropy)) all_score = (all_confidece + 1 - all_consistency + 1 - all_entropy) / 3 # args.threshold = torch.median(all_score) # print('threshold = {}'.format(args.threshold)) for i in range(len(all_score)): if all_score[i] >= args.threshold: source_weight += all_output[i] cnt += 1 if all_labels[i] in source_classes: common.append(all_score[i]) else: target_private.append(all_score[i]) hist, bin_edges = np.histogram(common, bins=10, range=(0, 1)) print(hist) # print(bin_edges) hist, bin_edges = np.histogram(target_private, bins=10, range=(0, 1)) print(hist) # print(bin_edges) source_weight = norm(source_weight / cnt) print('---source_weight---') print(source_weight) return source_weight
mlogging.glogger.info('start') # MODE = 'train' # MODE = 'eval' MODE = 'classify' if MODE == 'train': classes = ['diverse_normal_0.06', 'sensity'] # classes = ['1-normal', 'sensity'] # classes = ['2-bikini', 'all_naked'] # classes = ['2-bikini', '4-naked', '6-sex'] pclassifier = ImageClassifier( model_name='diversed_init_stage_porn_classifier', classes=classes, to_log_file=True) pclassifier.train(save_gen_imgs=False, use_tensorboard=True) elif MODE == 'eval': # classes = ['1-normal', 'sensity'] classes = ['2-bikini', 'all_naked'] # classes = ['2-bikini', '4-naked', '6-sex'] # model_id = 'soft_porn_classifier.20190622035912.01-1.0523' # (0.075, 0.9826) # model_id = 'soft_porn_classifier.20190622035912.02-0.5248' # (0.1830, 0.9304) # model_id = 'soft_porn_classifier.20190622035912.04-0.4564' # (0.2270, 0.9130) model_id = 'soft_porn_classifier.20190622035912.05-0.3722' # (0.3144, 0.8696) # model_id = 'soft_porn_classifier.20190622035912.06-0.3613' # (0.4999, 0.8348)
def train(train_source_iter: ForeverDataIterator, train_target_iter: ForeverDataIterator, model: ImageClassifier, domain_adv: DomainAdversarialLoss, esem, optimizer: SGD, lr_scheduler: StepwiseLR, epoch: int, source_class_weight, args: argparse.Namespace): batch_time = AverageMeter('Time', ':5.2f') data_time = AverageMeter('Data', ':5.2f') losses = AverageMeter('Loss', ':6.2f') cls_accs = AverageMeter('Cls Acc', ':3.1f') domain_accs = AverageMeter('Domain Acc', ':3.1f') progress = ProgressMeter( args.iters_per_epoch, [batch_time, data_time, losses, cls_accs, domain_accs], prefix="Epoch: [{}]".format(epoch)) # switch to train mode model.train() domain_adv.train() esem.eval() end = time.time() for i in range(args.iters_per_epoch): lr_scheduler.step() # measure data loading time data_time.update(time.time() - end) x_s, labels_s = next(train_source_iter) x_t, _ = next(train_target_iter) x_s = x_s.to(device) x_t = x_t.to(device) labels_s = labels_s.to(device) # compute output # x = torch.cat((x_s, x_t), dim=0) # y, f = model(x) # y_s, y_t = y.chunk(2, dim=0) # f_s, f_t = f.chunk(2, dim=0) y_s, f_s = model(x_s) y_t, f_t = model(x_t) with torch.no_grad(): yt_1, yt_2, yt_3, yt_4, yt_5 = esem(f_t) confidece = get_confidence(yt_1, yt_2, yt_3, yt_4, yt_5) entropy = get_entropy(yt_1, yt_2, yt_3, yt_4, yt_5) consistency = get_consistency(yt_1, yt_2, yt_3, yt_4, yt_5) w_t = (1 - entropy + 1 - consistency + confidece) / 3 w_s = torch.tensor([source_class_weight[i] for i in labels_s]).to(device) cls_loss = F.cross_entropy(y_s, labels_s) transfer_loss = domain_adv(f_s, f_t, w_s.detach(), w_t.to(device).detach()) domain_acc = domain_adv.domain_discriminator_accuracy loss = cls_loss + transfer_loss * args.trade_off cls_acc = accuracy(y_s, labels_s)[0] losses.update(loss.item(), x_s.size(0)) cls_accs.update(cls_acc.item(), x_s.size(0)) domain_accs.update(domain_acc.item(), x_s.size(0)) # compute gradient and do SGD step optimizer.zero_grad() loss.backward() optimizer.step() # measure elapsed time batch_time.update(time.time() - end) end = time.time() if i % args.print_freq == 0: progress.display(i)
from flask import Flask, render_template, request, jsonify, Response import io from PIL import Image from model import ImageClassifier #import numpy as np app = Flask(__name__) classifier = ImageClassifier() @app.route('/') def index(): return render_template('identifier.html') @app.route('/identify', methods=['POST']) def identify(): file_object = request.files['image'] image = file_object.read() print(type(image)) predictions = image # img_bytes = io.BytesIO(image) # predictions = classifier.predict(image) return Response(response=predictions, status=200, mimetype="text/plain") if __name__ == '__main__': #threaded=True creates separate thread for each person who visits website #can set debug=True, but turn it OFF before deploying in production app.run(host='0.0.0.0', port='5002', threaded=True)