def predict_on_extra(model, path, class_dict):
if torch.cuda.is_available():
model.cuda()
file_list = os.listdir(path)
points = []
transfrom = get_transform(input_size=cfg.INPUT_SIZE, imgset="test")
for i in tqdm(file_list):
img_path = os.path.join(path, i)
save_path = os.path.join(res_path, i)
img = cv2.imread(img_path)
ii = 0
jj = 0
img_w, img_h, _ = img.shape
while ii + 84 < img_w:
while jj + 84 < img_h:
to_pred = img[ii:ii + 84, jj:jj + 84]
to_pred = Image.fromarray(to_pred).convert('RGB')
to_pred = transfrom(to_pred)
to_pred = to_pred.unsqueeze(0)
if torch.cuda.is_available():
to_pred = to_pred.cuda()
with torch.no_grad():
out = model(to_pred)
class_ = torch.argmax(out, dim=1).cpu().item()
if class_dict[class_] == 'garbage':
points.append((jj + 42, ii + 42))
jj += 84
ii += 84
jj = 0
for point in points:
cv2.circle(img, point, radius=15, color=(0, 0, 255), thickness=-1)
cv2.imwrite(save_path, img)
def image_generator(increment, counter):
to_net = np.empty((batch_size, 32, 32, 3), 'float32')
for i in range(batch_size):
tr = dataset.get_transform(counter)
to_net[i] = dataset.idct(tr) # ycc format
counter = np.mod(np.add(counter, increment), dataset.quantization)
to_net = np.divide(np.subtract(to_net, scale), scale)
# print('batch stats: max={}, min={}'.format(to_net.max(), to_net.min()))
return to_net, counter
parser.add_argument('--train_way', type=int, default=30)
parser.add_argument('--valid_way', type=int, default=5)
parser.add_argument('--hallu_m', type=int, default=20)
parser.add_argument('--distance',
type=str,
default='parametric',
choices=['euclidian', 'cosine', 'parametric'])
parser.add_argument('--device', type=str, default='cuda')
args = parser.parse_args() ###############################
args.name = f'hallu{args.hallu_m}_shot{args.shot}_trainway{args.train_way}'+\
f'_validway{args.valid_way}_{args.distance}'
wandb.init(config=args, project='dlcv_proto_net', name=args.name)
# Image transform
train_trans, valid_trans = get_transform()
# Train data
train_set = MiniImageNet_Dataset('../hw4_data/train/', train_trans)
train_sampler = CategoriesSampler(train_set.label,
n_batch=args.n_batch,
n_ways=args.train_way,
n_shot=args.shot + args.query)
train_loader = DataLoader(train_set,
batch_sampler=train_sampler,
num_workers=6,
worker_init_fn=worker_init_fn)
# Valid data
valid_set = MiniImageNet_Dataset('../hw4_data/val/', valid_trans)
valid_sampler = CategoriesSampler(valid_set.label,
import torch
from models.MaskRCNN import get_model_instance_segmentation
from dataset import PennFudanDataset, get_transform
from references.engine import train_one_epoch, evaluate
from references import utils
# train on the GPU or the CPU, if a GPU is not available
device = torch.device('cuda') if torch.cuda.is_available() else torch.device(
'cpu')
# our dataset has two classes only - background and person
num_classes = 2
# use out dataset an defined transformations
dataset = PennFudanDataset('PennFudanPed', get_transform(train=True))
dataset_test = PennFudanDataset('PennFudanPed', get_transform(train=False))
# split the dataset in train and test set
indices = torch.randperm(len(dataset)).tolist()
dataset = torch.utils.data.Subset(dataset, indices[:-50])
dataset_test = torch.utils.data.Subset(dataset_test, indices[-50:])
# define training and validation data loaders
data_loader = torch.utils.data.DataLoader(dataset,
batch_size=2,
shuffle=True,
num_workers=4,
collate_fn=utils.collate_fn)
data_loader_test = torch.utils.data.DataLoader(dataset_test,
batch_size=1,
torch.cuda.set_device(params.gpu_ids[0])
params.nThreads = 1 # test code only supports nThreads = 1
params.batchSize = 1 # test code only supports batchSize = 1
params.serial_batches = True # no shuffle
params.no_flip = True # no flip
###
create_dir(Path(params.results_dir))
inference_images = make_dataset(params.source_dir)
num_inference_images = len(inference_images)
print(f'#inference images = {num_inference_images}')
model = create_model(params)
transform = get_transform(params)
start_time = time.time()
for i, img_path in enumerate(inference_images):
if params.how_many:
if i >= params.how_many:
print(f'how_many: {params.how_many}')
break
frameid = img_path.split('/')[-1].replace('.png', '')
target_frameid = f'H{frameid[1:]}'
target_path = os.path.join(params.target_dir, f'{target_frameid}.png')
source_img = Image.open(img_path).convert('RGB')
target_img = Image.open(target_path).convert('RGB')
ckpt = torch.load(os.path.join(gen_path, model_mask_newAS))
model_to_test.load_state_dict(ckpt['model'])
if cnn == '2':
model_to_test = get_model_frcnn_fpn_new_anchor(num_classes = 2, pretrained = True, new_AS = False, focal_loss = False)
ckpt = torch.load(os.path.join(gen_path, model_frcnn_stdAS))
model_to_test.load_state_dict(ckpt['model'])
if cnn == '3':
model_to_test = get_model_frcnn_fpn_new_anchor(num_classes = 2, pretrained = True, new_AS = True, focal_loss = False)
ckpt = torch.load(os.path.join(gen_path, model_frcnn_newAS))
model_to_test.load_state_dict(ckpt['model'])
dataset_test = CERNDataset_Test(root = os.path.join(dataset, 'test'),
data_file = os.path.join(dataset, 'test', 'data/labels.csv'),
transforms = get_transform(train = False))
''''
images processing
'''
print('images processing has started')
for idx in range(len(dataset_test.imgs)):
img, _ = dataset_test[idx]
label_boxes = np.array(dataset_test[idx][1]["boxes"])
model_to_test.eval()
with torch.no_grad():
prediction = model_to_test([img])
def main(argv):
modelPath = 'model.pth'
selectedDevice = ''
source = ''
youtube = False
try:
opts, args = getopt.getopt(argv, "p:d:s:",
["modelPath=", "device=", "source="])
except getopt.GetoptError:
print("Error parsing arguments")
sys.exit(2)
for opt, arg in opts:
if opt in ("-p", "--modelPath"):
if arg.endswith(".pth") is True or arg.endswith('.pt') is True:
modelPath = arg
else:
print("modelPath must end in .pth or .pt")
sys.exit(2)
if opt in ("-d", "--device"):
lower = arg.lower()
if lower == "gpu" or lower == "cpu":
selectedDevice = arg.lower()
else:
print("device must be either 'gpu' or 'cpu'")
sys.exit(2)
if opt in ("-s", "--source"):
if arg.startswith("http://") is True or arg.startswith(
"https://") is True:
if arg.startswith(
"https://www.youtube.com") is True or arg.startswith(
"https://youtube.com") is True or arg.startswith(
"https://youtu.be") is True:
youtube = True
source = arg
else:
print("Source must begin with http:// or https://")
sys.exit(2)
if source == '':
print("Please provide a source to evaluate using -s or --source=")
sys.exit(2)
# evaluate on the GPU or on the CPU, if a GPU is not available
device = torch.device(
'cuda') if torch.cuda.is_available() else torch.device('cpu')
# check if user has requested either cpu or gpu processing
if torch.cuda.is_available() and selectedDevice == '':
print("CUDA device is detected, using GPU for training and evaluation")
elif selectedDevice != '':
if selectedDevice == 'gpu':
if torch.cuda.is_available() is False:
print("Cannot find CUDA driver or device")
sys.exit(2)
device = torch.device('cuda')
if selectedDevice == 'cpu':
device = torch.device('cpu')
model = get_model_instance_segmentation(2)
model.load_state_dict(torch.load(modelPath))
model.eval()
model = model.to(device)
img = None
if youtube is True:
vPafy = pafy.new(source)
play = vPafy.getbest()
cap = cv2.VideoCapture(play.url)
_, frame = cap.read()
img = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
cap.release()
cv2.destroyAllWindows()
else:
with urllib.request.urlopen(source) as url:
image = np.asarray(bytearray(url.read()), dtype="uint8")
img = cv2.imdecode(image, cv2.IMREAD_COLOR)
# You may need to convert the color.
im_pil = Image.fromarray(img).convert("RGB")
transform = get_transform(train=False)
im_pil = transform(im_pil, None)
imList = [im_pil[0]]
ok = list(image.to(device) for image in imList)
output = model(ok)
positives = 0
weak = 0
for score in output[0]['scores']:
if score > 0.99:
positives = positives + 1
else:
weak = weak + 1
print("---- Results ----")
if positives == 0:
print("Did not detect any people")
else:
print("Detected " + str(positives) + " people")
print("Counted " + str(weak) +
" additional weak signals below 99% confidence")
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])
test_trans = transforms.Compose([
transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])
dataset = VRDFRDataset(dataset_path='./',
type='train',
num_classes=100,
cls_transform=train_trans,
ifselected=False,
ifdtc=True,
dtc_transform=get_transform(train=True))
data_loader = DataLoader(dataset,
batch_size=2,
shuffle=True,
num_workers=8,
collate_fn=dataset.collate_fn)
test_dataset = VRDFRDataset(dataset_path='./',
type='test',
num_classes=100,
cls_transform=test_trans,
ifselected=True,
ifdtc=True,
dtc_transform=get_transform(train=False))
test_data_loader = DataLoader(test_dataset,
batch_size=2,
def main():
dataset = options.dataset
writer = SummaryWriter(tb_path)
data_train = CERNDataset(root=os.path.join('Datasets', dataset),
data_file=os.path.join('Datasets', dataset,
'data/labels.csv'),
transforms=get_transform(train=True))
data_test = CERNDataset(root=os.path.join('Datasets', dataset),
data_file=os.path.join('Datasets', dataset,
'data/labels.csv'),
transforms=get_transform(train=False))
torch.manual_seed(1)
indices = torch.randperm(len(data_train)).tolist()
if options.dataset == 'GDXray_dataset/datasets_cropped':
len_set = int(len(data_train) * 0.4) * options.reduced
splitter = int(len_set * 0.3)
dataset_train = torch.utils.data.Subset(data_train,
indices[:(len_set - splitter)])
dataset_test = torch.utils.data.Subset(data_test, indices[-splitter:])
dataloader_train = torch.utils.data.DataLoader(
dataset=dataset_train,
batch_size=options.batch_size,
shuffle=True,
num_workers=options.num_workers,
collate_fn=utils.collate_fn)
dataloader_test = torch.utils.data.DataLoader(
dataset=dataset_test,
batch_size=1,
shuffle=False,
num_workers=options.num_workers,
collate_fn=utils.collate_fn)
else:
splitter = int(len(data_train) * 0.3)
dataset_train = torch.utils.data.Subset(data_train,
indices[:-splitter])
dataset_test = torch.utils.data.Subset(data_test, indices[-splitter:])
dataloader_train = torch.utils.data.DataLoader(
dataset=dataset_train,
batch_size=options.batch_size,
shuffle=True,
num_workers=options.num_workers,
collate_fn=utils.collate_fn)
dataloader_test = torch.utils.data.DataLoader(
dataset=dataset_test,
batch_size=1,
shuffle=False,
num_workers=options.num_workers,
collate_fn=utils.collate_fn)
# ## saving dataset in tb_log
#
# seq = iaa.Sequential([
# iaa.Resize({"height": 700, "width": 700})
# ])
#
# arrays = []
# images = []
# arrays_aug_img = []
# tensors_aug_img = []
# labels = []
# images_aug_with_boxes = []
# tensors_aug_img_with_boxes = []
# for batch_idx, (image, label) in enumerate(dataloader_train):
# img = image[0].numpy().transpose(1,2,0)
# img_aug = seq(image = img)
# img_aug_tensor = torch.from_numpy(img_aug.transpose(2,0,1))
#
# images.append(image[0].unsqueeze(0))
# arrays.append(img)
# labels.append(label)
# arrays_aug_img.append(img_aug)
# tensors_aug_img.append(img_aug_tensor)
#
# boxes = []
# for box in labels[0][0]['boxes']:
# box = box.tolist()
# boxes.append(box)
# my_bbs = []
# for b in boxes:
# bb = ia.BoundingBox(x1 = b[0], y1 = b[1], x2 = b[2], y2 = b[3])
# my_bbs.append(bb)
# bbs_oi = BoundingBoxesOnImage(my_bbs, shape = img.shape)
# img_aug, bbs_aug = seq(image = img, bounding_boxes = bbs_oi)
# bbs_aug_no_fout_clipart = bbs_aug.remove_out_of_image().clip_out_of_image()
# image_aug_with_boxes = bbs_aug_no_fout_clipart.draw_on_image(img_aug, size=2, color=[0,0,255])
# images_aug_with_boxes.append(image_aug_with_boxes)
# tensor_aug_img_with_boxes = torch.from_numpy(image_aug_with_boxes.transpose(2,0,1))
# tensors_aug_img_with_boxes.append(tensor_aug_img_with_boxes)
#
# grid = torchvision.utils.make_grid(tensors_aug_img, padding = 20)
# grid_1 = torchvision.utils.make_grid(tensors_aug_img_with_boxes, padding = 20)
# writer.add_image('images', grid)
#
# ## TODO "Resize" imgaug-function seems to not work correctly in annotations
# writer.add_image('images_with_boxes', grid_1)
device = torch.device(
'cuda') if torch.cuda.is_available() else torch.device('cpu')
num_classes = options.num_classes
if options.model == 1:
model = get_model_frcnn_fpn_new_anchor(num_classes, options.pretrained,
options.anchor_size)
if options.model == 0:
model = get_model_masck_fpn_new_anchor(num_classes, options.pretrained,
options.anchor_size)
model.to(device)
#writer.add_graph(model, tensors_aug_img)
params = [p for p in model.parameters() if p.requires_grad]
total_parameter = sum(p.numel() for p in model.parameters())
total_parameter_trainable = sum(p.numel() for p in model.parameters()
if p.requires_grad)
optimizer = torch.optim.SGD(params=params,
lr=options.learning_rate,
momentum=options.momentum,
weight_decay=options.weight_decay)
lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer=optimizer,
step_size=3,
gamma=0.1)
es = EarlyStopping(patience=options.patience,
verbose=True,
delta=options.delta)
# resume non finished training:
if options.resume:
if os.path.isfile(options.resume):
print("loading weights '{}'".format(options.resume))
checkpoint = torch.load(options.resume)
model.load_state_dict(checkpoint['model'])
optimizer.load_state_dict(checkpoint['optimizer'])
resume_epoch = checkpoint['epoch']
print("loaded checkpoint'{}' (epoch {})".format(
options.resume, checkpoint['epoch']))
else:
print("no checkpoint foung ar'{}'".format(options.resume))
else:
resume_epoch = 0
num_epochs = options.epochs
for epoch in range(resume_epoch, num_epochs):
train_one_epoch(model=model,
optimizer=optimizer,
data_loader=dataloader_train,
device=device,
epoch=epoch,
print_freq=10,
writer=writer,
ckpt_path=ckpt_path)
lr_scheduler.step()
(coco, map05) = evaluate(model=model,
data_loader=dataloader_test,
device=device,
writer=writer,
epoch=epoch)
es(val_acc=map05,
model=model,
path=best_path,
epoch=epoch,
optimizer=optimizer)
def main():
config_path = "config.yaml"
with open(config_path, 'r') as fp:
config = yaml.safe_load(fp)
coco_train_imgs = os.path.join(config['path'], "images/train2017")
coco_train_annos_path = os.path.join(
config['path'], "annotations/person_keypoints_train2017.json")
coco_val_imgs = os.path.join(config['path'], "images/val2017")
coco_val_annos_path = os.path.join(
config['path'], "annotations/person_keypoints_val2017.json")
epochs = config['num_epochs']
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
train_dataset = COCODataset(coco_train_imgs,
coco_train_annos_path,
num_keypoints=17,
transform=get_transform(train=True))
val_dataset = COCODataset(coco_val_imgs,
coco_val_annos_path,
num_keypoints=17,
transform=get_transform(train=False))
train_dataloader = DataLoader(train_dataset,
batch_size=8,
shuffle=True,
num_workers=4)
val_dataloader = DataLoader(val_dataset,
batch_size=4,
shuffle=True,
num_workers=4)
model = PoseModel(num_kpts=17)
model.to(device)
model.train()
criterion = JointMSELoss()
optimizer = optim.SGD(model.parameters(),
lr=config['learning_rate'],
momentum=config['momentum'])
logs = []
for e in range(epochs):
running_loss = 0.0
for i, data in enumerate(train_dataloader):
imgs, _, heatmaps = data
imgs = imgs.to(device)
heatmaps = heatmaps.to(device)
optimizer.zero_grad()
outs = model(imgs)
loss = criterion(outs.float(), heatmaps.float())
loss.backward()
optimizer.step()
running_loss += loss.item()
if i % 1000 == 999:
print("Epoch {} | Iteration {} | Loss {:.4f}".format(
e + 1, i + 1, running_loss / 2000.))
logs.append("Epoch {} | Iteration {} | Loss {:.4f}".format(
e + 1, i + 1, running_loss / 2000.))
running_loss = 0.0
validate(model, val_dataloader, criterion, device)
model.train()
print("Save model")
torch.save(model.state_dict(), f'model_epochs_{e}.pth')
print("Test training finished.")
torch.save(model.state_dict(), f'model_epochs_{epochs}.pth')
with open("logs.txt", 'a') as fp:
for el in logs:
fp.write(el + "\n")
print("Logs saved")
path = './data/submission_format.csv'
# path = './data/train.csv'
df = pd.read_csv(path)
side_df = pd.read_csv('./data/official_test.csv')
ids = side_df.image_path
# ids = df.image_id
# prefix = 'C:/Users/Admin/Desktop/Wind_data/test/'
# prefix = 'D:/Predict_Wind/test/'
# ids = [prefix + str(i) + '.jpg' for i in ids]
batch_size = 150
_, transform = get_transform(366)
dataset_test = WindDataset(image_list=ids, transform=transform, test=True)
shuffle_loader = DataLoader(dataset_test,
batch_size=batch_size,
shuffle=True,
num_workers=8)
test_loader = DataLoader(dataset_test,
batch_size=batch_size,
shuffle=False,
num_workers=8)
warm_up = True
train_mode = False
correct = 0
total = 0
with torch.no_grad():
for data in data_loader:
images, labels = data
outputs = net(images)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
print('Accuracy of the network on the %s val images: %d %%' % (len(sampler),
100 * correct / total))
dataset = CustomDataset(get_transform(True), labels)
batch_size = 4
validation_split = .2
shuffle_dataset = True
random_seed = 42
dataset_size = len(dataset)
indices = list(range(dataset_size))
split = int(np.floor(validation_split * dataset_size))
if shuffle_dataset:
np.random.seed(random_seed)
np.random.shuffle(indices)
train_indices, val_indices = indices[split:], indices[:split]
valid_sampler = SubsetRandomSampler(val_indices)
from dataset import MiniImageNet_Dataset, get_transform
trans, _ = get_transform()
train_set = MiniImageNet_Dataset('../hw4_data/train/', trans)
valid_set = MiniImageNet_Dataset('../hw4_data/val/', trans)
print(train_set.data[:10], train_set.label[:10])
print(valid_set.data[:10], valid_set.label[:10])
print(len(set(train_set.label)))
def main():
anchors = [30, 54, 95]
shuffle = not (args.no_shuffle)
exp = args.exp
warm_up_epoch = 3
# Load and process data
if args.fold:
df_train = pd.read_csv(args.data_path +
'k_fold/official_train_fold%d.csv' %
(args.fold))
df_val = pd.read_csv(args.data_path +
'k_fold/official_val_fold%d.csv' % (args.fold))
else:
df_train = pd.read_csv(args.data_path + 'official_train.csv')
df_val = pd.read_csv(args.data_path + 'official_val.csv')
train = df_train.image_path.to_list()
val = df_val.image_path.to_list()
if exp:
y_train = df_train.anchor.to_list()
y_val = df_val.anchor.to_list()
reg_train_gt = df_train.exp_wind.to_list()
reg_val_gt = df_val.exp_wind.to_list()
else:
y_train = df_train.wind_speed.to_list()
y_val = df_val.wind_speed.to_list()
train_transform, val_transform = get_transform(args.image_size)
train_dataset = WindDataset(image_list=train,
target=y_train,
exp_target=reg_train_gt if exp else None,
transform=train_transform)
val_dataset = WindDataset(image_list=val,
target=y_val,
exp_target=reg_val_gt if exp else None,
transform=val_transform)
train_loader = DataLoader(dataset=train_dataset,
batch_size=args.batch_size,
shuffle=shuffle,
num_workers=args.num_workers,
drop_last=True)
val_loader = DataLoader(dataset=val_dataset,
batch_size=args.batch_size,
shuffle=False,
num_workers=args.num_workers,
drop_last=True)
warm_loader = DataLoader(dataset=train_dataset,
batch_size=args.batch_size * 14,
shuffle=shuffle,
num_workers=args.num_workers,
drop_last=True)
# Load model
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
last_epoch = 0
# model = ResNet50_BN_idea()
if not exp:
model = Effnet_Wind_B7()
# model = Effnet_Wind_B5()
else:
model = Effnet_Wind_B5_exp_6()
# model = ResNetExample()
# if not exp:
# model = Seresnext_Wind()
# else:
# model = Seresnext_Wind_Exp()
# Optimizer
if args.opt == 'radam':
optimizer = RAdam(
model.parameters(),
lr=args.lr,
betas=(0.9, 0.999),
eps=1e-8,
weight_decay=args.weight_decay,
)
elif args.opt == 'adamw':
optimizer = AdamW(model.parameters(), args.lr)
elif args.opt == 'adam':
optimizer = Adam(model.parameters(),
args.lr,
weight_decay=args.weight_decay)
else:
optimizer = SGD(model.parameters(),
args.lr,
momentum=0.9,
nesterov=True,
weight_decay=args.weight_decay)
if args.weights:
# model.load_state_dict(torch.load(args.weights))
last_epoch = extract_number(args.weights)
try:
checkpoint = torch.load(args.weights)
model.load_state_dict(checkpoint['model_state_dict'])
if checkpoint['pre_opt'] == args.opt:
optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
print(optimizer)
except:
model.load_state_dict(torch.load(args.weights))
else:
model.apply(reset_m_batchnorm)
model.to(device)
# Loss function
if exp:
criterion = JointLoss2()
else:
criterion = RMSELoss()
# generate log and visualization
save_path = args.save_path
log_cache = (args.batch_size, args.image_size, shuffle, exp)
write_log(args.save_path, model, optimizer, criterion, log_cache)
plot_dict = {'train': list(), 'val': list()}
log_train_path = save_path + 'training_log.txt'
plot_train_path = save_path + 'log.json'
write_mode = 'w'
if os.path.exists(log_train_path) and os.path.exists(plot_train_path):
write_mode = 'a'
with open(plot_train_path, 'r') as j:
plot_dict = json.load(j)
plot_dict['train'] = plot_dict['train'][:last_epoch]
plot_dict['val'] = plot_dict['val'][:last_epoch]
# Training
print('Start warm up')
model.freeze_except_last()
for epoch in range(warm_up_epoch):
warm_up(
model=model,
dataloader=warm_loader,
optimizer=optimizer,
criterion=criterion,
device=device,
)
model.unfreeze()
with open(log_train_path, write_mode) as f:
for epoch in range(1, args.epoch + 1):
print('Epoch:', epoch + last_epoch)
f.write('Epoch: %d\n' % (epoch + last_epoch))
loss = train_epoch(model=model,
dataloader=train_loader,
optimizer=optimizer,
criterion=criterion,
device=device,
exp=exp)
RMSE = val_epoch(model=model,
dataloader=val_loader,
device=device,
exp=exp,
anchors=anchors)
if not exp:
f.write('Training loss: %.4f\n' % (loss))
f.write('RMSE val: %.4f\n' % (RMSE))
print('RMSE loss: %.4f' % (loss))
print('RMSE val: %.4f' % (RMSE))
else:
loss, classify, regress = loss
RMSE, accuracy = RMSE
f.write('Training loss: %.4f\n' % (loss))
f.write('Classification loss: %.4f\n' % (classify))
f.write('Regression loss: %.4f\n' % (regress))
f.write('Accuracy val: %.4f\n' % (accuracy))
f.write('RMSE val: %.4f\n' % (RMSE))
print('Training loss: %.4f' % (loss))
print('Classification loss: %.4f' % (classify))
print('Regression loss: %.4f' % (regress))
print('Accuracy val: %.4f' % (accuracy))
print('RMSE val: %.4f' % (RMSE))
# torch.save(model.state_dict(), save_path + 'epoch%d.pth'%(epoch+last_epoch))
save_name = save_path + 'epoch%d.pth' % (epoch + last_epoch)
save_pth(save_name, epoch + last_epoch, model, optimizer, args.opt)
plot_dict['train'].append(loss)
plot_dict['val'].append(RMSE)
with open(plot_train_path, 'w') as j:
json.dump(plot_dict, j)
num_classes=len(classnames)).to(device)
elif args.backbone == 'shufflenetv2':
model = shufflenetv2.ShuffleNetV2(
anchors, in_size=in_size,
num_classes=len(classnames)).to(device)
else:
print('unknown backbone architecture!')
sys.exit(0)
model.load_state_dict(torch.load(args.model, map_location=device))
else:
model = torch.load(args.model, map_location=device)
model.eval()
decoder = yolov3.YOLOv3EvalDecoder(in_size, len(classnames), anchors)
transform = dataset.get_transform(train=False,
net_w=in_size[0],
net_h=in_size[1])
FloatTensor = torch.cuda.FloatTensor if torch.cuda.is_available(
) else torch.FloatTensor
def process_single_image(filename):
bgr = cv2.imread(filename, cv2.IMREAD_COLOR)
assert bgr is not None, 'cv2.imread({}) fail'.format(filename)
rgb = cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB)
x, _ = transform(rgb, None)
x = x.type(FloatTensor) / norm
ys = model(x)
dets = decoder(ys)
dets = utils.get_network_boxes(dets, bgr.shape[:2], thresh=args.thresh)
dets = utils.do_nms_sort(dets)
if args.store:
def main():
savePath = 'model.pth'
selectedDevice = ''
# let's train it for 10 epochs
num_epochs = 10
try:
opts, args = getopt.getopt(sys.argv[1:], "o:d:e:",
["modelOutputPath=", "device=", "epochs="])
except getopt.error as err:
print(str(err))
sys.exit(2)
for opt, arg in opts:
if opt in ("-o", "--modelOutputPath"):
if arg.endswith(".pth") is True or arg.endswith('.pt') is True:
savePath = arg
else:
print("Input Error: modelOutputPath must end in .pth or .pt")
sys.exit(2)
if opt in ("-d", "--device"):
lower = arg.lower()
if lower == "gpu" or lower == "cpu":
selectedDevice = arg.lower()
else:
print("Input Error: Device must be either 'gpu' or 'cpu'")
sys.exit(2)
if opt in ("-e", "--epochs"):
epochs = int(arg)
if epochs > 0:
num_epochs = epochs
# train on the GPU or on the CPU, if a GPU is not available
device = torch.device(
'cuda') if torch.cuda.is_available() else torch.device('cpu')
# check if user has requested either cpu or gpu processing
if torch.cuda.is_available() and selectedDevice == '':
print("CUDA device is detected, using GPU for training and evaluation")
elif selectedDevice != '':
if selectedDevice == 'gpu':
if torch.cuda.is_available() is False:
print("Cannot find CUDA driver or device")
sys.exit(2)
device = torch.device('cuda')
if selectedDevice == 'cpu':
device = torch.device('cpu')
# our dataset has two classes only - background and person
num_classes = 2
# use our dataset and defined transformations
dataset = PennFudanDataset('PennFudanPed', get_transform(train=True))
dataset_test = PennFudanDataset('PennFudanPed', get_transform(train=False))
# split the dataset in train and test
indices = torch.randperm(len(dataset)).tolist()
dataset = torch.utils.data.Subset(dataset, indices[:-50])
dataset_test = torch.utils.data.Subset(dataset_test, indices[-50:])
# define training and validation data loaders
# these organize the process for sending information to the GPU
data_loader = torch.utils.data.DataLoader(dataset,
batch_size=2,
shuffle=True,
num_workers=4,
collate_fn=utils.collate_fn)
data_loader_test = torch.utils.data.DataLoader(dataset_test,
batch_size=1,
shuffle=False,
num_workers=4,
collate_fn=utils.collate_fn)
# get the model using our helper function
model = get_model_instance_segmentation(num_classes)
# move model to the selected device
model.to(device)
# construct an optimizer
params = [p for p in model.parameters() if p.requires_grad]
optimizer = torch.optim.SGD(params,
lr=0.005,
momentum=0.9,
weight_decay=0.0005)
# and a learning rate scheduler
lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer,
step_size=3,
gamma=0.1)
for epoch in range(num_epochs):
# train for one epoch, printing every 10 iterations
train_one_epoch(model,
optimizer,
data_loader,
device,
epoch,
print_freq=10)
# update the learning rate
lr_scheduler.step()
# evaluate on the test dataset
evaluate(model, data_loader_test, device=device)
# save the model to the current directory
torch.save(model.state_dict(), savePath)
print("Finished")
