def get_model(opt):
state_dict = None
if opt.pretrained and opt.network != 'resnext_wsl':
state_dict = torch.utils.model_zoo.load_url(model_urls[opt.network+str(opt.layers)])
if opt.network == 'resnet':
model = resnet(opt.classes, opt.layers, state_dict)
elif opt.network == 'resnext':
model = resnext(opt.classes, opt.layers, state_dict)
elif opt.network == 'resnext_wsl':
# resnext_wsl must specify the opt.battleneck_width parameter
opt.network = 'resnext_wsl_32x' + str(opt.battleneck_width) +'d'
model = resnext_wsl(opt.classes, opt.battleneck_width)
elif opt.network == 'vgg':
model = vgg_bn(opt.classes, opt.layers, state_dict)
elif opt.network == 'densenet':
pattern = re.compile(
r'^(.*denselayer\d+\.(?:norm|relu|conv))\.((?:[12])\.(?:weight|bias|running_mean|running_var))$')
for key in list(state_dict.keys()):
res = pattern.match(key)
if res:
new_key = res.group(1) + res.group(2)
state_dict[new_key] = state_dict[key]
del state_dict[key]
model = densenet(opt.classes, opt.layers, state_dict)
elif opt.network == 'inception_v3':
model = inception_v3(opt.classes, opt.layers, state_dict)
elif opt.network == 'dpn':
model = dpn(opt.classes, opt.layers, opt.pretrained)
elif opt.network == 'effnet':
model = effnet(opt.classes, opt.layers, opt.pretrained)
# elif opt.network == 'pnasnet_m':
# model = pnasnet_m(opt.classes, opt.layers, opt.pretrained)
return model
def eval(hps):
images, labels = input.build_input(FLAGS.dataset, FLAGS.eval_data_path,
hps.batch_size, FLAGS.mode)
cls_resnet = model.resnet(hps, images, labels,
FLAGS.mode) #initialize class resnet
cls_resnet.build_graph()
saver = tf.train.Saver()
summary_writer = tf.summary.FileWriter(FLAGS.eval_dir)
sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True))
tf.train.start_queue_runners(sess)
best_precision = 0.0
while True:
try:
ckpt_state = tf.train.get_checkpoint_state(FLAGS.log_root)
except tf.errors.OutOfRangeError as e:
tf.logging.error('Cannot restore checkpoint : %s', e)
continue
if not (ckpt_state and ckpt_state.model_checkpoint_path):
tf.logging.error('No model to eval yet at %s', FLAGS.log_root)
continue
tf.logging.info('Loading checkpoint %s',
ckpt_state.model_checkpoint_path)
saver.restore(sess, ckpt_state.model_checkpoint_path)
total_prediction, correct_prediction = 0, 0
for _ in six.moves.range(FLAGS.eval_batch_count):
(summaries, loss, predictions, truth, train_step) = sess.run([
cls_resnet.summaries, cls_resnet.cost, cls_resnet.predictions,
cls_resnet.label, cls_resnet.global_step
])
truth = np.argmax(truth, axis=1)
predictions = np.argmax(predictions, axis=1)
correct_prediction += np.sum(truth == predictions)
total_prediction += predictions.shape[0]
precision = 1.0 * correct_prediction / total_prediction
best_precision = max(precision, best_precision)
precision_summ = tf.Summary()
precision_summ.value.add(tag='Precision', simple_value=precision)
summary_writer.add_summary(precision_summ, train_step)
best_precision_summ = tf.Summary()
best_precision_summ.value.add(tag='Best Precision',
simple_value=best_precision)
summary_writer.add_summary(best_precision_summ, train_step)
summary_writer.add_summary(summaries, train_step)
tf.logging.info(
'loss:%.3f , precisions: %.3f , best_precision : %.3f' %
(loss, precision, best_precision))
summary_writer.flush()
if FLAGS.eval_once:
break
time.sleep(60)
def main():
# Define hyper-parameter
learning_rate = 0.01
batch_size = 12
epoch_number = 1
steps_to_validate = 12
resnet_layer_number = 32 # 20
# Load training dataset
X_train, Y_train, X_test, Y_test = load_data()
# Define the model
X = tf.placeholder("float", [None, 32, 32, 3])
Y = tf.placeholder("float", [None, 10])
net = model.resnet(X, resnet_layer_number)
cross_entropy = -tf.reduce_sum(Y * tf.log(net))
opt = tf.train.MomentumOptimizer(learning_rate, 0.9)
train_op = opt.minimize(cross_entropy)
correct_prediction = tf.equal(tf.argmax(net, 1), tf.argmax(Y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
# Define other tools
saver = tf.train.Saver()
checkpoint = tf.train.latest_checkpoint("./checkpoint/")
init_op = tf.initialize_all_variables()
# Start the session
with tf.Session() as sess:
sess.run(init_op)
# Restore from checkpoint
if checkpoint:
print("Restore checkpoint from: {}".format(checkpoint))
#saver.restore(sess, checkpoint)
# Start training
for epoch_index in range(epoch_number):
for i in range(0, 50000, batch_size):
feed_dict = {
X: X_train[i:i + batch_size],
Y: Y_train[i:i + batch_size]
}
sess.run([train_op], feed_dict=feed_dict)
if i % steps_to_validate == 0:
saver.save(sess, './checkpoint/', global_step=i)
validate_start_index = 0
validate_end_index = validate_start_index + batch_size
valiate_accuracy_value = sess.run(
[accuracy],
feed_dict={
X: X_test[validate_start_index:validate_end_index],
Y: Y_test[validate_start_index:validate_end_index]
})
print("Epoch: {}, image id: {}, validate accuracy: {}".
format(epoch_index, i, valiate_accuracy_value))
def main():
# Define hyper-parameter
learning_rate = 0.01
batch_size = 12
epoch_number = 1
steps_to_validate = 12
resnet_layer_number = 32 # 20
# Load training dataset
X_train, Y_train, X_test, Y_test = load_data()
# Define the model
X = tf.placeholder("float", [None, 32, 32, 3])
Y = tf.placeholder("float", [None, 10])
net = model.resnet(X, resnet_layer_number)
cross_entropy = -tf.reduce_sum(Y * tf.log(net))
opt = tf.train.MomentumOptimizer(learning_rate, 0.9)
train_op = opt.minimize(cross_entropy)
correct_prediction = tf.equal(tf.argmax(net, 1), tf.argmax(Y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
# Define other tools
saver = tf.train.Saver()
checkpoint = tf.train.latest_checkpoint("./checkpoint/")
init_op = tf.initialize_all_variables()
# Start the session
with tf.Session() as sess:
sess.run(init_op)
# Restore from checkpoint
if checkpoint:
print("Restore checkpoint from: {}".format(checkpoint))
#saver.restore(sess, checkpoint)
# Start training
for epoch_index in range(epoch_number):
for i in range(0, 50000, batch_size):
feed_dict = {
X: X_train[i:i + batch_size],
Y: Y_train[i:i + batch_size]
}
sess.run([train_op], feed_dict=feed_dict)
if i % steps_to_validate == 0:
saver.save(sess, './checkpoint/', global_step=i)
validate_start_index = 0
validate_end_index = validate_start_index + batch_size
valiate_accuracy_value = sess.run(
[accuracy],
feed_dict={
X: X_test[validate_start_index:validate_end_index],
Y: Y_test[validate_start_index:validate_end_index]
})
print("Epoch: {}, image id: {}, validate accuracy: {}".format(
epoch_index, i, valiate_accuracy_value))
def get_model(model=None):
if model is None:
model = resnet(n_classes=5)
model = load_model_state(CHECKPOINT_PATH,
model,
is_remote_paths=False,
cleanup_cache=False)
return model
def main(opt):
if torch.cuda.is_available():
device = torch.device('cuda')
torch.cuda.set_device(opt.gpu_id)
else:
device = torch.device('cpu')
if opt.network == 'resnet':
model = resnet(opt.classes, opt.layers)
elif opt.network == 'resnext':
model = resnext(opt.classes, opt.layers)
elif opt.network == 'resnext_wsl':
# resnext_wsl must specify the opt.battleneck_width parameter
opt.network = 'resnext_wsl_32x' + str(opt.battleneck_width) + 'd'
model = resnext_wsl(opt.classes, opt.battleneck_width)
elif opt.network == 'vgg':
model = vgg_bn(opt.classes, opt.layers)
elif opt.network == 'densenet':
model = densenet(opt.classes, opt.layers)
elif opt.network == 'inception_v3':
model = inception_v3(opt.classes, opt.layers)
model = nn.DataParallel(model, device_ids=[7, 6])
model = model.to(device)
train_data, _ = utils.read_data(os.path.join(opt.root_dir, opt.train_dir),
os.path.join(opt.root_dir,
opt.train_label),
val_num=1)
val_transforms = my_transform(False, opt.crop_size)
dataset = WeatherDataset(train_data[0], train_data[1], val_transforms)
loader = torch.utils.data.DataLoader(dataset,
batch_size=opt.batch_size,
shuffle=False,
num_workers=2)
model.load_state_dict(
torch.load(opt.model_dir + '/' + opt.network + '-' + str(opt.layers) +
'-' + str(crop_size) + '_model.ckpt'))
im_labels = []
for name, label in zip(im_names, labels):
im_labels.append([name, label])
header = ['filename', 'type']
utils.mkdir(opt.results_dir)
result = opt.network + '-' + str(
opt.layers) + '-' + str(crop_size) + '_result.csv'
filename = os.path.join(opt.results_dir, result)
with open(filename, 'w', encoding='utf-8') as f:
f_csv = csv.writer(f)
f_csv.writerow(header)
f_csv.writerows(im_labels)
def train():
with tf.Graph().as_default():
global_step = tf.contrib.framework.get_or_create_global_step()
with tf.device('/cpu:0'):
images, labels = model.altered_input()
logits = model.resnet(images, scope='resnet1', istrain=True)
loss = model.loss(logits, labels, scope='loss1')
accuracy = model.accuracy(logits, labels, scope='accuracy')
train_op = model.train(loss, global_step)
class Log(tf.train.SessionRunHook):
def begin(self):
self.step = -1
self.start_time = time.time()
self.total_time = time.time()
def before_run(self, run_context):
self.step += 1
return tf.train.SessionRunArgs([loss, accuracy])
def after_run(self, run_context, run_values):
'''
logs loss, examples per second, seconds per batch
'''
if not self.step % write_frequency:
curtime = time.time() #current time
duration = curtime - self.start_time #start time
total_dur = curtime - self.total_time
ts = total_dur % 60
tm = (total_dur // 60) % 60
th = total_dur // 3600
self.start_time = curtime
[loss, accuracy] = run_values.results
ex_per_sec = write_frequency * batch_size / duration
sec_per_batch = float(duration / write_frequency)
string = (
'step: %d, accuracy:%.3f loss: %.3f, examples/sec: %.2f, sec/batch: %1f, total time: %dh %dm %ds'
)
print(string % (self.step, accuracy, loss, ex_per_sec,
sec_per_batch, th, tm, ts))
with tf.train.MonitoredTrainingSession(
checkpoint_dir=train_dir, #for checkpoint writing
hooks=[ #things to do while running the session
tf.train.StopAtStepHook(last_step=max_steps),
tf.train.NanTensorHook(loss),
Log()
],
save_summaries_steps=100) as sess:
while not sess.should_stop():
sess.run(train_op)
def compile_model(input_shape, depth, NUM_CLASSES):
model = resnet(input_shape=input_shape, depth=depth, num_classes=NUM_CLASSES)
opt = tf.keras.optimizers.Adam
model.compile(loss='categorical_crossentropy',
optimizer=opt(lr=lr_schedule(0)),
metrics=['accuracy'])
model.summary()
print('ResNet%dv2' % (depth))
return model
def main():
global args
conf = configparser.ConfigParser()
args = parser.parse_args()
conf.read(args.config)
DATA_DIR = conf.get("subject_level", "data")
LABEL_DIR = conf.get("subject_level", "label")
create_dir_not_exist(LABEL_DIR)
os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu
if not args.model:
print("Usage: --model -m\n\tpath to the model")
sys.exit()
model = resnet()
model = DataParallel(model)
trained_net = torch.load(args.model)
model.load_state_dict(trained_net['state_dict'])
model = model.cuda()
result_list = []
for class_index, class_name in enumerate(CLASSES_NAME):
class_dir = os.path.join(DATA_DIR, class_name)
patient_list = os.listdir(class_dir)
patient_list = [
os.path.join(class_dir, patient) for patient in patient_list
if os.path.isdir(os.path.join(class_dir, patient))
]
print('---------- {} ----------'.format(class_name))
for i, patient_dir in enumerate(patient_list):
slice_list = os.listdir(patient_dir)
if len(slice_list) < 10:
continue
checkSuffix(slice_list)
slice_list = [s for s in slice_list if s[:2] != "._"]
slice_list = [os.path.join(patient_dir, s) for s in slice_list]
scorelist = test(slice_list, class_index, model)
result = np.insert(scorelist, 0, class_index)
print('{} ----- {}'.format(i, len(patient_list)))
result_list.append(list(result))
with open(os.path.join(LABEL_DIR, 'result.csv'), 'w') as f:
f_csv = csv.writer(f)
f_csv.writerows(result_list)
def main():
global args
conf = configparser.ConfigParser()
args = parser.parse_args()
conf.read(args.config)
TEST_DIR = conf.get("resnet", "test")
LOG_DIR = conf.get("resnet", "log")
create_dir_not_exist(LOG_DIR)
test_list = [os.path.join(TEST_DIR, item) for item in os.listdir(TEST_DIR)]
test_list = checkSuffix(test_list)
os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu
if not args.model:
print("Usage: --model -m\n\tpath to the model")
sys.exit()
model = resnet()
criterion = nn.CrossEntropyLoss().cuda()
model = DataParallel_withLoss(model, criterion)
trained_net = torch.load(args.model)
model.load_state_dict(trained_net['state_dict'])
model = model.cuda()
vote_pred = np.zeros(len(test_list))
vote_score = np.zeros(len(test_list))
targetlist, scorelist, predlist = test(test_list, model, criterion)
report = classification_report(y_true=targetlist,
y_pred=predlist,
target_names=["Normal", "CAP", "COVID-19"])
print(report)
def main(args):
config = Config()
train_data = Dataset(TRAIN_DATA_DIR, config)
batch_count = train_data.batch_count
train_xs, train_ys, train_org = train_data.get_batch_pipeline()
net = resnet(mode='train', config=config, checkpoints_root_dir=CKPT_DIR)
# Load Existed Models
if PRE_MODEL == 'resnet':
net.load_weights(PRETRAINED_MODEL_PATH)
elif PRE_MODEL == 'last':
net.load_weights(net.find_last())
else:
net.initialize_weights()
# Train Model
net.train(train_xs, train_ys, batch_count)
if not os.path.exists(MODEL_SAVE_DIR):
os.makedirs(MODEL_SAVE_DIR)
savepath = os.path.join(MODEL_SAVE_DIR, MODEL_SAVE_NAME)
net.save(savepath)
return
# Test Model
val_data = Dataset(VAL_DATA_DIR)
val_xs, val_ys, val_org = val_data.get_batch_pipeline()
net.test(val_xs, val_ys, val_org)
import tensorflow as tf
import tensorflow.contrib.layers as cl
from model import resnet
# Data loading and preprocessing
import tflearn
from tflearn.data_utils import shuffle, to_categorical
from tflearn.datasets import cifar10
(cifar10_X, cifar10_Y), (X_test, Y_test) = cifar10.load_data()
cifar10_X = np.transpose(cifar10_X, [0, 3, 1, 2])
cifar10_Y = to_categorical(cifar10_Y, 10)
X_test = np.transpose(X_test, [0, 3, 1, 2])
Y_test = to_categorical(Y_test, 10)
# cnn = normal_cnn_cifar
cnn = resnet('resnet', 5, grid=True)
WEIGHT_DECAY = 1e-4
l2 = cl.l2_regularizer(WEIGHT_DECAY)
batch_size = 100
with tf.Graph().as_default():
X = tf.placeholder(shape=(batch_size, 3, 32, 32), dtype=tf.float32)
Y = tf.placeholder(shape=(batch_size, 10), dtype=tf.float32)
is_training = tf.placeholder(shape=(), dtype=tf.bool)
lr = tf.Variable(0.1,
name='learning_rate',
trainable=False,
dtype=tf.float32)
decay_lr_op = tf.assign(lr, lr / 10)
def aug_image(x):
res_sizes = utils.get_resolutions()
# get the specified image resolution
IMAGE_HEIGHT, IMAGE_WIDTH, IMAGE_SIZE = utils.get_specified_res(
res_sizes, phone, resolution)
# disable gpu if specified
config = tf.ConfigProto(
device_count={'GPU': 0}) if use_gpu == "false" else None
# create placeholders for input images
x_ = tf.compat.v1.placeholder(tf.float32, [None, IMAGE_SIZE])
x_image = tf.reshape(x_, [-1, IMAGE_HEIGHT, IMAGE_WIDTH, 3])
# generate enhanced image
enhanced = resnet(x_image)
with tf.compat.v1.Session(config=config) as sess:
# load pre-trained model
saver = tf.train.Saver()
saver.restore(sess, "models_orig/" + phone)
test_dir = "input/"
print_dir = "output/"
test_photos = [
f for f in os.listdir(test_dir) if os.path.isfile(test_dir + f)
]
print(
"--------------------------------------------------------------------------------"
train_loader = DataLoader(dataset_train,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.num_worker)
test_loader = DataLoader(dataset_test,
batch_size=args.batch_size_test,
shuffle=False,
num_workers=args.num_worker)
# there are 10 classes so the dataset name is cifar-10
classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse',
'ship', 'truck')
print('==> Making model..')
net = resnet()
net = net.to(device)
num_params = sum(p.numel() for p in net.parameters() if p.requires_grad)
print('The number of parameters of model is', num_params)
# print(net)
if args.resume is not None:
checkpoint = torch.load('./save_model/' + args.resume)
net.load_state_dict(checkpoint['net'])
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(),
lr=0.1,
momentum=0.9,
weight_decay=1e-4)
import model
import numpy as np
import tensorflow as tf
IMAGE_SIZE = 32
IMAGE_CHANNELS = 3
image = tf.placeholder(tf.float32,
[None, IMAGE_SIZE, IMAGE_SIZE, IMAGE_CHANNELS])
label = tf.placeholder(tf.float32,
[None, IMAGE_SIZE, IMAGE_SIZE, IMAGE_CHNNELS])
learning_rate = tf.placeholder(tf.float32, [])
net = model.resnet(image, 1)
cross_entropy = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(labels=label, logits=net))
opt = tf.MomentumOptimizer(learning_rate, 0.9)
train_op = opt.minimize(cross_entropy)
correct_pre = tf.equal(tf.argmax(net, 1), tf.argmax(label, 1))
accuracy = tf.reduce_mean(tf.cast(correct_pre, dtype=tf.float32))
saver = tf.train.saver()
sess = tf.Session()
sess.run(tf.global_variables_initializer())
checkpoint = tf.train.latest_checkpoint('.')
if checkpoint is not None:
print('Restoring from checkpoint ' + checkpoint)
saver.restore(sess, ckeckpoint)
else:
print('Could not find the checkpoint to restore')
sess.close()
x = mx.sym.var('data')
y = vgg19(x)
print('\n=== the symbolic program of net===')
interals = y.get_internals()
print(interals.list_outputs())
vgg19_relu5_4 = g.SymbolBlock([interals['vgg0_conv15_fwd_output']], x, params=vgg19.collect_params())
vgg19_relu5_4.hybridize()
# d_net = g.SymbolBlock([interals['discriminator0_d_dense0_fwd_output']], x, params=d_net_sigm.collect_params())
# vgg19_relu5_4.collect_params().reset_ctx(ctx=ctx)
enhanced = resnet()
enhanced.hybridize()
blur_op = blur()
blur_op.hybridize()
#dont forget about softmax
discrim_predictions_logits = adversarial()
discrim_predictions_logits.hybridize()
enhanced.collect_params().initialize(mx.init.Normal(0.02), ctx=ctx)
discrim_predictions_logits.collect_params().initialize(mx.init.Normal(0.02), ctx=ctx)
G_trainer = g.Trainer(enhanced.collect_params(), 'Adam', {'learning_rate': learning_rate})
D_trainer = g.Trainer(discrim_predictions_logits.collect_params(), 'Adam', {'learning_rate': learning_rate})
import torch.backends.cudnn as cudnn
import torch.optim
import torch.utils.data
import torchvision.transforms as transforms
import torchvision.datasets as datasets
from torchvision import datasets, models, transforms
from model.resnet import *
# from tensorboardX import SummaryWriter
from logger import Logger
logger = Logger('./logs')
model = resnet()
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_loader = torch.utils.data.DataLoader(
datasets.CIFAR10(root='./data', train=True, transform=transforms.Compose([
transforms.RandomHorizontalFlip(),
transforms.RandomCrop(32, 4),
transforms.ToTensor(),
normalize,
]), download=True),
batch_size=args.batch_size, shuffle=True,
num_workers=args.workers, pin_memory=True)
val_loader = torch.utils.data.DataLoader(
def train(hps):
"""
:param hparams:
:return:
"""
"""training loop"""
images, labels = input.build_input(FLAGS.dataset, FLAGS.train_data_path,
hps.batch_size, FLAGS.mode)
cls_resnet = model.resnet(hps, images, labels,
FLAGS.mode) #initialize class resnet
cls_resnet.build_graph()
param_stats = tf.contrib.tfprof.model_analyzer.print_model_analysis(
tf.get_default_graph(),
tfprof_options=tf.contrib.tfprof.model_analyzer.FLOAT_OPS_OPTIONS
) #this function for profiling
print param_stats.total_parameters
sys.stdout.write('total_params: %d\n' * param_stats.total_parameters)
truth = tf.argmax(cls_resnet.label, axis=1) # onehot --> cls
predictions = tf.argmax(cls_resnet.predictions, axis=1) #onehot --> cls
precision = tf.reduce_mean(tf.to_float(tf.equal(predictions,
truth))) #mean average
summary_hook = tf.train.SummarySaverHook(save_steps=100, output_dir=FLAGS.train_dir,\
summary_op=tf.summary.merge([cls_resnet.summaries, tf.summary.scalar('Precision', precision)]))
logging_hook = tf.train.LoggingTensorHook(tensors={
'step': cls_resnet.global_step,
'loss': cls_resnet.cost,
'precision': precision
},
every_n_iter=100)
class _LearningRateSetterHook(tf.train.SessionRunHook):
def begin(self):
self._lrn_rate = 0.1
def before_run(self, run_context):
return tf.train.SessionRunArgs(
cls_resnet.global_step,
feed_dict={cls_resnet.lrn_rate: self._lrn_rate})
def after_run(self, run_context, run_values):
train_step = run_values.results
if train_step < 40000:
self._lrn_rate = 0.01
elif train_step < 60000:
self._lrn_rate = 0.001
elif train_step < 80000:
self._lrn_rate = 0.0001
else:
self._lrn_rate = 0.00001
with tf.train.MonitoredTrainingSession(
checkpoint_dir=FLAGS.log_root,
hooks=[logging_hook, _LearningRateSetterHook()],
chief_only_hooks=[summary_hook],
save_summaries_steps=0,
config=tf.ConfigProto(allow_soft_placement=True)) as mon_sess:
while not mon_sess.should_stop():
mon_sess.run(cls_resnet.train_op)
def main():
global args, best_prec1
best_prec1 = 1e6
args = parser.parse_args()
args.original_lr = 1e-6
args.lr = 1e-6
args.momentum = 0.95
args.decay = 5 * 1e-4
args.start_epoch = 0
args.epochs = 100
args.steps = [-1, 1, 20, 50]
args.scales = [1, 1, 0.5, 0.5]
args.workers = 0
args.seed = time.time()
args.print_freq = 30
wandb.config.update(args)
wandb.run.name = f"Default_{wandb.run.name}" if (
args.task == wandb.run.name) else f"{args.task}_{wandb.run.name}"
conf = configparser.ConfigParser()
conf.read(args.config)
TRAIN_DIR = conf.get("resnet", "train")
VALID_DIR = conf.get("resnet", "valid")
TEST_DIR = conf.get("resnet", "test")
LOG_DIR = conf.get("resnet", "log")
create_dir_not_exist(LOG_DIR)
train_list = [
os.path.join(TRAIN_DIR, item) for item in os.listdir(TRAIN_DIR)
]
train_list = checkSuffix(train_list)
val_list = [
os.path.join(VALID_DIR, item) for item in os.listdir(VALID_DIR)
]
val_list = checkSuffix(val_list)
os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu
torch.cuda.manual_seed(args.seed)
model = resnet()
model = model.cuda()
criterion = nn.CrossEntropyLoss().cuda()
optimizer = torch.optim.Adam(model.parameters(),
args.lr,
betas=(0.9, 0.999),
eps=1e-08,
weight_decay=args.decay)
model = DataParallel_withLoss(model, criterion)
for epoch in range(args.start_epoch, args.epochs):
adjust_learning_rate(optimizer, epoch)
train(train_list, model, criterion, optimizer, epoch)
prec1 = validate(val_list, model, criterion, epoch)
with open(os.path.join(LOG_DIR, args.task + ".txt"), "a") as f:
f.write("epoch " + str(epoch) + " CELoss: " + str(float(prec1)))
f.write("\n")
wandb.save(os.path.join(LOG_DIR, args.task + ".txt"))
is_best = prec1 < best_prec1
best_prec1 = min(prec1, best_prec1)
print(' * best CELoss {CELoss:.3f} '.format(CELoss=best_prec1))
save_checkpoint(
{
'epoch': epoch + 1,
'arch': args.pre,
'state_dict': model.state_dict(),
'best_prec1': best_prec1,
'optimizer': optimizer.state_dict(),
},
is_best,
args.task,
epoch=epoch,
path=os.path.join(LOG_DIR, args.task))
def main():
args = parser.parse_args()
print('parsed options:', vars(args))
epoch_step = json.loads(args.epoch_step)
check_manual_seed(args.seed)
os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu_id
ds = check_dataset(args.dataset, args.dataroot, args.augment,
args.download)
if args.dataset == "awa2":
image_shape, num_classes, train_dataset, test_dataset, all_labels = ds
all_labels = all_labels.to("cuda:0")
else:
image_shape, num_classes, train_dataset, test_dataset = ds
all_labels = torch.eye(num_classes).to("cuda:0")
if args.ssl:
num_labelled = args.num_labelled
num_unlabelled = len(train_dataset) - num_labelled
if args.dataset == "awa2":
labelled_set, unlabelled_set = data.random_split(
train_dataset, [num_labelled, num_unlabelled])
else:
td_targets = train_dataset.targets if args.dataset == "cifar10" else train_dataset.labels
labelled_idxs, unlabelled_idxs = x_u_split(td_targets,
num_labelled,
num_classes)
labelled_set, unlabelled_set = [
Subset(train_dataset, labelled_idxs),
Subset(train_dataset, unlabelled_idxs)
]
labelled_set = data.ConcatDataset(
[labelled_set for i in range(num_unlabelled // num_labelled + 1)])
labelled_set, _ = data.random_split(
labelled_set, [num_unlabelled,
len(labelled_set) - num_unlabelled])
train_dataset = Joint(labelled_set, unlabelled_set)
def _init_fn(worker_id):
np.random.seed(args.seed)
train_loader = data.DataLoader(train_dataset,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.n_workers,
worker_init_fn=_init_fn)
test_loader = data.DataLoader(test_dataset,
batch_size=args.eval_batch_size,
shuffle=False,
num_workers=args.n_workers,
worker_init_fn=_init_fn)
model, params = resnet(args.depth, args.width, num_classes, image_shape[0])
if args.lp:
num_flow_classes = num_classes if not num_classes % 2 else num_classes + 1
prior_y = MultivariateNormal(
torch.zeros(num_flow_classes).to("cuda:0"),
torch.eye(num_flow_classes).to("cuda:0"))
num_flows = 3
flows = [
NSF_CL(dim=num_flow_classes, K=8, B=3, hidden_dim=16)
for _ in range(num_flows)
]
convs = [
Invertible1x1Conv(dim=num_flow_classes) for i in range(num_flows)
]
flows = list(itertools.chain(*zip(convs, flows)))
model_y = NormalizingFlowModel(prior_y, flows,
num_flow_classes).to("cuda:0")
optimizer_y = Adam(model_y.parameters(), lr=1e-3, weight_decay=1e-5)
def create_optimizer(args, lr):
print('creating optimizer with lr = ', lr)
return SGD([v for v in params.values() if v.requires_grad],
lr,
momentum=0.9,
weight_decay=args.weight_decay)
optimizer = create_optimizer(args, args.lr)
epoch = 0
print('\nParameters:')
print_tensor_dict(params)
n_parameters = sum(p.numel() for p in params.values() if p.requires_grad)
print('\nTotal number of parameters:', n_parameters)
meter_loss = tnt.meter.AverageValueMeter()
if args.dataset == "awa2":
classacc = tnt.meter.AverageValueMeter()
else:
classacc = tnt.meter.ClassErrorMeter(accuracy=True)
timer_train = tnt.meter.TimeMeter('s')
timer_test = tnt.meter.TimeMeter('s')
if not os.path.exists(args.save):
os.mkdir(args.save)
global counter
counter = 0
def compute_loss(sample):
if not args.ssl:
inputs = cast(sample[0], args.dtype)
targets = cast(sample[1], 'long')
y = data_parallel(model, inputs, params, sample[2],
list(range(args.ngpu))).float()
if args.dataset == "awa2":
return F.binary_cross_entropy_with_logits(y,
targets.float()), y
else:
return F.cross_entropy(y, targets), y
else:
global counter
l = sample[0]
u = sample[1]
inputs_l = cast(l[0], args.dtype)
targets_l = cast(l[1], 'long')
inputs_u = cast(u[0], args.dtype)
y_l = data_parallel(model, inputs_l, params, sample[2],
list(range(args.ngpu))).float()
y_u = data_parallel(model, inputs_u, params, sample[2],
list(range(args.ngpu))).float()
if args.dataset == "awa2":
loss = F.binary_cross_entropy_with_logits(
y_l, targets_l.float())
else:
loss = F.cross_entropy(y_l, targets_l)
if args.min_entropy:
if args.dataset == "awa2":
labels_pred = F.sigmoid(y_u)
entropy = -torch.sum(labels_pred * torch.log(labels_pred),
dim=1)
else:
labels_pred = F.softmax(y_u, dim=1)
entropy = -torch.sum(labels_pred * torch.log(labels_pred),
dim=1)
if counter >= 10:
loss_entropy = args.unl_weight * torch.mean(entropy)
loss += loss_entropy
elif args.semantic_loss:
if args.dataset == "awa2":
labels_pred = F.sigmoid(y_u)
else:
labels_pred = F.softmax(y_u, dim=1)
part1 = torch.stack([
labels_pred**all_labels[i]
for i in range(all_labels.shape[0])
])
part2 = torch.stack([(1 - labels_pred)**(1 - all_labels[i])
for i in range(all_labels.shape[0])])
sem_loss = -torch.log(
torch.sum(torch.prod(part1 * part2, dim=2), dim=0))
if counter >= 10:
semantic_loss = args.unl_weight * torch.mean(sem_loss)
loss += semantic_loss
elif args.lp:
model_y.eval()
if args.dataset == "awa2":
labels_pred = F.sigmoid(y_u)
else:
labels_pred = F.softmax(y_u, dim=1)
if num_classes % 2:
labels_pred = torch.cat(
(labels_pred, torch.zeros(
(labels_pred.shape[0], 1)).to("cuda:0")),
dim=1)
_, nll_ypred = model_y(labels_pred)
if counter >= 10:
loss_nll_ypred = args.unl_weight * torch.mean(nll_ypred)
loss += loss_nll_ypred
model_y.train()
optimizer_y.zero_grad()
if args.dataset == "awa2":
a = targets_l.float() * 120. + (1 -
targets_l.float()) * 1.1
b = (1 -
targets_l.float()) * 120. + targets_l.float() * 1.1
beta_targets = Beta(a, b).rsample()
if num_classes % 2:
beta_targets = torch.cat(
(beta_targets,
torch.zeros(
(beta_targets.shape[0], 1)).to("cuda:0")),
dim=1)
zs, nll_y = model_y(beta_targets)
else:
one_hot_targets = F.one_hot(torch.tensor(targets_l),
num_classes).float()
one_hot_targets = one_hot_targets * 120 + (
1 - one_hot_targets) * 1.1
dirichlet_targets = torch.stack(
[Dirichlet(i).sample() for i in one_hot_targets])
zs, nll_y = model_y(dirichlet_targets)
loss_nll_y = torch.mean(nll_y)
loss_nll_y.backward()
optimizer_y.step()
return loss, y_l
def compute_loss_test(sample):
inputs = cast(sample[0], args.dtype)
targets = cast(sample[1], 'long')
y = data_parallel(model, inputs, params, sample[2],
list(range(args.ngpu))).float()
if args.dataset == "awa2":
return F.binary_cross_entropy_with_logits(y, targets.float()), y
else:
return F.cross_entropy(y, targets), y
def log(t, state):
torch.save(
dict(params=params,
epoch=t['epoch'],
optimizer=state['optimizer'].state_dict()),
os.path.join(args.save, 'model.pt7'))
z = {**vars(args), **t}
with open(os.path.join(args.save, 'log.txt'), 'a') as flog:
flog.write('json_stats: ' + json.dumps(z) + '\n')
print(z)
def on_sample(state):
state['sample'].append(state['train'])
def on_forward(state):
loss = float(state['loss'])
if args.dataset == "awa2":
if not args.ssl or not state['train']:
acc = calculate_accuracy(F.sigmoid(state['output'].data),
state['sample'][1])
else:
acc = calculate_accuracy(F.sigmoid(state['output'].data),
state['sample'][0][1])
classacc.add(acc)
else:
if not args.ssl or not state['train']:
classacc.add(state['output'].data, state['sample'][1])
else:
classacc.add(state['output'].data, state['sample'][0][1])
meter_loss.add(loss)
if state['train']:
state['iterator'].set_postfix(loss=loss)
def on_start(state):
state['epoch'] = epoch
def on_start_epoch(state):
classacc.reset()
meter_loss.reset()
timer_train.reset()
state['iterator'] = tqdm(train_loader, dynamic_ncols=True)
epoch = state['epoch'] + 1
if epoch in epoch_step:
lr = state['optimizer'].param_groups[0]['lr']
state['optimizer'] = create_optimizer(args,
lr * args.lr_decay_ratio)
def on_end_epoch(state):
train_loss = meter_loss.value()
train_acc = classacc.value()[0]
train_time = timer_train.value()
meter_loss.reset()
classacc.reset()
timer_test.reset()
with torch.no_grad():
engine.test(compute_loss_test, test_loader)
test_acc = classacc.value()[0]
print(
log(
{
"train_loss": train_loss[0],
"train_acc": train_acc,
"test_loss": meter_loss.value()[0],
"test_acc": test_acc,
"epoch": state['epoch'],
"num_classes": num_classes,
"n_parameters": n_parameters,
"train_time": train_time,
"test_time": timer_test.value(),
}, state))
print('==> id: %s (%d/%d), test_acc: \33[91m%.2f\033[0m' %
(args.save, state['epoch'], args.epochs, test_acc))
global counter
counter += 1
engine = Engine()
engine.hooks['on_sample'] = on_sample
engine.hooks['on_forward'] = on_forward
engine.hooks['on_start_epoch'] = on_start_epoch
engine.hooks['on_end_epoch'] = on_end_epoch
engine.hooks['on_start'] = on_start
engine.train(compute_loss, train_loader, args.epochs, optimizer)
if __name__ == '__main__':
train_img_dir = '../../data/searchwing/airbus_ship_data/train_v2'
test_img_dir = '../../data/searchwing/Hackathon/SingleFrame_ObjectProposalClassification/test'
train_csv = '../../data/searchwing/airbus_ship_data/train_zero_to_one_ships.csv'
test_csv = '../../data/searchwing/Hackathon/SingleFrame_ObjectProposalClassification/test/pipistrel_image_cls.csv'
log_dir = '../logs'
train_df = pd.read_csv(train_csv)
test_df = pd.read_csv(test_csv)
image_size = (224, 224)
input_shape = image_size + (3, )
gpus = 4
batch_size = 16 * gpus
model = resnet(input_shape)
# todo freeze features
multi_gpu_model(model, gpus=gpus)
model.compile(optimizer=Adam(lr=3e-4),
loss=binary_crossentropy,
metrics=['accuracy'])
image_generator = ImageDataGenerator()
tensorboard = TensorBoard(log_dir, batch_size=batch_size)
# chkp_saver = ModelCheckpoint(log_dir + 'weights.{epoch:02d}-{val_loss:.2f}.h5', monitor='loss')
def main():
# Default parameters
batch_size = 5
epochs = 50
learning_rate = 0.0001 # 10^-5
decay_rate = 1e-4
resnet = resnet18(pretrained=True)
# Hyper Parameters
TRAIN_DATASET = dataLoader()
TEST_DATASET = dataLoader(
'/mnt/291d3084-ca91-4f28-8f33-ed0b64be0a8c/akshay/targetless_calibration/data/2011_09_26/2011_09_26_drive_0001_sync/velodyne_points/data/agumenteddata/test_data.json'
)
trainDataLoader = torch.utils.data.DataLoader(TRAIN_DATASET,
batch_size=batch_size,
shuffle=False,
num_workers=0)
testDataLoader = torch.utils.data.DataLoader(TEST_DATASET,
batch_size=1,
shuffle=False,
num_workers=0)
#MODEL = importlib.import_module(pointcloudnet)
# empty the CUDA memory
torch.cuda.empty_cache()
network_model = pointcloudnet.pointcloudnet(layers=[1, 1, 1, 1, 1, 1])
regressor_model = regressor.regressor().to('cuda:2')
loss_function = pointcloudnet.get_loss().to('cuda:1')
optimizer = torch.optim.Adam(network_model.parameters(),
lr=learning_rate,
betas=(0.9, 0.999),
eps=1e-08,
weight_decay=decay_rate)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer,
step_size=20,
gamma=0.7)
start_epoch = 0
global_epoch = 0
global_step = 0
besteulerdistance = 100
eulerdistances = np.empty(0)
loss_function_vec = np.empty(0)
pred_R = np.empty(0)
pred_P = np.empty(0)
pred_Y = np.empty(0)
target_R = np.empty(0)
target_P = np.empty(0)
target_Y = np.empty(0)
# Training
for epoch in range(start_epoch, epochs):
scheduler.step()
for batch_no, data in tqdm(enumerate(trainDataLoader, 0),
total=len(trainDataLoader),
smoothing=0.9):
inputPtTensor, imgTensor, transformTensor, targetTensor = data
# Extract point clouds
inputCld = inputPtTensor.data.numpy()
targetCld = targetTensor.data.numpy()
# Preprocessing the input cloud
#inputCldPtsDropped = provider.random_point_dropout(inputCld)
'''inputCldPtsDropped[:,:,0:3] = provider.random_scale_point_cloud(inputCldPtsDropped[:,:, 0:3])'''
# Convert it back to tensor
#inputPtsDroppedTensor = torch.Tensor(inputCldPtsDropped)
# Move the data to cuda
# inputPtsDroppedTensor = inputPtsDroppedTensor.cuda()
inputPtTensor = inputPtTensor.transpose(2, 1)
inputPtTensor = inputPtTensor
transformTensor = transformTensor
optimizer.zero_grad()
network_model = network_model.train()
resnet = resnet.eval()
feature_map = network_model(inputPtTensor)
imgTensor = imgTensor.transpose(3, 1)
img_featuremap = resnet(imgTensor)
img_featuremap = img_featuremap.unsqueeze(dim=2)
aggTensor = torch.cat(
[feature_map, img_featuremap.to('cuda:2')], dim=2)
pred = regressor_model(aggTensor.transpose(2, 1))
loss = loss_function(pred.to('cuda:1'),
transformTensor.to('cuda:1'), inputPtTensor,
targetTensor)
loss_function_vec = np.append(loss_function_vec,
loss.cpu().data.numpy())
loss.backward()
optimizer.step()
global_step += 1
with torch.no_grad():
eulerDist, predr, predp, predy, targetr, targetp, targety = test(
network_model.eval(), resnet, regressor_model.eval(),
testDataLoader)
eulerdistances = np.append(eulerdistances, eulerDist)
pred_R = np.append(pred_R, predr)
pred_P = np.append(pred_P, predp)
pred_Y = np.append(pred_Y, predy)
target_R = np.append(target_R, targetr)
target_P = np.append(target_P, targetp)
target_Y = np.append(target_Y, targety)
print("Calculated mean Euler Distance: " + str(eulerDist) +
" and the loss: " + str(loss_function_vec[global_epoch]) +
" for Global Epoch: " + str(global_epoch))
if (eulerDist < besteulerdistance):
besteulerdistance = eulerDist
# make sure you save the model as checkpoint
print("saving the model")
savepath = "/tmp/bestmodel_targetlesscalibration.pth"
state = {
'epoch': global_epoch,
'bestEulerDist': besteulerdistance,
'model_state_dict_1': network_model.state_dict(),
'model_state_dict_2': regressor_model.state_dict(),
'optimizer_state_dict': optimizer.state_dict(),
}
torch.save(state, savepath)
global_epoch += 1
np.save('/tmp/eulerdistances.npy', eulerdistances)
np.save('/tmp/loss.npy', loss_function_vec)
np.save('/tmp/predicted_R.npy', pred_R)
np.save('/tmp/predicted_T.npy', pred_P)
np.save('/tmp/predicted_P.npy', pred_Y)
np.save('/tmp/target_R.npy', target_R)
np.save('/tmp/target_T.npy', target_P)
np.save('/tmp/target_P.npy', target_Y)
print("something")
with tf.variable_scope('model', reuse=tf.AUTO_REUSE):
# Note: We need to use placeholders for inputs and outputs. Otherwise,
# the batch size would be fixed and we could not use the trained model with
# a different batch size. In addition, the names of these tensors must be "inputs"
# and "labels" such that we can find them on the evaluation server. DO NOT CHANGE THIS!
x = tf.placeholder(tf.float32, [None] + [224, 224] + [1], 'inputs')
labels = tf.placeholder(tf.float32, [None] + [NUM_CLASSES], 'labels')
prediction_logits = []
if MODEL == 'alexnet':
prediction_logits = model.alexnet(x,
len(CLASSNAMES),
dropout_rate=0.55)
if MODEL == 'resnet':
prediction_logits = model.resnet(x, len(CLASSNAMES))
if MODEL == 'resnet_m':
prediction_logits = model.resnet_m(x, len(CLASSNAMES))
if MODEL == 'inception_resnet':
prediction_logits, auxiliary = model.inception_resnet(
x, len(CLASSNAMES))
# apply loss
# TODO : Implement suitable loss function for multi-label problem
loss = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(labels=labels,
logits=prediction_logits))
if MODEL == 'inception_resnet':
loss = loss + tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(labels=labels,
logits=auxiliary))
def main(opt):
if torch.cuda.is_available():
device = torch.device('cuda')
torch.cuda.set_device(opt.gpu_id)
else:
device = torch.device('cpu')
if opt.network == 'resnet':
model = resnet(opt.classes, opt.layers)
elif opt.network == 'resnext':
model = resnext(opt.classes, opt.layers)
elif opt.network == 'resnext_wsl':
# resnext_wsl must specify the opt.battleneck_width parameter
opt.network = 'resnext_wsl_32x' + str(opt.battleneck_width) + 'd'
model = resnext_wsl(opt.classes, opt.battleneck_width)
elif opt.network == 'vgg':
model = vgg_bn(opt.classes, opt.layers)
elif opt.network == 'densenet':
model = densenet(opt.classes, opt.layers)
elif opt.network == 'inception_v3':
model = inception_v3(opt.classes, opt.layers)
elif opt.network == 'dpn':
model = dpn(opt.classes, opt.layers)
elif opt.network == 'effnet':
model = effnet(opt.classes, opt.layers)
# elif opt.network == 'pnasnet_m':
# model = pnasnet_m(opt.classes, opt.layers, opt.pretrained)
# model = nn.DataParallel(model, device_ids=[4])
# model = nn.DataParallel(model, device_ids=[0, 1, 2, 3])
model = nn.DataParallel(model, device_ids=[opt.gpu_id, opt.gpu_id + 1])
# model = convert_model(model)
model = model.to(device)
images, names = utils.read_test_data(
os.path.join(opt.root_dir, opt.test_dir))
dict_ = {}
for crop_size in [opt.crop_size]:
if opt.tta:
transforms = test_transform(crop_size)
else:
transforms = my_transform(False, crop_size)
dataset = TestDataset(images, names, transforms)
loader = torch.utils.data.DataLoader(dataset,
batch_size=opt.batch_size,
shuffle=False,
num_workers=4)
state_dict = torch.load(opt.model_dir + '/' + opt.network + '-' +
str(opt.layers) + '-' + str(crop_size) +
'_model.ckpt')
if opt.network == 'densenet':
pattern = re.compile(
r'^(.*denselayer\d+\.(?:norm|relu|conv))\.((?:[12])\.(?:weight|bias|running_mean|running_var))$'
)
for key in list(state_dict.keys()):
res = pattern.match(key)
if res:
new_key = res.group(1) + res.group(2)
state_dict[new_key] = state_dict[key]
del state_dict[key]
model.load_state_dict(state_dict)
if opt.vote:
if opt.tta:
im_names, labels = eval_model_tta(loader, model, device=device)
else:
im_names, labels = eval_model(loader, model, device=device)
else:
if opt.tta:
im_names, labels = eval_logits_tta(loader,
model,
device=device)
else:
im_names, labels = eval_logits(loader, model, device)
im_labels = []
# print(im_names)
for name, label in zip(im_names, labels):
if name in dict_:
dict_[name].append(label)
else:
dict_[name] = [label]
header = ['filename', 'type']
utils.mkdir(opt.results_dir)
result = opt.network + '-' + str(opt.layers) + '-' + str(
opt.crop_size) + '_result.csv'
filename = os.path.join(opt.results_dir, result)
with open(filename, 'w', encoding='utf-8') as f:
f_csv = csv.writer(f)
f_csv.writerow(header)
for key in dict_.keys():
v = np.argmax(np.sum(np.array(dict_[key]), axis=0)) + 1
# v = list(np.sum(np.array(dict_[key]), axis=0))
f_csv.writerow([key, v])
save_best_only=5)
cp_callback_r = tf.keras.callbacks.ModelCheckpoint(filepath=checkpoint_path_r,
save_weights_only=True,
verbose=1,
save_best_only=5)
cp_callback_r2 = tf.keras.callbacks.ModelCheckpoint(
filepath=checkpoint_path_r2,
save_weights_only=True,
verbose=1,
save_best_only=5)
unet = model.unet(input_size=(config["patch_size"], config["patch_size"], 3),
wavelengths=config["wavelengths"])
print("Created unet model")
resnet = model.resnet(input_dim=config["patch_size"],
wavelengths=config["wavelengths"])
print("Created resnet model")
resnet2 = model.resnet2(input_dim=config["patch_size"],
wavelengths=config["wavelengths"])
print("Created deeper resnet model\n")
# print("Using unet model")
# unet.load_weights(latest_checkpoint_u)
# print("Loaded pre-trained unet model")
# history = unet.fit(train_ds,validation_data= validation_ds, batch_size = config["batch_size"], epochs = config["epochs"])
# prediction_u = unet.predict(test_ds)
# performance = unet.evaluate(test_ds)
print("Using resnet model")
# resnet.load_weights(latest_checkpoint_r)
