def _load(self, pth_path: str):
"""Loading model.
Args:
pth_path (str): pth path.
Raises:
FileNotFoundError: file not exists.
"""
# check exist
if not os.path.exists(pth_path):
err = OSError(errno.ENOENT, os.strerror(errno.ENOENT), pth_path)
raise FileNotFoundError(err)
# load checkpoint
checkpoint = torch.load(pth_path)
# classes, network
self.classes = checkpoint["classes"]
self.classify_size = len(self.classes)
# network
self.net = cnn.Net(
input_size=self.input_size,
classify_size=self.classify_size,
in_channels=self.in_channels,
)
self.net.load_state_dict(checkpoint["model_state_dict"])
self.net.to(self.device) # switch to GPU / CPU
self.net.eval() # switch to eval
def _build_model(self):
self.net = cnn.Net(input_size=self.input_size) # network
# self.optimizer = optim.SGD(self.net.parameters(), lr=0.01)
self.optimizer = optim.Adam(self.net.parameters(), lr=1e-3, betas=(0.9, 0.999), eps=1e-8)
self.criterion = nn.CrossEntropyLoss()
self.net.zero_grad() # init all gradient
self.net.to(self.device) # switch to GPU / CPU
def test(test_set, PATH):
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
classes = ('0', '1')
batch_size = 4
num_workers = 2
test_loader = torch.utils.data.DataLoader(test_set,
batch_size=batch_size,
shuffle=False,
num_workers=num_workers)
net = cnn.Net().to(device)
net.load_state_dict(torch.load(PATH))
correct = 0
total = 0
n_class_correct = [0 for i in range(2)]
n_class_samples = [0 for i in range(2)]
criterion = nn.CrossEntropyLoss()
with torch.no_grad():
epoch_loss = 0.0
for i, (images, labels) in enumerate(test_loader):
images = images.to(device)
labels = labels.to(device)
outputs = net(images)
loss = criterion(outputs, labels)
epoch_loss += loss.item()
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
for l in range(batch_size):
label = labels[l]
pred = predicted[l]
if (label == pred):
n_class_correct[label] += 1
n_class_samples[label] += 1
for m in range(2):
acc = 100 * n_class_correct[m] / n_class_samples[m]
print('Accuracy of %s: %.3f %%' % (classes[m], acc))
accuracy = 100 * correct / total
loss_t = 100 * epoch_loss / i
print('Accuracy of the network on the 10000 test images: %.3f %%' %
(accuracy))
print('Loss of the network on the 10000 test images: %.3f %%' % (loss_t))
return loss_t, accuracy
def train_model():
dataloader = load_dataset(train=True)
model = cnn.Net()
model.to(cnn.get_device())
model.train()
model, dictionary = cnn.train_model(model=model,
dataloader=dataloader,
num_epochs=10)
print("Time spent: {:.2f}s".format(dictionary['exec_time']))
torch.save(model.state_dict(), "./modelo/mnist.pt")
save_stats(dictionary)
def __init__(self,
prototxt_name,
model_name,
batch_size=1,
max_num_proposals=60,
output_dim=201,
iou_thres=0.3):
self.Net = cnn.Net(prototxt_name, model_name, batch_size)
self.proposer = region_proposer.proposer(max_num_proposals)
self.nms = nms.reducer(iou_thres)
self.output_dim = output_dim
def test_model():
dataloader = load_dataset(train=False)
model = cnn.Net()
model.load_state_dict(torch.load("./modelo/mnist.pt"))
model.to(cnn.get_device())
model.eval()
dictionary = cnn.test_model(model=model, dataloader=dataloader)
classes = list(dataloader.dataset.class_to_idx.keys())
dictionary['classes'] = classes
dictionary = {**load_stats(), **dictionary}
save_stats(dictionary)
show_stats(dictionary)
def train(train_set):
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
batch_size = 4
num_workers = 2
learning_rate = 0.001
momentum = 0.9
num_epochs = 2
train_loader = torch.utils.data.DataLoader(train_set,
batch_size=batch_size,
shuffle=True,
num_workers=num_workers)
net = cnn.Net().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(),
lr=learning_rate,
momentum=momentum)
for epoch in range(num_epochs):
for i, (inputs, labels) in enumerate(train_loader):
inputs = inputs.to(device)
labels = labels.to(device)
optimizer.zero_grad()
outputs = net(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
epoch_loss = 0.0
for j, (inputs, labels) in enumerate(train_loader):
inputs = inputs.to(device)
labels = labels.to(device)
outputs = net(inputs)
loss = criterion(outputs, labels)
epoch_loss += loss.item()
print('Finished Training')
torch.save(net.state_dict(), './mnist_net.pth')
print('Loss of the network on the train images: %.3f' % (epoch_loss /
(j + 1)))
return epoch_loss / (j + 1)
def __init__(self):
self.test_on_gpu = torch.cuda.is_available()
self.device = torch.device("cuda" if self.test_on_gpu else "cpu")
self.model = cnn.Net()
self.model.to(self.device)
print(self.device)
self.model.double()
self.model.load_state_dict(torch.load("./src/construction_site_lane_detection/models/nn_model.pt"))
self.model.eval()
self.state = 1 #there is a red truck in front
self.frame_count = 0
def assert_image(dataloader, index):
model = cnn.Net()
model.load_state_dict(torch.load("./modelo/mnist.pt"))
model.to(cnn.get_device())
model.eval()
image = dataloader.dataset[index][0]
image = image.to(cnn.get_device())
image = image[None]
image = image.type('torch.FloatTensor')
predictated = cnn.assert_image(model, image)
class_map = dict(map(reversed, dataloader.dataset.class_to_idx.items()))
print(class_map[predictated])
show_image(dataloader, index)
return predictated
import numpy as np
import cnn
import torch.optim as optim
import torch.nn as nn
import sklearn.model_selection as skms
import torch
print("===============Loading data...================")
x_train, x_test, y_train, y_test = Utl.load_data22_from_all()
print("x_train shape: ", x_train.shape)
print("x_test shape: ", x_test.shape)
print("y_train shape: ", y_train.shape)
print("y_test shape: ", y_test.shape)
print("===============Training model...==============")
net = cnn.Net()
net.cuda()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(net.parameters(), lr=0.001, weight_decay=0.01)
for epoch in range(1): # loop over the dataset multiple times
running_loss = 0.0
for i in range(2000):
inputs, labels = Utl.mini_batch(x_train, y_train, batch_size=200)
labels = Utl.index_code(labels)
inputs, labels = torch.from_numpy(inputs), torch.from_numpy(labels)
inputs = torch.unsqueeze(inputs, 1)
inputs = inputs.float()
labels = labels.long()
inputs, labels = Variable(inputs.cuda()), Variable(labels.cuda())
def fit(F,
D,
sr,
time_win_sec,
log_dir=os.getcwd(),
log_id='id0',
O={},
overwrite=False,
plot_figures=True,
sort_weights_PC1=False,
sort_data_PC1=False):
# default optional parameters
P = {}
P['rank'] = None
P['weight_scale'] = 1e-6
P['learning_rate'] = 0.001
P['early_stopping_steps'] = 10
P['train_val_test_frac'] = [0.6, 0.2, 0.2]
P['eval_interval'] = 5
P['max_iter'] = 1000
P['act'] = 'relu'
P['seed'] = 0
P['stim_labels'] = None
P['print_iter'] = True
# replace defaults with optional parameters
P = misc.param_handling(
P,
O,
maxlen=100,
delimiter='/',
omit_key_from_idstring=['stim_labels', 'print_iter'])
# feature dimensionality
n_stims = F.shape[0]
n_tps = F.shape[1]
n_feats = F.shape[2]
# data dimensionality
if len(D.shape) == 2:
D = np.reshape(D, [n_stims, n_tps, 1])
n_resp = D.shape[2]
data_dims = [n_stims, n_tps, n_resp]
assert (D.shape[0] == n_stims)
assert (D.shape[1] == n_tps)
# create train, validation, test splits
if P['stim_labels'] is None:
labels = np.zeros((n_stims, 1))
else:
labels = P['stim_labels']
train_val_test = misc.partition_within_labels(labels,
P['train_val_test_frac'],
seed=P['seed'])
# directory to save results
idstring = 'win-' + misc.num2str(time_win_sec) + '_sr-' + misc.num2str(sr)
if P['idstring']:
idstring = idstring + '_' + P['idstring']
save_directory = misc.mkdir(log_dir + '/' + idstring)
# file with the key stats
stats_file = save_directory + '/stats_' + log_id + '.p'
if os.path.exists(stats_file) and not (overwrite):
S = pickle.load(open(stats_file, "rb"))
else:
# create single layer CNN with above parameters
layer = {}
layer['type'] = 'conv'
layer['n_kern'] = n_resp
layer['time_win_sec'] = time_win_sec
layer['act'] = P['act']
layer['rank'] = P['rank']
layers = []
layers.append(layer)
# initialize, build, and train
tf.reset_default_graph()
n_weights = (time_win_sec * sr * n_feats)
net = cnn.Net(data_dims,
n_feats,
sr,
deepcopy(layers),
loss_type='squared_error',
weight_scale=P['weight_scale'] / n_weights,
seed=P['seed'],
log_dir=save_directory,
log_id=log_id)
net.build()
net.train(F,
D,
max_iter=P['max_iter'],
eval_interval=P['eval_interval'],
learning_rate=P['learning_rate'],
train_val_test=train_val_test,
early_stopping_steps=P['early_stopping_steps'],
print_iter=P['print_iter'])
S = {}
S['train_loss'] = net.train_loss
S['val_loss'] = net.val_loss
S['test_loss'] = net.test_loss
S['W'] = net.layer_vals()[0]['W']
S['Y'] = net.predict(F)
S['train_val_test'] = train_val_test
pickle.dump(S, open(stats_file, "wb"))
print('Train loss:', S['train_loss'][-1])
print('Val loss:', S['val_loss'][-1])
print('Test loss:', S['test_loss'][-1])
S['test_corr'] = np.corrcoef(
S['Y'][S['train_val_test'] == 2, :, 0].flatten(),
D[S['train_val_test'] == 2, :, 0].flatten())[0, 1]
if plot_figures:
# loss
plt.plot(S['train_loss'])
plt.plot(S['val_loss'])
plt.plot(S['test_loss'])
plt.legend(['Train', 'Val', 'Test'])
plt.xlabel('Eval Iter')
plt.ylabel('Loss')
plt.savefig(save_directory + '/loss_' + log_id + '.pdf',
bbox_inches='tight')
plt.show()
# predictions
xi = np.where(S['train_val_test'] == 2)[0]
if sort_data_PC1:
[U, E, V] = np.linalg.svd(np.transpose(D[xi, :, 0]))
feat_weights = V[0, :] * np.sign(U[:, 0].mean())
xi = xi[np.flipud(np.argsort(feat_weights))]
plt.figure(figsize=(10, 5))
plt.subplot(1, 2, 1)
plot.imshow(D[xi, :, 0])
plt.title('Data')
plt.ylabel('Test stims')
plt.xlabel('Time')
plt.subplot(1, 2, 2)
plot.imshow(S['Y'][xi, :, 0])
plt.title('Prediction')
plt.ylabel('Test stims')
plt.xlabel('Time')
del xi
plt.savefig(save_directory + '/predictions_' + log_id + '.pdf',
bbox_inches='tight')
plt.show()
# plot weights, optionally sort by first PC
if sort_weights_PC1:
[U, E, V] = np.linalg.svd(S['W'][:, :, 0])
feat_weights = V[0, :] * np.sign(U[:, 0].mean())
xi = np.flipud(np.argsort(feat_weights))
else:
xi = np.arange(0, n_feats)
plt.figure(figsize=(5, 5))
plot.imshow(np.fliplr(np.transpose(S['W'][:, xi, 0])))
plt.title('Weights')
plt.xlabel('Time')
plt.ylabel('Feats')
del xi
plt.savefig(save_directory + '/weights_' + log_id + '.pdf',
bbox_inches='tight')
plt.show()
return S
fig = plt.figure(figsize=(10, 4))
# display 20 images
for idx in np.arange(2):
ax = fig.add_subplot(2, 10 / 2, idx + 1, xticks=[], yticks=[])
imshow(images[idx])
ax.set_title(classes[labels[idx]])
plt.show()
criterion = torch.nn.CrossEntropyLoss()
# track test loss
test_loss = 0.0
class_correct = list(0. for i in range(2))
class_total = list(0. for i in range(2))
model = cnn.Net()
model.load_state_dict(torch.load("model_cifar.pt"))
if train_on_gpu:
model.cuda()
model.eval()
i = 1
# iterate over test data
#print(len(test_loader)) #how many batches
for data, target in test_loader:
print("target", target)
i = i + 1
if len(target) != batch_size:
continue
# move tensors to GPU if CUDA is available
def test(arguments):
# create settings from arguments
settings = {
'data_folder': Path(arguments[1]),
'model_name': arguments[2],
'masked': ('masked' in arguments),
'scrolling': ('scrolling' in arguments),
'root': ('root' in arguments),
'overlap': ('overlap' in arguments)
}
# filter users and webpages to use
users = names.get_all_users()
users_to_use = list(set(users) & set(arguments))
if users_to_use:
users = users_to_use
else:
users = users[:1]
webpages = names.get_all_webpages()
webpages_to_use = list(set(webpages) & set(arguments))
if webpages_to_use:
webpages = webpages_to_use
print('Loading Model')
net = cnn.Net()
state_file = settings['model_name'] + '.pth'
net.load_state_dict(torch.load(settings['data_folder'] / state_file))
print('Model loaded successfully')
# print settings
printer.print_settings(settings,
users,
users_to_use,
webpages,
webpages_to_use,
training=False)
# create dict from CSV files
csv_dict = dict_creator.create_dict(users, webpages, settings)
# check if the observations are getting ORed or are separate by layers and their masks
if settings['masked'] or settings['scrolling'] or settings['root']:
all_obs = [
ob for user in users for webpage in webpages
for ob in csv_dict[user][webpage]['features_meta']
]
else:
all_obs = [
ob for user in users for webpage in webpages
for ob in csv_dict[user][webpage]['labeled_obs']
]
if settings['overlap']:
all_obs = list(
filter(
lambda o: (int(o['overlap_height']) > 32) and
(int(o['overlap_width']) > 32), all_obs))
# split obs into training data and testing data
# random_seed is used so test_cnn.py will have the same list to work with
split_percentage = int(
next((s for s in arguments if 'split' in s), 'split=0').split('=')[-1])
if split_percentage:
if split_percentage > 99 or split_percentage < 1:
print('Percentage has to be between 0 and 100, splitting aborted')
else:
print('Splitting data:')
print(str(len(all_obs)) + ' observations total')
random_seed = next((s for s in arguments if 'seed' in s),
'seed=' + settings['model_name']).split('=')[-1]
random.Random(random_seed).shuffle(all_obs)
all_obs = all_obs[int(len(all_obs) * (split_percentage) / 100):]
print(str(len(all_obs)) + ' observations kept')
vids = {}
for user in users:
vids[user] = {}
for webpage in webpages:
vids[user][webpage] = cv2.VideoCapture(
get_video_file(user, webpage, settings))
predictions = []
net.eval()
labeled = 0
print('Observations to test: ' + str(len(all_obs)))
print('Testing started!')
i = 0
with torch.no_grad():
for ob in all_obs:
# prepare input
input_frame = imp.get_merged_frame_pair(
vids[ob['user']][ob['webpage']], ob, settings)
# swap color axis because
# numpy image: H x W x C
# torch image: C X H X W
input_frame = torch.from_numpy(input_frame.transpose((2, 0, 1)))
inputs = [input_frame]
target = min(1, ob['label'])
labeled += target
# get prediction
inputs = torch.stack(inputs, dim=0)
outputs = net(inputs)
outputs = torch.sigmoid(outputs)
output_labels = torch.round(outputs)
prediction = output_labels.numpy().squeeze().tolist()
not_rounded = outputs.numpy().squeeze().tolist()
# fill prediction list
predictions.append({
'target': target,
'prediction': prediction,
'not_rounded': not_rounded,
'webpage': ob['webpage'],
'user': ob['user']
})
# print statistics
i += 1
if i % 200 == 0:
print('Observations tested so far: ' + str(i))
reports = {}
target_names = ['Visually same', 'Visually different']
print('REPORT\n')
print('OVERALL')
reports['overall'] = classification_report(
[p['target'] for p in predictions],
[p['prediction'] for p in predictions],
target_names=target_names,
output_dict=True)
print(
classification_report([p['target'] for p in predictions],
[p['prediction'] for p in predictions],
target_names=target_names))
print('USERS')
for u in users:
print('User ' + u)
reports[u] = classification_report(
[p['target'] for p in predictions if p['user'] == u],
[p['prediction'] for p in predictions if p['user'] == u],
target_names=target_names,
output_dict=True)
print(
classification_report(
[p['target'] for p in predictions if p['user'] == u],
[p['prediction'] for p in predictions if p['user'] == u],
target_names=target_names))
print('WEBPAGES')
for wp in webpages:
print('Webpage ' + wp)
reports[wp] = classification_report(
[p['target'] for p in predictions if p['webpage'] == wp],
[p['prediction'] for p in predictions if p['webpage'] == wp],
target_names=target_names,
output_dict=True)
print(
classification_report(
[p['target'] for p in predictions if p['webpage'] == wp],
[p['prediction'] for p in predictions if p['webpage'] == wp],
target_names=target_names))
print('NOT ROUNDED OVERALL')
sorted_preds = sorted(predictions, key=lambda p: p['not_rounded'])
print('Split at ' +
str(sorted_preds[(len(all_obs) - labeled)]['not_rounded']))
for pred in sorted_preds[:(len(all_obs) - labeled)]:
pred['prediction'] = 0
for pred in sorted_preds[(len(all_obs) - labeled):]:
pred['prediction'] = 1
reports['not_rounded_overall'] = classification_report(
[p['target'] for p in sorted_preds],
[p['prediction'] for p in sorted_preds],
target_names=target_names,
output_dict=True)
print(
classification_report([p['target'] for p in sorted_preds],
[p['prediction'] for p in sorted_preds],
target_names=target_names))
report_file_name = settings['model_name'] + '_report.json'
report_file = open(settings['data_folder'] / report_file_name, 'w')
json.dump(reports, report_file)
report_file.close()
print('Report saved as ' + report_file_name)
gt_data = pkl.loads(fh.read())
fh.close()
gt_cqts = gt_data['gt_cqts']
gt_samples = gt_data['gt_samples']
gt_sampling_freqs = gt_data['gt_sampling_freqs']
with open("pred_data.pkl", 'rb') as fh:
pred_data = pkl.loads(fh.read())
fh.close()
pred_cqts = pred_data['pred_cqts']
pred_samples = pred_data['pred_samples']
pred_sampling_freqs = pred_data['pred_sampling_freqs']
#plt.figure(figsize=(16,12))
#plt.imshow(merge_images(gt_cqts[:16], pred_cqts[:16]))
return gt_samples, gt_sampling_freqs, pred_samples, pred_sampling_freqs
if __name__ == "__main__":
net = cnn.Net().double().to(device)
train_data, test_data, val_data, eval_data = load_data()
train_model(net, train_data, val_data, eval_data)
test(net, test_data)
#plot_curves()
#gt_samples, gt_sampling_freqs, pred_samples, pred_sampling_freqs = plot_cqts()
# for i in range(len(gt_samples)):
# print("GT")
# display(Audio(gt_samples[i], rate=2*gt_sampling_freqs[i]))
# print("Pred")
# display(Audio(pred_samples[i], rate=2*pred_sampling_freqs[i]))
sensitivity = occlusion_sensitivity(model,
images,
ids[:, [i]],
patch=p,
stride=stride,
n_batches=n_batches)
# Save results as image files
for j in range(len(images)):
print("\t#{}: {} ({:.5f})".format(j, classes[ids[j, i]],
probs[j, i]))
# save_sensitivity(
# filename=osp.join(
# output_dir,
# "{}-{}-sensitivity-{}-{}.png".format(
# j, arch, p, classes[ids[j, i]]
# ),
# ),
# maps=sensitivity[j],
# )
if __name__ == "__main__":
classes = ['crossing', 'klaxon', 'noise']
tms = _tms.factory()
net = cnn.Net(tms.input_size)
main(net, classes, tms.input_size)
def train(arguments):
# print help information
if 'help' in arguments:
printer.print_help()
sys.exit()
else:
printer.print_help_notice()
# create settings from arguments
settings = {
'data_folder': Path(arguments[1]),
'masked': ('masked' in arguments),
'scrolling': ('scrolling' in arguments),
'has_cuda': ('cuda' in arguments),
'root': ('root' in arguments),
'balanced': ('balanced' in arguments),
'overlap': ('overlap' in arguments),
'model_name': arguments[2]
}
# filter users and webpages to use
users = names.get_all_users()
users_to_use = list(set(users) & set(arguments))
if users_to_use:
users = users_to_use
else:
users = users[1:]
webpages = names.get_all_webpages()
webpages_to_use = list(set(webpages) & set(arguments))
if webpages_to_use:
webpages = webpages_to_use
# print settings
printer.print_settings(settings, users, users_to_use, webpages,
webpages_to_use)
# create dict from CSV files
csv_dict = dict_creator.create_dict(users, webpages, settings)
# CNN
net = cnn.Net()
criterion = nn.BCEWithLogitsLoss()
if 'load' in arguments:
state_file = settings['model_name'] + '.pth'
net.load_state_dict(torch.load(settings['data_folder'] / state_file))
print('Model loaded successfully')
if 'loadautosave' in arguments:
state_file = 'autosave.pth'
net.load_state_dict(torch.load(settings['data_folder'] / state_file))
print('Model loaded successfully')
if settings['has_cuda']:
device = torch.device("cuda")
net = net.cuda()
criterion = criterion.cuda()
optimizer = optim.Adam(net.parameters(), lr=0.0001)
i = 0
vids = {}
for user in users:
vids[user] = {}
for webpage in webpages:
vids[user][webpage] = cv2.VideoCapture(
get_video_file(user, webpage, settings))
torch.cuda.empty_cache()
# check if the observations are getting ORed or are separate by layers and their masks
if settings['masked'] or settings['scrolling'] or settings[
'root'] or settings['overlap']:
all_obs = [
ob for user in users for webpage in webpages
for ob in csv_dict[user][webpage]['features_meta']
]
else:
all_obs = [
ob for user in users for webpage in webpages
for ob in csv_dict[user][webpage]['labeled_obs']
]
if settings['overlap']:
all_obs = list(
filter(
lambda o: (int(o['overlap_height']) > 32) and
(int(o['overlap_width']) > 32), all_obs))
# split obs into training data and testing data
# random_seed is used so test_cnn.py will have the same list to work with
split_percentage = int(
next((s for s in arguments if 'split' in s), 'split=0').split('=')[-1])
if split_percentage:
if split_percentage > 99 or split_percentage < 1:
print('Percentage has to be between 0 and 100, splitting aborted')
else:
print('Splitting data:')
print(str(len(all_obs)) + ' observations total')
random_seed = next((s for s in arguments if 'seed' in s),
'seed=' + settings['model_name']).split('=')[-1]
random.Random(random_seed).shuffle(all_obs)
all_obs = all_obs[:int(len(all_obs) * split_percentage / 100)]
print(str(len(all_obs)) + ' observations kept')
# training parameters
batch_size = int(
next((s for s in arguments if 'batch_size' in s),
'batch_size=10').split('=')[-1])
epochs = int(
next((s for s in arguments if 'epochs' in s),
'epochs=5').split('=')[-1])
running_loss = 0.0
inputs = []
targets = []
# split obs between labels
obs1, obs2 = partition(all_obs, lambda x: x.get('label') > 0)
random.shuffle(obs1)
random.shuffle(obs2)
# start training
printer.print_training_start(obs1, obs2, batch_size, settings)
for epoch in range(epochs): # loop over the dataset multiple times
print('Epoch ' + Fore.YELLOW + str(epoch + 1) + '/' + str(epochs) +
Style.RESET_ALL + ' started')
obs1, obs2, next_obs = prepare_next_observations(obs1, obs2, settings)
for ob in next_obs:
input_frame = imp.get_merged_frame_pair(
vids[ob['user']][ob['webpage']], ob, settings)
# swap color axis because
# numpy image: H x W x C
# torch image: C X H X W
input_frame = torch.from_numpy(input_frame.transpose((2, 0, 1)))
inputs.append(input_frame)
targets.append([min(1, ob['label'])])
if len(inputs) >= batch_size:
inputs = torch.stack(inputs, dim=0)
# print(inputs.shape)
# inputs = torch.from_numpy(inputs)
targets = torch.Tensor(targets)
if settings['has_cuda']:
inputs = inputs.cuda()
targets = targets.cuda()
# forward + backward + optimize
output = net(inputs)
loss = criterion(output, targets)
# zero the parameter gradients
optimizer.zero_grad()
loss.backward()
optimizer.step()
# Clean up GPU memory
del inputs
del targets
torch.cuda.empty_cache()
# current loss
running_loss += loss.item() * batch_size
inputs = []
targets = []
# print statistics
if i % 200 == 199:
print('[%d, %5d] loss: %.3f' %
(epoch + 1, i + 1, running_loss / 200))
running_loss = 0.0
i += 1
autosave_path = settings['data_folder'] / 'autosave.pth'
torch.save(net.state_dict(), autosave_path)
print('Autosave')
if ('saveall' in arguments) and (epoch < (epochs - 1)):
file_name = settings['model_name'] + '_afterEpoch' + str(
epoch + 1) + '.pth'
PATH = settings['data_folder'] / file_name
torch.save(net.state_dict(), PATH)
print('Finished Training')
file_name = settings['model_name'] + '.pth'
PATH = settings['data_folder'] / file_name
torch.save(net.state_dict(), PATH)
print('Saved as ' + file_name)
