def fc_target(self, rank):
rank = [int(rank)]
runtime_ms = 0.0
decomp_model = copy.deepcopy(self.model)
decomp_model.cuda()
# Tucker decomposed
print('Travis 1')
decompose = tucker_decomposition_fc_layer_without_rank(
decomp_model.classifier._modules[
self.decomposed_layer_info['key']], rank)
print('Travis 2')
assert isinstance(decompose, torch.nn.modules.container.Sequential)
'''
for i in decompose:
assert isinstance(i, torch.nn.modules.linear.Linear)
tmp_ms = self.estimate_with_config([i.in_features, i.out_features])
runtime_ms += tmp_ms
'''
decomp_model.classifier._modules[
self.decomposed_layer_info['key']] = decompose
runtime_ms, _ = self.get_model_predict_runtime(decomp_model)
decomp_model.cuda()
decomp_model.eval()
#print('Travis decomp_model: {}'.format(decomp_model))
test_loss = 0
correct = 0
total = 0
beta = 1.5
for batch_idx, (inputs, targets) in enumerate(self.testloader):
inputs, targets = inputs.cuda(), targets.cuda()
with torch.no_grad():
inputs, targets = Variable(inputs), Variable(targets)
outputs = decomp_model(inputs)
loss = self.criterion(outputs, targets)
test_loss += loss.item()
_, predicted = torch.max(outputs.data, 1)
total += targets.size(0)
correct += float(predicted.eq(targets.data).cpu().sum())
decomp_model.train()
acc = 100. * correct / total
#print('Travis acc: {}, Travis runtime: {}, Value: {}'.format(acc, runtime_ms, -1*(100-acc)*(runtime_ms**0.1)))
assert (runtime_ms**self.fc_target_rate) > 0
assert runtime_ms > 1
#print('{}Travis{} fc_target error: {}, runtime_ms: {}'.format('\033[36m', '\033[0m', acc, runtime_ms))
#return -1 * (100-acc) * (runtime_ms**self.fc_target_rate)
return -1 * (100 - acc) + -1 * (runtime_ms * self.fc_target_rate)
def fc_decomposition(self):
VBMF_model = torch.load('checkpoint/VBMF_alexnet_model')
_, tmp_VBMF_layer_runtime = self.get_model_predict_runtime(VBMF_model)
#remain_budget = 0.0
N_classifier = len(self.model.classifier._modules.keys())
for i, key in enumerate(self.model.classifier._modules.keys()):
if i >= N_classifier - 2:
break
if isinstance(self.model.classifier._modules[key],
torch.nn.modules.linear.Linear):
fc_layer_to_decompose = self.model.classifier._modules[key]
#print('Travis fc_layer_to_decompose rank1:{}, rank2:{}'.format(fc_layer_to_decompose.in_features, fc_layer_to_decompose.out_features))
print('\n{}Layer Info{}'.format('\033[31m', '\033[0m'))
print('{}-----------------------------------------{}'.format(
'\033[94m', '\033[0m'))
print('Rank1:{}, Rank2:{}'.format(
fc_layer_to_decompose.in_features,
fc_layer_to_decompose.out_features))
print(self.estimate(fc_layer_to_decompose, key))
self.decomposed_layer_info['key'] = key
self.fc_target_rate = 0.5
rank, b_iter = self.fc_bayesian(
fc_layer_to_decompose.in_features *
fc_layer_to_decompose.out_features //
(fc_layer_to_decompose.in_features +
fc_layer_to_decompose.out_features))
self.bayesian_iter['fc_' + key] = b_iter
#rank = self.fc_bayesian(fc_layer_to_decompose.in_features*fc_layer_to_decompose.out_features//(fc_layer_to_decompose.in_features+fc_layer_to_decompose.out_features))
tmp_ms_1 = self.estimate_with_config(
[fc_layer_to_decompose.in_features, rank[0]])
tmp_ms_2 = self.estimate_with_config(
[rank[0], fc_layer_to_decompose.out_features])
tmp_runtime_ms = tmp_ms_1 + tmp_ms_2
#assert (tmp_runtime_ms - self.VBMF_layer_runtime['fc_'+key]) > 0
decompose = tucker_decomposition_fc_layer_without_rank(
self.model.classifier._modules[key], rank)
self.model.classifier._modules[key] = decompose
fine_tune(self.model, 10)
fine_tune_test(self.model, self.testloader, True)
def fc_decomposition(self):
VBMF_model = torch.load('checkpoint/VBMF_alexnet_model')
_, tmp_VBMF_layer_runtime = self.get_model_predict_runtime(VBMF_model)
#remain_budget = 0.0
N_classifier = len(self.model.classifier._modules.keys())
for i, key in enumerate(self.model.classifier._modules.keys()):
if i >= N_classifier - 2:
break
if isinstance(self.model.classifier._modules[key], torch.nn.modules.linear.Linear):
fc_layer_to_decompose = self.model.classifier._modules[key]
#print('Travis fc_layer_to_decompose rank1:{}, rank2:{}'.format(fc_layer_to_decompose.in_features, fc_layer_to_decompose.out_features))
print('\n{}Layer Info{}'.format('\033[31m', '\033[0m'))
print('{}-----------------------------------------{}'.format('\033[94m', '\033[0m'))
print('Rank1:{}, Rank2:{}'.format(fc_layer_to_decompose.in_features, fc_layer_to_decompose.out_features))
print(self.estimate(fc_layer_to_decompose, key))
self.decomposed_layer_info['key'] = key
if(self.constrain == 0):
sels.fc_target_rate = 0.5
else:
self.fc_target_rate = 0
beta = 0.5
last_search_time = 1000000
iteration_count = 0
while(True):
'''
# prevent TVM from disconnecting
save_model_name = export_onnx_model(self.model)
_ = deploy_by_rpc(save_model_name)
os.remove(save_model_name)
'''
print('{}Iteration{}'.format('\033[31m', '\033[0m'))
print('{}-----------------------------------------{}'.format('\033[94m', '\033[0m'))
print('Iteration {}{}{} Target_Rate: {}{}{}'.format('\033[32m', iteration_count, '\033[0m', '\033[32m', self.fc_target_rate, '\033[0m'))
iteration_count += 1
if(self.search_runtime['fc_'+key] == tmp_VBMF_layer_runtime['fc_'+key]):
rank = [self.VBMF_layer_rank['fc_'+key][0]]
b_iter = 0
else:
rank, b_iter = self.fc_bayesian(fc_layer_to_decompose.in_features*fc_layer_to_decompose.out_features//(fc_layer_to_decompose.in_features+fc_layer_to_decompose.out_features))
'''
if(key == '4'):
if(iteration_count == 1):
rank = 1500
else:
rank = 1500 * (0.9**(iteration_count-1))
rank = [int(rank)]
b_iter = 0
else:
rank, b_iter = self.fc_bayesian(fc_layer_to_decompose.in_features*fc_layer_to_decompose.out_features//(fc_layer_to_decompose.in_features+fc_layer_to_decompose.out_features))
'''
self.bayesian_iter['fc_'+key] = b_iter
#rank = self.fc_bayesian(fc_layer_to_decompose.in_features*fc_layer_to_decompose.out_features//(fc_layer_to_decompose.in_features+fc_layer_to_decompose.out_features))
tmp_ms_1 = self.estimate_with_config([fc_layer_to_decompose.in_features, rank[0]])
tmp_ms_2 = self.estimate_with_config([rank[0], fc_layer_to_decompose.out_features])
tmp_runtime_ms = tmp_ms_1 + tmp_ms_2
#assert (tmp_runtime_ms - self.VBMF_layer_runtime['fc_'+key]) > 0
if(self.constrain == 0):
break
else:
if((tmp_runtime_ms) <= (self.search_runtime['fc_'+ key] + self.remain_budget)):
print('Travis Constrain: {}, Search_runtime: {}, Layer_budget: {}, Remain_budget: {}'.format(self.constrain, \
tmp_runtime_ms, \
self.search_runtime['fc_'+key], self.remain_budget))
print('Travis Layer_budget + Remain_budget: {}'.format(self.search_runtime['fc_'+key]+self.remain_budget))
self.remain_budget = (self.search_runtime['fc_'+key] + self.remain_budget) - (tmp_runtime_ms)
assert self.remain_budget >= 0
print('Updated Remain budget: {}'.format(self.remain_budget))
break
else:
print('Update the objective function ...')
if(last_search_time < tmp_runtime_ms):
beta += 0.25
else:
last_search_time = tmp_runtime_ms
if(iteration_count >= 10):
beta += 0.25
self.fc_target_rate += beta
print('Travis Constrain: {}, Search_runtime: {}, Layer_budget: {}, Remain_budget: {}'.format(self.constrain, \
tmp_runtime_ms, \
self.search_runtime['fc_'+key], self.remain_budget))
print('Travis Layer_budget + Remain_budget: {}'.format(self.search_runtime['fc_'+key]+self.remain_budget))
decompose = tucker_decomposition_fc_layer_without_rank(self.model.classifier._modules[key],rank)
self.model.classifier._modules[key] = decompose
fine_tune(self.model, 10)
fine_tune_test(self.model, self.testloader, True)
def fc_decomposition(self):
#remain_budget = 0.0
N_classifier = len(self.model.classifier._modules.keys())
for i, key in enumerate(self.model.classifier._modules.keys()):
if i >= N_classifier - 2:
break
if isinstance(self.model.classifier._modules[key],
torch.nn.modules.linear.Linear):
fc_layer_to_decompose = self.model.classifier._modules[key]
#print('Travis fc_layer_to_decompose rank1:{}, rank2:{}'.format(fc_layer_to_decompose.in_features, fc_layer_to_decompose.out_features))
print('\n{}Layer Info{}'.format('\033[31m', '\033[0m'))
print('{}-----------------------------------------{}'.format(
'\033[94m', '\033[0m'))
print('Rank1:{}, Rank2:{}'.format(
fc_layer_to_decompose.in_features,
fc_layer_to_decompose.out_features))
print(self.estimate(fc_layer_to_decompose, key))
self.decomposed_layer_info['key'] = key
self.fc_target_rate = 0.5
iteration_count = 0
while (True):
print('{}Iteration{}'.format('\033[31m', '\033[0m'))
print(
'{}-----------------------------------------{}'.format(
'\033[94m', '\033[0m'))
print('Iteration {}{}{} Target_Rate: {}{}{}'.format(
'\033[32m', iteration_count, '\033[0m', '\033[32m',
self.fc_target_rate, '\033[0m'))
iteration_count += 1
rank = self.fc_bayesian(
fc_layer_to_decompose.in_features *
fc_layer_to_decompose.out_features //
(fc_layer_to_decompose.in_features +
fc_layer_to_decompose.out_features))
tmp_ms_1 = self.estimate_with_config(
[fc_layer_to_decompose.in_features, rank[0]])
tmp_ms_2 = self.estimate_with_config(
[rank[0], fc_layer_to_decompose.out_features])
tmp_runtime_ms = tmp_ms_1 + tmp_ms_2
assert (tmp_runtime_ms -
self.VBMF_layer_runtime['fc_' + key]) > 0
if (self.constrain == 0
or (tmp_runtime_ms -
self.VBMF_layer_runtime['fc_' + key]) <=
(self.layer_budget['fc_' + key] + self.remain_budget)):
print('Travis Constrain: {}, Search_runtime: {}, Layer_budget: {}, Search_layer_runtime: {}, VBMF_layer_runtime: {}, Remain_budget: {}'.format(self.constrain, \
tmp_runtime_ms-self.VBMF_layer_runtime['fc_'+key], \
self.layer_budget['fc_'+key], tmp_runtime_ms, self.VBMF_layer_runtime['fc_'+key], self.remain_budget))
print('Travis Layer_budget + Remain_budget: {}'.format(
self.layer_budget['fc_' + key] +
self.remain_budget))
self.remain_budget = (
self.layer_budget['fc_' + key] + self.remain_budget
) - (tmp_runtime_ms -
self.VBMF_layer_runtime['fc_' + key])
assert self.remain_budget >= 0
print('Updated Remain budget: {}'.format(
self.remain_budget))
break
else:
print('Update the objective function ...')
self.fc_target_rate += 0.1
print('Travis Constrain: {}, Search_runtime: {}, Layer_budget: {}, Search_layer_runtime: {}, VBMF_layer_runtime: {}, Remain_budget: {}'.format(self.constrain, \
tmp_runtime_ms-self.VBMF_layer_runtime['fc_'+key], \
self.layer_budget['fc_'+key], tmp_runtime_ms, self.VBMF_layer_runtime['fc_'+key], self.remain_budget))
print('Travis Layer_budget + Remain_budget: {}'.format(
self.layer_budget['fc_' + key] +
self.remain_budget))
decompose = tucker_decomposition_fc_layer_without_rank(
self.model.classifier._modules[key], rank)
self.model.classifier._modules[key] = decompose
fine_tune(self.model, 10)
fine_tune_test(self.model, self.testloader, True)