def test(device: torch.device = 'cuda'):
submit = pd.read_csv('data/sample_submission.csv')
model1 = load_model(0, 19)
model2 = load_model(1, 19)
model3 = load_model(2, 19)
model4 = load_model(3, 19)
model5 = load_model(4, 19)
tta_model1 = tta.ClassificationTTAWrapper(model1, transforms)
tta_model2 = tta.ClassificationTTAWrapper(model2, transforms)
tta_model3 = tta.ClassificationTTAWrapper(model3, transforms)
tta_model4 = tta.ClassificationTTAWrapper(model4, transforms)
tta_model5 = tta.ClassificationTTAWrapper(model5, transforms)
tta_model1.eval()
tta_model2.eval()
tta_model3.eval()
tta_model4.eval()
tta_model5.eval()
testset = MnistDataset('data/test_dirty_mnist_2nd',
'data/sample_submission.csv', transforms_test)
test_loader = DataLoader(testset,
batch_size=2,
shuffle=False,
num_workers=0)
batch_size = test_loader.batch_size
batch_index = 0
for i, (images, targets) in enumerate(test_loader):
images = images.to(device)
targets = targets.to(device)
outputs1 = tta_model1(images)
outputs2 = tta_model2(images)
outputs3 = tta_model3(images)
outputs4 = tta_model4(images)
outputs5 = tta_model5(images)
outputs = (outputs1 + outputs2 + outputs3 + outputs4 + outputs5) / 5
outputs = outputs > 0.0
batch_index = i * batch_size
submit.iloc[batch_index:batch_index+batch_size, 1:] = \
outputs.long().squeeze(0).detach().cpu().numpy()
submit.to_csv('effinet_b4-SAM_CosLR-kfold.csv', index=False)
def single_model_predict_tta():
assert len(model_name_list) == 1
model_name = model_name_list[0]
model = Net(model_name).to(device)
model_save_path = os.path.join(
config.dir_weight, '{}.bin'.format(model_name))
model.load_state_dict(torch.load(model_save_path))
transforms = tta.Compose([
tta.HorizontalFlip(),
# tta.Rotate90(angles=[0, 180]),
# tta.Scale(scales=[1, 2, 4]),
# tta.Multiply(factors=[0.9, 1, 1.1]),
tta.FiveCrops(224, 224)
])
tta_model = tta.ClassificationTTAWrapper(model, transforms)
pred_list = []
with torch.no_grad():
for batch_x, _ in tqdm(test_loader):
batch_x = batch_x.to(device)
probs = tta_model(batch_x)
probs = torch.max(torch.softmax(probs, dim=1), dim=1)
probs = probs[1].cpu().numpy()
pred_list += probs.tolist()
submission = pd.DataFrame({
"id": range(len(pred_list)),
"label": [int2label(x) for x in pred_list]
})
submission.to_csv(config.dir_csv_test, index=False, header=False)
def _get_inference_model(config: InferenceConfig) -> nn.Module:
model = config.model
model.load_state_dict(torch.load(config.checkpoint_path, map_location='cpu')['st_d'])
model = ModelWrapper(model)
model.to('cuda')
model.eval()
return tta.ClassificationTTAWrapper(model, _tta_transforms)
def evaluate(val_loader, model, loss_fn, device, use_tta=False):
model.eval()
if use_tta:
transformations = tta.Compose([
tta.Rotate90(angles=[0, 90, 180, 270]),
tta.HorizontalFlip(),
tta.VerticalFlip()
])
tta_model = tta.ClassificationTTAWrapper(model, transformations)
correct = 0
total = 0
total_loss = 0
for i, batch in enumerate(val_loader):
input_data, labels = batch
input_data, labels = input_data.to(device), labels.to(device)
with torch.no_grad():
if use_tta:
predictions = tta_model(input_data)
else:
predictions = model(input_data)
total_loss += loss_fn(predictions, labels).item()
correct += (predictions.argmax(axis=1) == labels).sum().item()
total += len(labels)
torch.cuda.empty_cache()
model.train()
return total_loss / total, correct / total
def get_predictions(model_chosen, tta = False):
model_chosen.cuda.eval()
actual_values, predicted_values = [], []
if tta == True:
transformation = ttach.Compose(
[
ttach.HorizontalFlip(),
ttach.VerticalFlip(),
ttach.Rotate90(angles=[0, 90, 180, 270])
]
)
test_time_augmentation_wrapper = ttach.ClassificationTTAWrapper(model_chosen, transformation)
with torch.no_grad():
for batch in loader_of_test:
test_image, test_label = batch
predicted_value = test_time_augmentation_wrapper(test_image.cuda())
predicted_value = torch.argmax(predicted_value, dim=1).detach().cpu().numpy()
actual_values.append(test_label.cpu().numpy())
predicted_values.append(predicted_value)
else:
with torch.no_grad():
for batch in loader_of_test:
test_image, test_label = batch
predicted_value = model_chosen(test_image.cuda())
predicted_value = torch.argmax(predicted_value, dim=1).detach().cpu().numpy()
actual_values.append(test_label.cpu().numpy())
predicted_values.append(predicted_value)
return predicted_values
def multi_model_predict_tta():
preds_dict = dict()
for model_name in model_name_list:
for fold_idx in range(5):
model = Net(model_name).to(device)
model_save_path = os.path.join(
config.dir_weight, '{}_fold{}.bin'.format(model_name, fold_idx))
model.load_state_dict(torch.load(model_save_path))
'/home/muyun99/data/dataset/AIyanxishe/Image_Classification/weight/resnet18_train_size_256_fold0.bin'
transforms = tta.Compose([
tta.Resize([int(config.size_test_image), int(config.size_test_image)]),
tta.HorizontalFlip(),
# tta.Rotate90(angles=[0, 180]),
# tta.Scale(scales=[1, 2, 4]),
# tta.Multiply(factors=[0.9, 1, 1.1]),
tta.FiveCrops(config.size_test_image, config.size_test_image)
])
tta_model = tta.ClassificationTTAWrapper(model, transforms)
pred_list = predict(tta_model)
submission = pd.DataFrame(pred_list)
submission.to_csv(
'{}/{}_fold{}_submission.csv'.format(config.dir_submission, config.save_model_name, fold_idx),
index=False,
header=False
)
preds_dict['{}_{}'.format(model_name, fold_idx)] = pred_list
pred_list = get_pred_list(preds_dict)
submission = pd.DataFrame(
{"id": range(len(pred_list)), "label": [int2label(x) for x in pred_list]})
submission.to_csv(config.dir_csv_test, index=False, header=False)
def _recommend_threshold_evaluate(self, dataloader, best_epoch=None):
try:
model_path = glob.glob('%s/*[-_]%04d[-_]*.pth' %
(self.config.LOGS_PATH, best_epoch))[0]
except Exception as e:
message = f'Checkpoint {best_epoch} not found due to {e}'
raise Exception(message)
# Re-build model to avoid conflict with multi-gpus model
self.config.WEIGHT_PATH = model_path
evaluate_model = self.load_weight(weight_path=model_path,
multi_gpus=False)
evaluate_model.eval()
tta_model = tta.ClassificationTTAWrapper(evaluate_model,
self.tta_option)
tta_model.eval()
highest_pass_score = 0.
with torch.no_grad():
for val_data in dataloader:
inputs_val, labels_val = val_data[0], val_data[1]
# if self.config.GPU_COUNT == 1:
inputs_val = inputs_val.to(self.device, non_blocking=True)
if self.tta_opt:
outputs_val = tta_model(inputs_val)
else:
outputs_val = evaluate_model(inputs_val)
# print(torch.nn.Softmax(dim=1)(outputs_val)) # For debug purpose
labels_val = labels_val.to(outputs_val.device,
non_blocking=True)
val_scores, val_preds = torch.max(outputs_val, 1)
# # Check if the predict values are in pass class or not
if_pred_pass = _check_Fail_Pass_class(val_preds,
self.pass_class_index)
# # Check if the label values are in fail class or not
if_gth_fail = _check_Fail_Pass_class(labels_val,
self.fail_class_index)
# # Final check: if images is actually a fail pass or not
fail_passes = outputs_val[if_gth_fail & if_pred_pass]
local_high = torch.softmax(
fail_passes,
dim=1).max() if fail_passes.size(0) > 0 else 0.0
if local_high > highest_pass_score:
highest_pass_score = local_high
message = 'Recommended PassThreshold: %.4f' % highest_pass_score
self.config.LOGGING.write_log(message, message_type=0)
print('[INFO]' + message)
def single_model_predict_tta(predict_model):
transforms = tta.Compose([
# tta.HorizontalFlip(),
# tta.VerticalFlip(),
# tta.FiveCrops(200, 200)
])
tta_model = tta.ClassificationTTAWrapper(predict_model, transforms)
pred_cls_list = single_model_predict(tta_model)
return pred_cls_list
def __init__(self):
super(Net, self).__init__()
self.transforms = ttach.Compose([
ttach.HorizontalFlip(),
# ttach.Scale(scales=[1, 1.05], interpolation="linear"),
ttach.Multiply(factors=[0.95, 1, 1.05]),
])
self.model = ttach.ClassificationTTAWrapper(InnerNet(),
transforms=self.transforms,
merge_mode="mean")
def main(hparams: Namespace):
loader = get_test_dataloder(hparams)
model_names = hparams.model_name.split(',')
model_types = hparams.model_type.split(',')
weights = hparams.weights.split(',')
if len(model_types) != len(weights):
print(
f'Padding model_type to match weights length, {len(model_types)} and {len(weights)}'
)
model_types = cycle(model_types)
if len(model_names) != len(weights):
print(
f'Padding model_name to match weights length, {len(model_names)} and {len(weights)}'
)
model_names = cycle(model_names)
models = [
load_model(model_name, model_type,
weight) for model_name, model_type, weight in zip(
model_names, model_types, weights)
]
if hparams.tta == 'd4':
models = [
ttach.ClassificationTTAWrapper(model, ttach.aliases.d4_transform())
for model in models
]
if hparams.tta == 'ten_crop':
models = [
ttach.ClassificationTTAWrapper(model,
ttach.aliases.ten_crop_transform())
for model in models
]
if hparams.tta == 'five_crop':
models = [
ttach.ClassificationTTAWrapper(model,
ttach.aliases.five_crop_transform())
for model in models
]
predictions = run_predictions(models, loader)
sample_submission = pd.read_csv(hparams.sample_submission_path)
sample_submission.loc[:, 'target'] = predictions
sample_submission.to_csv(f'./predictions/{hparams.submission_name}.csv',
index=False)
def predict(model_path, test_loader, saveFileName, iftta):
## predict
model = initialize_model(num_classes=176)
# create model and load weights from checkpoint
model = model.to(device)
model.load_state_dict(torch.load(model_path))
if iftta:
print("Using TTA")
transforms = tta.Compose(
[
tta.HorizontalFlip(),
tta.VerticalFlip(),
tta.Rotate90(angles=[0, 180]),
# tta.Scale(scales=[1, 0.3]),
]
)
model = tta.ClassificationTTAWrapper(model, transforms)
# Make sure the model is in eval mode.
# Some modules like Dropout or BatchNorm affect if the model is in training mode.
model.eval()
# Initialize a list to store the predictions.
predictions = []
# Iterate the testing set by batches.
for batch in tqdm(test_loader):
imgs = batch
with torch.no_grad():
logits = model(imgs.to(device))
# Take the class with greatest logit as prediction and record it.
predictions.extend(logits.argmax(dim=-1).cpu().numpy().tolist())
preds = []
for i in predictions:
preds.append(num_to_class[i])
test_data = pd.read_csv('leaves_data/test.csv')
test_data['label'] = pd.Series(preds)
submission = pd.concat([test_data['image'], test_data['label']], axis=1)
submission.to_csv(saveFileName, index=False)
print("Done!!!!!!!!!!!!!!!!!!!!!!!!!!!")
def validation(epoch, model, criterion, valid_loader):
model.eval()
model = tta.ClassificationTTAWrapper(model, tta.aliases.d4_transform())
val_loss = []
correct_samples = 0
full_a = np.zeros(len(valid_loader) * valid_loader.batch_size)
full_b = np.zeros(len(valid_loader) * valid_loader.batch_size)
for batch_i, (data, target) in enumerate(valid_loader):
if batch_i % 100 == 0:
print(batch_i * valid_loader.batch_size)
with torch.no_grad():
data, target = data.cuda(), target.cuda()
output = model(data)
loss = criterion(output[:, 1], target.float())
val_loss.append(loss.item())
full_a[batch_i *
valid_loader.batch_size:batch_i * valid_loader.batch_size +
output.shape[0]] = target.data.cpu().numpy()
full_b[batch_i *
valid_loader.batch_size:batch_i * valid_loader.batch_size +
output.shape[0]] = output[:, -1].detach().cpu().numpy()
correct_samples += (target.detach().cpu().numpy() == np.argmax(
output.detach().cpu().numpy(), axis=1)).sum()
del data, target, output
torch.cuda.empty_cache()
valid_loss = np.mean(val_loss)
val_auc = roc_auc_score(full_a, full_b)
accuracy_score = correct_samples / (len(valid_loader) *
valid_loader.batch_size)
metrics = {
'loss': valid_loss,
'accuracy': accuracy_score,
'val_auc': val_auc
}
print(metrics)
return metrics
def __init__(self,
model_path,
transforms=None,
th=0.5,
device='cpu',
gradcam=False):
self.device = torch.device(device)
classifier = QualityDescriptor.load_from_checkpoint(model_path)
classifier.model = torch.nn.Sequential(classifier.model, torch.nn.Sigmoid())
classifier.freeze()
self.mean = classifier.hparams['dataset']['mean']
self.std = classifier.hparams['dataset']['std']
self.size = classifier.hparams['dataset']['size']
if transforms:
classifier = tta.ClassificationTTAWrapper(classifier, transforms, merge_mode='mean')
self.classifier = classifier.to(self.device)
self.th = th
self.gcam = None
if gradcam:
self.gcam = GradCAM(self.classifier)
def get_tta_model(model: nn.Module, crop_method: str,
input_size: List[int]) -> nn.Module:
"""Wraps input model to TTA model.
Args:
model: input model without TTA
crop_method: one of {'resize', 'crop'}. Cropping method of the input images
input_size: model's input size
Returns:
Model with TTA
"""
transforms = [ttach.HorizontalFlip()]
if crop_method == "crop":
transforms.append(
ThreeCrops(crop_height=input_size[0], crop_width=input_size[1]))
transforms = ttach.Compose(transforms)
model = ttach.ClassificationTTAWrapper(model, transforms)
return model
def predict_one(self, img, TTA=True):
self.pytorch_model.eval()
with torch.no_grad():
if TTA:
img = preprocess_input(img).to(self.device, non_blocking=True)
tta_model = tta.ClassificationTTAWrapper(
self.pytorch_model, self.tta_option)
outputs = tta_model(
img.unsqueeze(0).to(self.device, non_blocking=True))
propability = torch.nn.Softmax(dim=1)(outputs)
return self.manage_prediction(propability.tolist())
else:
img = preprocess_input(img).to(self.device, non_blocking=True)
outputs = self.pytorch_model(img.unsqueeze(0))
propability = torch.nn.Softmax(dim=1)(outputs)
return self.manage_prediction(propability.tolist())
def validate(args, model: nn.Module, valid_loader):
model.eval()
if args.tta:
#model = tta.SegmentationTTAWrapper(model, tta.aliases.d4_transform(), merge_mode='mean')
model = tta.ClassificationTTAWrapper(model,
tta.aliases.d4_transform(),
merge_mode='mean')
all_preds, all_targets, all_loss = [], [], []
with torch.no_grad():
for inputs, targets in valid_loader:
all_targets.append(targets)
inputs, targets = inputs.cuda(), targets.cuda()
outputs = model(inputs, nn.Sigmoid())
loss = criterion(outputs, targets).sum()
all_loss.append(loss.item())
all_preds.append(outputs.cpu())
all_preds = torch.cat(all_preds, 0).numpy()
all_targets = torch.cat(all_targets, 0).numpy()
metrics = {}
metrics['loss'] = sum(all_loss) / valid_loader.num
#metrics['dice'] = 0. #dice(all_preds, all_targets)
pr_auc_mean = 0.
for class_i in range(4):
precision, recall, _ = precision_recall_curve(all_targets[:, class_i],
all_preds[:, class_i])
pr_auc = auc(recall, precision)
pr_auc_mean += pr_auc / 4
#print(f"PR AUC {self.class_names[class_i]}, {self.stage}: {pr_auc:.3f}\n")
metrics['dice'] = pr_auc_mean
if args.val:
print_metrics(all_preds, all_targets)
return metrics
def predict_empty_masks(args,
recall_thresholds=[
0.2502807, 0.30874616, 0.47154653, 0.25778872
]):
#[0.30248615, 0.4076966, 0.55904335, 0.29780537] 0875):
#[0.32873523, 0.44805834, 0.6001048, 0.3136805] 085):
#[0.21345863, 0.1824504, 0.41996846, 0.20917079]095):
# #[0.28479144, 0.35337192, 0.5124028, 0.27734384]090):
model, model_file = create_model(args.encoder_type,
work_dir=args.work_dir,
ckp=args.ckp)
model = model.cuda()
model = DataParallel(model)
model.eval()
if args.tta:
model = tta.ClassificationTTAWrapper(model,
tta.aliases.d4_transform(),
merge_mode='mean')
test_loader = get_test_loader(batch_size=args.val_batch_size)
all_preds = []
with torch.no_grad():
for inputs in tqdm(test_loader):
inputs = inputs.cuda()
outputs = model(inputs, nn.Sigmoid())
all_preds.append(outputs.cpu())
all_preds = torch.cat(all_preds, 0).numpy()
img_ids = test_loader.img_ids
print(all_preds.shape)
image_labels_empty = []
for i, (img, predictions) in enumerate(zip(img_ids, all_preds)):
for class_i, class_name in enumerate(class_names):
if predictions[class_i] < recall_thresholds[class_i]:
image_labels_empty.append(f'{img}_{class_name}')
pd.DataFrame({
'empty_ids': image_labels_empty
}).to_csv('empty_ids.csv', index=False)
def test_preds(model, data_dir, test_loader):
model.eval()
model = tta.ClassificationTTAWrapper(model, tta.aliases.d4_transform())
sample_submission = pd.read_csv(
os.path.join(data_dir, 'sample_submission.csv'))
test_preds = np.zeros(sample_submission.shape[0])
for batch_i, data in enumerate(test_loader):
with torch.no_grad():
data = data.cuda()
output = model(data)
test_preds[batch_i * test_loader.batch_size:batch_i *
test_loader.batch_size + output.shape[0]] = sigmoid(
output[:, 1].detach().cpu().numpy())
del data, output
torch.cuda.empty_cache()
if batch_i % 100 == 0:
print(batch_i * test_loader.batch_size)
return test_preds
def main():
device = "cuda:0" if torch.cuda.is_available() else "cpu"
parser = argparse.ArgumentParser()
parser.add_argument('--image_path', type=str, default="./data/test_dirty_mnist_2nd/")
parser.add_argument('--label_path', type=str, default="./data/sample_submission.csv")
parser.add_argument('--weight_path', type=str, default='./save/kfold_202119/')
parser.add_argument('--out_path', type=str, default='./save/kfold_202119/')
parser.add_argument('--model', type=str, default='efficientnet-b8')
parser.add_argument('--batch_size', type=int, default=1)
parser.add_argument('--device', type=str, default=device)
args = parser.parse_args()
assert os.path.isdir(args.image_path), 'wrong path'
assert os.path.isfile(args.label_path), 'wrong path'
assert os.path.isdir(args.weight_path), 'wrong path'
assert os.path.isdir(args.out_path), 'wrong path'
print('=' * 50)
print('[info msg] arguments')
for key, value in vars(args).items():
print(key, ":", value)
weights = glob(os.path.join(args.weight_path, '*.tar'))
test_df = pd.read_csv(args.label_path)
test_set = DatasetMNIST(
image_folder=args.image_path,
label_df=test_df,
transforms=base_transforms['test']
)
submission_df = copy.copy(test_df)
for weight in weights:
model = EfficientNet.from_name(args.model, in_channels=1, num_classes=26)
model.load_state_dict(torch.load(weight, map_location=args.device))
print('=' * 50)
print('[info msg] weight {} is loaded'.format(weight))
test_data_loader = torch.utils.data.DataLoader(
test_set,
batch_size = args.batch_size,
shuffle = False,
)
model.to(args.device)
model.eval()
tta_model = tta.ClassificationTTAWrapper(model, tta_transforms)
batch_size = args.batch_size
batch_index = 0
print('=' * 50)
print('[info msg] inference start')
for i, (images, _) in enumerate(tqdm(test_data_loader)):
images = images.to(args.device)
outputs = tta_model(images).detach().cpu().numpy().squeeze() # soft vote
# outputs = (outputs > 0.5).astype(int) # hard vote
batch_index = i * batch_size
submission_df.iloc[batch_index:batch_index+batch_size, 1:] += outputs
submission_df.iloc[:,1:] = (submission_df.iloc[:,1:] / len(weights) >= 0.35).astype(int)
SAVE_FN = os.path.join(args.out_path, datetime.now().strftime("%m%d%H%M") + '_ensemble_submission.csv')
submission_df.to_csv(
SAVE_FN,
index=False
)
print('=' * 50)
print('[info msg] submission fils is saved to {}'.format(SAVE_FN))
for i in range(5):
train(i)
def load_model(fold: int, epoch: int, device: torch.device = 'cuda'):
model = EfficientNetModel().to(device)
model.load_state_dict(
torch.load(f'models/effinet_b4_SAM_CosLR-f{fold}-{epoch}.pth'))
return model
transforms = tta.Compose([tta.HorizontalFlip(), tta.VerticalFlip()])
tta_model = tta.ClassificationTTAWrapper(model, transforms)
def test(device: torch.device = 'cuda'):
submit = pd.read_csv('data/sample_submission.csv')
model1 = load_model(0, 19)
model2 = load_model(1, 19)
model3 = load_model(2, 19)
model4 = load_model(3, 19)
model5 = load_model(4, 19)
tta_model1 = tta.ClassificationTTAWrapper(model1, transforms)
tta_model2 = tta.ClassificationTTAWrapper(model2, transforms)
tta_model3 = tta.ClassificationTTAWrapper(model3, transforms)
tta_model4 = tta.ClassificationTTAWrapper(model4, transforms)
# 预测
probability = []
for file in tqdm(image_id):
img_path = os.path.join(path, file)
image = cv2.imread(img_path)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
augmented = get_inference_transforms()(image=image)
image = augmented['image'][None]
image = image.to(device)
image_preds_all = []
with torch.no_grad():
for model in net0:
tta_model = tta.ClassificationTTAWrapper(
model, tta.aliases.d4_transform())
image_preds = tta_model(image)
image_preds_all += [
torch.softmax(image_preds, 1).detach().cpu().numpy()
]
image_preds_all = np.concatenate(image_preds_all, axis=0)
tta_preds = np.mean(image_preds_all, axis=0)
prob = np.argmax(tta_preds)
probability.append((prob))
df_submit = pd.DataFrame({'image_name': image_id, 'label': probability})
df_submit.to_csv(f'{result_path}/result.csv', index=False)
def _custom_eval_one_epoch(self, dataloader):
evaluate_dict = {"y_gth_list": [], "y_pred_list": []}
# Evaluate metric part
print("====================================")
print("Calculating Custom Metric.....")
print("====================================")
if self.config.GPU_COUNT > 1:
evaluate_model = self.pytorch_model.module
tta_model = tta.ClassificationTTAWrapper(evaluate_model,
self.tta_option)
tta_model = nn.DataParallel(tta_model)
else:
evaluate_model = self.pytorch_model
tta_model = tta.ClassificationTTAWrapper(evaluate_model,
self.tta_option)
tta_model.eval()
with torch.no_grad():
draft_img = preprocess_input(
np.zeros(
(self.input_size, self.input_size, 3)).astype(np.float32))
if self.config.GPU_COUNT > 1:
pass
else:
draft_img = draft_img.to(self.device, non_blocking=True)
if self.tta_opt:
tta_model(draft_img.unsqueeze(0))
else:
self.pytorch_model(draft_img.unsqueeze(0))
for eval_data in dataloader:
if self.tta_opt:
inputs_eval, labels_eval = eval_data[0], eval_data[1]
if self.config.GPU_COUNT == 1:
inputs_eval = inputs_eval.to(self.device,
non_blocking=True)
outputs_eval = tta_model(inputs_eval)
labels_eval = labels_eval.to(outputs_eval.device,
non_blocking=True)
_, eval_preds = torch.max(outputs_eval, 1)
evaluate_dict['y_pred_list'].extend(eval_preds.tolist())
else:
inputs_eval, labels_eval = eval_data[0], eval_data[1]
if self.config.GPU_COUNT == 1:
inputs_eval = inputs_eval.to(self.device,
non_blocking=True)
labels_val = labels_val.to(self.device, non_blocking=True)
outputs_eval = self.pytorch_model(inputs_eval)
_, eval_preds = torch.max(outputs_eval, 1)
evaluate_dict['y_pred_list'].extend(eval_preds.tolist())
evaluate_dict['y_gth_list'].extend(labels_eval.tolist())
UK_ratio = _FP_FN_metric(evaluate_dict['y_pred_list'],
evaluate_dict['y_gth_list'],
self.fail_class_index)
OK_ratio = _FP_FN_metric(evaluate_dict['y_pred_list'],
evaluate_dict['y_gth_list'],
self.pass_class_index)
# Delete when done evaluate to prevent OOM
try:
del evaluate_model
except NameError:
pass
# Tensorboard part
self.config.LOGGING.write_log(f"False Pass rate: {UK_ratio} %",
message_type=0)
self.config.LOGGING.write_log(f"False Reject rate: {OK_ratio} %",
message_type=0)
print(f"False Pass rate: {UK_ratio} %")
print(f"False Reject rate: {OK_ratio} %")
return UK_ratio, OK_ratio
cfg = Config()
desc_test = os.path.join(cfg.ds_folder, 'test.csv')
_, transform_test = get_transforms(cfg.img_size)
valid_data = TestDataset(desc_test,
data_folder=os.path.join(cfg.ds_folder, "test"),
transform=transform_test)
test_loader = DataLoader(dataset=valid_data, batch_size=cfg.bs, shuffle=False)
models = []
for path in get_kfold_model(opt.weights):
model = get_model_by_name(cfg.model_name)
model.load_state_dict(torch.load(path)['state_dict'])
if opt.tta == 'yes':
model = tta.ClassificationTTAWrapper(model,
get_tta_transforms(),
merge_mode='mean')
models.append(model)
rst = [[] for i in range(len(models))]
for index in range(len(models)):
net = models[index]
net.to("cuda")
net.eval()
files = []
with torch.no_grad():
for x, y in tqdm(test_loader):
x, filename = x.cuda(), y
out = net(x)
_, pred = torch.max(out.data, 1)
n_iter // 20,
after_scheduler=schedulerD)
# plot_scheduler(schedulerG, n_iter, "Gen LR Scheduler")
# plot_scheduler(schedulerD, n_iter * NUM_DISCRIMINATOR_TRAIN, "Dis LR Scheduler")
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
gen.to(device)
dis.to(device)
criterionG.to(device)
criterionD.to(device)
tta_transform = tta.Compose([tta.HorizontalFlip(), tta.VerticalFlip()])
tta_gen = tta.SegmentationTTAWrapper(gen, tta_transform)
tta_dis = tta.ClassificationTTAWrapper(dis, tta_transform)
history = []
img_test = plt.imread(r'data\testing_lr_images\09.png')
img_valid = plt.imread(r'data\valid_hr_images\t20.png')
for epoch in range(1, NUM_EPOCHS + 1):
train_bar = tqdm(train_loader)
running_results = {
'batch_sizes': 0,
'lossG': 0,
'lossD': 0,
'gradeHR': 0,
'gradeSR': 0,
'psnr': 0
}
# Train a epoch:
print('Training done.')
print(f'================')
print(f'Started testing...')
print(f'================')
# testing with train data
_, train_acc = test_model(model, train_loader)
print(f'train set acc: {train_acc}')
# testing with test data
_, test_acc = test_model(model, test_loader)
print(f'test set acc: {test_acc}')
# this is a 5x tta with test data
# wrapping a model
tta_model = tta.ClassificationTTAWrapper(
model, tta.aliases.five_crop_transform(config.tta_crop,
config.tta_crop))
# creating dataset
tta_dataset = dataset.dataset(valid_df, transforms.tta_transform_cls)
# creating the loder
tta_loader = DataLoader(tta_dataset, batch_size=1, shuffle=False)
# testing
_, tta_acc = test_model(tta_model, tta_loader)
print(f'TTA acc: {tta_acc}')
print(f'================')
print(f'Testing done.')
# total run time
total_time = time.time() - start
print(f'================')
# #### Load model
multilabel_resnet34 = models.resnet34(pretrained=False)
multilabel_resnet34.fc = torch.nn.Linear(multilabel_resnet34.fc.in_features,
len(CLASSES))
multilabel_resnet34 = load_dataparallel_model(
multilabel_resnet34, torch.load(model_multilabel_path))
multilabel_resnet34 = torch.nn.DataParallel(multilabel_resnet34,
device_ids=range(
torch.cuda.device_count()))
multilabel_resnet34.to(DEVICE)
multilabel_resnet34.eval()
multilabel_resnet34 = tta.ClassificationTTAWrapper(multilabel_resnet34,
tta.Compose([
tta.HorizontalFlip(),
tta.VerticalFlip(),
tta.Scale([0.85, 1.15]),
]),
merge_mode="mean")
# #### Inference
DEVICE = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
class_th = torch.tensor([0.0005, 0.2, 0.005, 0.02, 0.005, 0.005, 0.008,
0.005]).to(DEVICE)
total_preds, total_paths = [], []
@toma.batch(initial_batchsize=batch_size_multilabel)
def run_multilabel(batch_size):
inference_loader = DataLoader(inference_dataset,
desc_test = os.path.join(cfg.ds_folder, 'test.csv')
_, test_tfms = get_transforms(IMG_SIZE)
valid_data = TestDataset(desc_test,
data_folder=os.path.join(cfg.ds_folder, "test"),
transform=test_tfms)
test_loader = DataLoader(dataset=valid_data, batch_size=cfg.bs, shuffle=False)
net = get_model_by_name(cfg.model_name)
net.load_state_dict(torch.load(opt.weights)['state_dict'])
net.to("cuda")
net.eval()
if opt.tta == 'yes':
transforms = tta.Compose([
tta.HorizontalFlip(),
])
net = tta.ClassificationTTAWrapper(net, transforms, merge_mode='mean')
rst = []
files = []
for x, y in tqdm(test_loader):
with torch.no_grad():
x, filename = x.cuda(), y
out = net(x)
_, pred = torch.max(out.data, 1)
rst.extend(list(pred.cpu().numpy()))
files.extend(list(filename.numpy()))
submit = pd.DataFrame({'id': files, 'label': rst})
submit.to_csv("submit.csv", encoding="utf8", index=False)
