def info_tutorial():
nn = NeuralNet()
x_shape = dat.shape()
test_gen, _ = dat.testset(batch_size=cfg.BATCH_SIZE,
max_samples=cfg.TEST_SET_SIZE)
nn.test(test_gen, print_it=True)
nn.net.initialize_spatial_layers(x_shape, cfg.BATCH_SIZE, PATCH_SIZE)
nn.summary(x_shape, print_it=True)
nn.print_weights()
print(nn.output_size(x_shape))
# Spatial Operations, defined one the net itself. Remember that after enabling a layer, ops are affected
assert nn.net.num_spatial_layers() != 0
nn.net.print_spatial_status()
# nn.train(epochs=1, set_size=5000, lr=0.1, batch_size=cfg.BATCH_SIZE) # Train to see fully disabled performance
nn.net.print_ops_summary()
nn.net.print_ops_summary(
use_conv=True) # Count convlution operations instead of MAC
print(nn.net.num_ops()) # (ops_saved, total_ops)
# Given x, we generate all spatial layer requirement sizes:
spat_sizes = nn.net.generate_spatial_sizes(x_shape)
print(spat_sizes)
p_spat_sizes = nn.net.generate_padded_spatial_sizes(x_shape, PATCH_SIZE)
print(p_spat_sizes)
# Generate a constant 1 value mask over all spatial nets
print(nn.net.enabled_layers())
nn.net.fill_masks_to_val(1)
print(nn.net.enabled_layers())
print(nn.net.disabled_layers())
nn.net.print_spatial_status(
) # Now all are enabled, seeing the mask was set
nn.train(epochs=1, set_size=5000, lr=0.1, batch_size=cfg.BATCH_SIZE
) # Train to see all layers enabled performance
nn.net.print_ops_summary()
nn.net.print_ops_summary(
use_conv=True) # Count convlution operations instead of MAC
nn.net.reset_spatial() # Disables layers as well
nn.net.print_ops_summary()
nn.net.print_ops_summary(use_conv=True)
# Turns on 3 ids and turns off all others
chosen_victims = random.sample(range(nn.net.num_spatial_layers()), 4)
nn.net.strict_mask_update(update_ids=chosen_victims[0:3],
masks=[
torch.zeros(p_spat_sizes[chosen_victims[0]]),
torch.zeros(p_spat_sizes[chosen_victims[1]]),
torch.zeros(p_spat_sizes[chosen_victims[2]])
])
# Turns on one additional id and *does not* turn off all others
nn.net.lazy_mask_update(
update_ids=[chosen_victims[3]],
masks=[torch.zeros(p_spat_sizes[chosen_victims[3]])])
nn.net.print_spatial_status() #
print(nn.net.enabled_layers())
nn.train(epochs=1, set_size=5000, lr=0.1,
batch_size=cfg.BATCH_SIZE) # Run with 4 layers on
nn.net.print_ops_summary()
nn.net.print_ops_summary(use_conv=True)
def create_FR_after_retrain(self,
mode,
acc_loss,
retrain=True,
epochs=50,
lr=0.01):
final_rec = self.create_FR_with_different_acc_loss(mode, acc_loss)
if retrain:
self.retrain_with_mask(final_rec, epochs=epochs, lr=lr)
retrain_nn = NeuralNet(ckp_name_prefix=final_rec.get_retrain_prefix())
retrain_nn.net.initialize_spatial_layers(dat.shape(), cfg.BATCH_SIZE,
self.ps)
retrain_nn.net.reset_spatial()
retrain_nn.net.strict_mask_update(update_ids=list(
range(len(final_rec.mask))),
masks=final_rec.mask)
if INNAS_COMP:
test_acc = 100
ops_saved = 100
ops_total = 100
else:
_, test_acc, _ = retrain_nn.test(self.test_gen)
ops_saved, ops_total = retrain_nn.net.num_ops()
final_rec.retrain_update(test_acc, ops_saved, ops_total, epochs, lr)
print(final_rec)
save_to_file(final_rec, path=cfg.RESULTS_DIR)
def __init__(self, resume=True, ckp_name_prefix=None):
# Decide on device:
if torch.cuda.is_available():
# print('CUDA FOUND!')
self.device = torch.device('cuda')
cudnn.benchmark = True
if torch.cuda.device_count() > 1:
raise NotImplementedError
# This line enables multiple GPUs, but changes the layer names a bit
# self.net = torch.nn.DataParallel(self.net)
# Useful if you have multiple GPUs - does not hurt otherwise
else:
self.device = torch.device('cpu')
# torch.set_num_threads(4) # Presuming 4 cores
print('WARNING: Found no valid GPU device - Running on CPU')
# Build Model:
print(f'==> Building model {net.__name__} on the dataset {dat.name()}')
self.net = net(self.device, dat.num_classes(), dat.input_channels(),
dat.shape())
print(f'==> Detected family model of {self.net.family_name()}')
if resume:
print(
f'==> Resuming from checkpoint via sorting method: {cfg.RESUME_METHOD}'
)
assert os.path.isdir(
cfg.CHECKPOINT_DIR), 'Error: no checkpoint directory found!'
ck_file = self.__class__.resume_methods[cfg.RESUME_METHOD](
self.net.family_name(), ckp_name_prefix=ckp_name_prefix)
if ck_file is None:
print(
f'-E- Found no valid checkpoints for {net.__name__} on {dat.name()}'
)
self.best_val_acc = 0
self.start_epoch = 0
else:
checkpoint = torch.load(ck_file, map_location=self.device)
self._load_checkpoint(checkpoint['net'])
self.best_val_acc = checkpoint['acc']
self.start_epoch = checkpoint['epoch']
assert (dat.name() == checkpoint['dataset'])
print(
f'==> Loaded model with val-acc of {self.best_val_acc:.3f}'
)
else:
self.best_val_acc = 0
self.start_epoch = 0
self.net = self.net.to(self.device)
# Build SGD Algorithm:
self.criterion = torch.nn.CrossEntropyLoss()
self.train_gen, self.val_gen, self.classes = (None, None, None)
self.optimizer = None
def gen_first_lvl_results(self, mode):
rec_filename = self.record_finder.find_rec_filename(
mode, RecordType.FIRST_LVL_REC)
if rec_filename is not None:
rcs = load_from_file(rec_filename, path='')
st_point = rcs.find_resume_point()
if st_point is None:
return rcs
layers_layout = self.nn.net.generate_spatial_sizes(dat.shape())
self._init_nn()
if rec_filename is None:
if self.input_patterns is None:
rcs = Record(layers_layout, self.gran_thresh, True, mode,
self.init_acc, self.ps, self.ones_range)
else:
rcs = Record(layers_layout, self.gran_thresh, False, mode,
self.init_acc, self.input_patterns,
self.ones_range)
st_point = [0] * 4
if INNAS_COMP:
rcs.filename = 'DEBUG_' + rcs.filename
print('==> Result will be saved to ' +
os.path.join(cfg.RESULTS_DIR, rcs.filename))
save_counter = 0
for layer, channel, patch, pattern_idx, mask in tqdm(
mf.gen_masks_with_resume(self.ps,
rcs.all_patterns,
rcs.mode,
rcs.gran_thresh,
layers_layout,
resume_params=st_point)):
self.nn.net.strict_mask_update(update_ids=[layer],
masks=[torch.from_numpy(mask)])
if INNAS_COMP:
test_acc = 100
ops_saved = 100
ops_total = 100
else:
_, test_acc, _ = self.nn.test(self.test_gen)
ops_saved, ops_total = self.nn.net.num_ops()
self.nn.net.reset_spatial()
rcs.addRecord(ops_saved, ops_total, test_acc, layer, channel,
patch, pattern_idx)
save_counter += 1
if save_counter > cfg.SAVE_INTERVAL:
save_to_file(rcs, True, cfg.RESULTS_DIR)
save_counter = 0
save_to_file(rcs, True, cfg.RESULTS_DIR)
print('==> Result saved to ' +
os.path.join(cfg.RESULTS_DIR, rcs.filename))
return rcs
def training():
# dat.data_summary(show_sample=False)
nn = NeuralNet(resume=True) # Spatial layers are by default, disabled
nn.summary(dat.shape())
nn.train(epochs=50, lr=0.01)
test_gen, _ = dat.testset(batch_size=cfg.BATCH_SIZE,
max_samples=cfg.TEST_SET_SIZE)
test_loss, test_acc, count = nn.test(test_gen)
print(
f'==> Final testing results: test acc: {test_acc:.3f} with {count}, test loss: {test_loss:.3f}'
)
def plot_ops_saved_accuracy_uniform_network(self):
layers_layout = self.nn.net.generate_spatial_sizes(dat.shape())
rcs = Record(layers_layout, self.gran_thresh, True, Mode.UNIFORM_LAYER,
self.init_acc, self.ps, self.ones_range)
no_of_patterns = rcs.all_patterns.shape[2]
ops_saved_array = [None] * no_of_patterns
acc_array = [None] * no_of_patterns
self._init_nn()
for p_idx in range(no_of_patterns):
sp_list = [None] * len(layers_layout)
for layer, layer_mask in enumerate(
mf.base_line_mask(layers_layout,
self.ps,
pattern=rcs.all_patterns[:, :, p_idx])):
sp_list[layer] = torch.from_numpy(layer_mask)
self.nn.net.strict_mask_update(update_ids=list(
range(len(layers_layout))),
masks=sp_list)
_, test_acc, _ = self.nn.test(self.test_gen)
ops_saved, ops_total = self.nn.net.num_ops()
self.nn.net.reset_ops()
ops_saved_array[p_idx] = ops_saved / ops_total
acc_array[p_idx] = test_acc
plt.figure()
plt.subplot(211)
plt.plot(list(range(no_of_patterns)), ops_saved_array, 'o')
plt.xlabel('pattern index')
plt.ylabel('ops_saved [%]')
plt.title(f'ops saved for uniform network, patch_size:{self.ps}')
plt.subplot(212)
plt.plot(list(range(no_of_patterns)), acc_array, 'o')
plt.xlabel('pattern index')
plt.ylabel('accuracy [%]')
plt.title(f'accuracy for uniform network, patch_size:{self.ps}')
data = [rcs.all_patterns, ops_saved_array, acc_array]
save_to_file(
data, False, cfg.RESULTS_DIR,
'baseline_all_patterns_{cfg.NET.__name__}_{dat.name()}' +
f'acc{self.init_acc}_ps{self.ps}_ones{self.ones_range[0]}x{self.ones_range[1]}_mg{self.gran_thresh}.pkl'
)
plt.savefig(
f'{cfg.RESULTS_DIR}/baseline_all_patterns_{cfg.NET.__name__}_{dat.name()}'
+
f'acc{self.init_acc}_ps{self.ps}_ones{self.ones_range[0]}x{self.ones_range[1]}_mg{self.gran_thresh}.pdf'
)
return data
def base_line_result(self):
layers_layout = self.nn.net.generate_spatial_sizes(dat.shape())
self._init_nn()
sp_list = [None] * len(layers_layout)
for layer, layer_mask in enumerate(
mf.base_line_mask(layers_layout, self.ps)):
sp_list[layer] = torch.from_numpy(layer_mask)
self.nn.net.strict_mask_update(update_ids=list(
range(len(layers_layout))),
masks=sp_list)
_, test_acc, _ = self.nn.test(self.test_gen)
ops_saved, ops_total = self.nn.net.num_ops()
bl_rec = BaselineResultRc(self.init_acc, test_acc, ops_saved,
ops_total, self.ps, cfg.NET.__name__,
dat.name())
print(bl_rec)
save_to_file(bl_rec, True, cfg.RESULTS_DIR)
def __init__(self,
patch_size,
ones_range,
gran_thresh,
max_acc_loss,
init_acc=None,
test_size=cfg.TEST_SET_SIZE,
patterns_idx=None):
self.ps = patch_size
self.max_acc_loss = max_acc_loss
self.gran_thresh = gran_thresh
if patterns_idx is None:
self.ones_range = ones_range
self.input_patterns = None
else:
patterns_rec = load_from_file(
f'all_patterns_ps{self.ps}_cluster{patterns_idx}.pkl',
path=cfg.RESULTS_DIR)
self.ones_range = (patterns_rec[1], patterns_rec[1] + 1)
self.input_patterns = patterns_rec[2]
self.full_net_run_time = None
self.total_ops = None
self.nn = NeuralNet()
self.nn.net.initialize_spatial_layers(dat.shape(), cfg.BATCH_SIZE,
self.ps)
self.test_gen, _ = dat.testset(batch_size=cfg.BATCH_SIZE,
max_samples=cfg.TEST_SET_SIZE)
self.test_set_size = cfg.TEST_SET_SIZE
if INNAS_COMP:
init_acc = DEBUG_INIT_ACC
if init_acc is None:
_, test_acc, correct = self.nn.test(self.test_gen)
print(f'==> Asserted test-acc of: {test_acc} [{correct}]\n ')
self.init_acc = test_acc # TODO - Fix initialize bug
else:
self.init_acc = init_acc
self.record_finder = RecordFinder(cfg.NET.__name__, dat.name(),
patch_size, ones_range, gran_thresh,
max_acc_loss, self.init_acc)
def eval_run_time(self, mode, no_of_tries=5):
layers_layout = self.nn.net.generate_spatial_sizes(dat.shape())
if self.input_patterns is None:
recs_first_lvl = Record(layers_layout, self.gran_thresh, True,
mode, self.init_acc, self.ps,
self.ones_range)
else:
recs_first_lvl = Record(layers_layout, self.gran_thresh, False,
mode, self.init_acc, self.input_patterns,
self.ones_range)
first_lvl_runs = recs_first_lvl.size
self.nn.net.reset_spatial()
run_time_for_iter = 0
for idx in range(no_of_tries):
layer = random.randint(0, recs_first_lvl.no_of_layers - 1)
channel = random.randint(0,
recs_first_lvl.no_of_channels[layer] - 1)
patch = random.randint(0, recs_first_lvl.no_of_patches[layer] - 1)
pattern_idx = random.randint(
0, recs_first_lvl.no_of_patterns[layer] - 1)
pattern = recs_first_lvl.all_patterns[:, :, pattern_idx]
mask = mf.get_specific_mask(layers_layout[layer], channel, patch,
pattern,
recs_first_lvl.patch_sizes[layer],
mode)
st_time = time.time()
self.nn.net.reset_spatial()
self.nn.net.strict_mask_update(update_ids=[layer],
masks=[torch.from_numpy(mask)])
_, test_acc, _ = self.nn.test(self.test_gen)
end_time = time.time()
run_time_for_iter += (end_time - st_time)
run_time_for_iter = run_time_for_iter / no_of_tries
recs_first_lvl.fill_empty()
if mode == Mode.UNIFORM_LAYER:
second_lvl_runs = 0
lQ = LayerQuantizier(recs_first_lvl, self.init_acc, 0, self.ps,
self.ones_range, self.get_total_ops())
lQ_runs = lQ.number_of_iters()
elif mode == Mode.MAX_GRANULARITY:
pQ = PatchQuantizier(recs_first_lvl, self.init_acc, 0, self.ps)
pQ.output_rec.fill_empty()
cQ = ChannelQuantizier(pQ.output_rec, self.init_acc, 0, self.ps)
cQ.output_rec.fill_empty()
second_lvl_runs = pQ.number_of_iters() + cQ.number_of_iters()
lQ = LayerQuantizier(cQ.output_rec, self.init_acc, 0, self.ps,
self.ones_range, self.get_total_ops())
lQ_runs = lQ.number_of_iters()
elif mode == Mode.UNIFORM_FILTERS:
pQ = PatchQuantizier(recs_first_lvl, self.init_acc, 0, self.ps)
second_lvl_runs = pQ.number_of_iters()
pQ.output_rec.fill_empty()
lQ = LayerQuantizier(pQ.output_rec, self.init_acc, 0, self.ps,
self.ones_range, self.get_total_ops())
lQ_runs = lQ.number_of_iters()
elif mode == Mode.UNIFORM_PATCH:
cQ = ChannelQuantizier(recs_first_lvl, self.init_acc, 0, self.ps)
cQ.output_rec.fill_empty()
second_lvl_runs = cQ.number_of_iters()
lQ = LayerQuantizier(cQ.output_rec, self.init_acc, 0, self.ps,
self.ones_range, self.get_total_ops())
lQ_runs = lQ.number_of_iters()
no_of_runs = (first_lvl_runs, second_lvl_runs, lQ_runs)
run_times = (round(run_time_for_iter,
3), self.get_full_net_run_time(no_of_tries))
return no_of_runs, run_times
