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)
