def quantize_and_run_any(network, qbits):
print('network:', network)
input_file = './nn_quant_and_run_code/rlbitwidth.tfmodels/caffe2tf/tfmodels/' + network +'/' + network +'.ckpt'
print('==================================================================')
print('Quantization')
print('==================================================================')
""" Quantization """
nbits = 10
path_save = './nn_quant_and_run_code/results/quantized/'+ network +'/'
path_save_q = path_save + network +'_layers_quant_'+ str(nbits) +'-bits_date.pickle'
#layers_sorted = load.get_layers('/backup/amir-tc/rl_quantization/rl_quantization.code/nn_quant_and_run_code/rlbitwidth.tfmodels/caffe2tf/tfmodels/alexnet/alexnet.py')
layers_sorted = load.get_layers('./nn_quant_and_run_code_train/rlbitwidth.tfmodels/caffe2tf/tfmodels/'+ network +'/'+ network +'.py')
#bits_q = [nbits] * len(layers_sorted)
bits_q = qbits
path_params = input_file
quantize_network(path_params, layers_sorted, path_save_q, bits_q)
print('==================================================================')
print('INFERENCE')
print('==================================================================')
""" Run Inference """
#path_save_q = path_save + '_layers_shift_quant_10May.pickle'
#param_path = save_path_params
#param_path = '/home/ahmed/projects/NN_quant/results/quantized/resnet18/resnet18_layers_shift_quant_retrain_A_10May.pickle'
param_path = path_save_q
with tf.Graph().as_default():
acc, netparams = eval_imagenet(network, param_path, shift_back, trainable=False, err_mean=None, err_stddev=None, train_vars=None, cost_factor=0., n_epoch=1)
return acc
def run_inference(network, input_param_path, qbits):
global HOME
print('==================================================================')
print('Quantization')
print('==================================================================')
""" Quantization """
nbits = 10
path_save = HOME+'/nn_quant_and_run_code/results/quantized/'+ network +'/'
# SECOND file: quantized after retraining
path_save_q = path_save + network +'train_1_test_retrained_quantized.pickle'
#layers_sorted = load.get_layers('/backup/amir-tc/rl_quantization/rl_quantization.code/nn_quant_and_run_code/rlbitwidth.tfmodels/caffe2tf/tfmodels/alexnet/alexnet.py')
layers_sorted = load.get_layers(HOME+'/nn_quant_and_run_code_train/rlbitwidth.tfmodels/caffe2tf/tfmodels/'+ network +'/'+ network +'.py')
#bits_q = [nbits] * len(layers_sorted)
bits_q = qbits
path_params = input_param_path
quantize_network(path_params, layers_sorted, path_save_q, bits_q)
print('==================================================================')
print('INFERENCE')
print('==================================================================')
#param_path = input_param_path
param_path = path_save_q
param_q_path = ''
layer_index = 0
layer_name = 0
file_idx = 0
shift_back = {}
with tf.Graph().as_default():
acc, netparams = eval_imagenet(network, param_path, param_q_path, qbits, layer_index, layer_name, file_idx, shift_back, trainable=False, err_mean=None, err_stddev=None, train_vars=None, cost_factor=0., n_epoch=1)
return acc
def run_inference(network, input_param_path, qbits):
print('==================================================================')
print('Quantization')
print('==================================================================')
""" Quantization """
nbits = 10
path_save = '../nn_quant_and_run_code/results/quantized/'+ network +'/'
path_save_q = path_save + network +'_retrained_quantized.pickle'
#layers_sorted = load.get_layers('/backup/amir-tc/rl_quantization/rl_quantization.code/nn_quant_and_run_code/rlbitwidth.tfmodels/caffe2tf/tfmodels/alexnet/alexnet.py')
layers_sorted = load.get_layers('./rlbitwidth.tfmodels/caffe2tf/tfmodels/'+ network +'/'+ network +'.py')
#bits_q = [nbits] * len(layers_sorted)
bits_q = qbits
path_params = input_param_path
quantize_network(path_params, layers_sorted, path_save_q, bits_q)
print('==================================================================')
print('INFERENCE')
print('==================================================================')
#param_path = input_param_path
param_path = path_save_q
with tf.Graph().as_default():
acc, netparams = eval_imagenet(network, param_path, shift_back, trainable=False, err_mean=None, err_stddev=None, train_vars=None, cost_factor=0., n_epoch=1)
return acc
def quantize_and_train(network_name, layer_index, layer_name, qbits, idx, init_params, file_idx):
""" full precision """
#input_file = './rlbitwidth.tfmodels/caffe2tf/tfmodels/' + network_name + '/' + network_name + '.ckpt'
date = '110118'
date = '110618'
date = date + '_' + str(idx)
global HOME
print('==================================================================')
print('Quantization')
print('==================================================================')
""" Quantization """
""" 1) we initialize based on the quantized input pattern (?) """
path_save = HOME+'/nn_quant_and_run_code/results/quantized/' + network_name + '/'
out_path_save_q = path_save + 'quantized_' + network_name + '_layers_'+date+'.pickle'
layers_sorted = load.get_layers(HOME+'/nn_quant_and_run_code_train/rlbitwidth.tfmodels/caffe2tf/tfmodels/' + network_name + '/' + network_name + '.py')
""" always start with the most recent retrained model """
in_path_params = init_params
quantize_network(in_path_params, layers_sorted, out_path_save_q, qbits)
print('==================================================================')
print('TRAINING')
print('==================================================================')
""" Run retraining """
""" use the full precision weights for initialization, or the most recent retrained """
""" this is used to calculate the quantization difference regularizer """
in_param_path = init_params
param_q_path = out_path_save_q
_, std = get_stats(network_name)
# DEBUG:
print('std : ####################')
print(std)
# -------------
with tf.Graph().as_default():
acc, netparams = eval_imagenet(network_name, in_param_path, param_q_path, qbits, std, layer_index, layer_name, file_idx, shift_back, trainable=True, err_mean=None, err_stddev=None, train_vars=None, cost_factor=100., n_epoch=1)
print(acc)
""" path for saving the retrained model """
path_save = HOME+'/nn_quant_and_run_code/results/quantized/' + network_name + '/'
retrained_path = path_save + 'retrained_'+date+'.pickle'
# AHMED: debug
#print('retrained = ', np.amax(netparams['weights']['conv2']))
#print('len set = ', len(set(np.array(netparams['weights']['conv2']))))
# ------------
with open(retrained_path, 'wb') as f:
pickle.dump(netparams, f)
print('==================================================================')
print('Re-TRAINING DONE!')
print('==================================================================')
return acc
def quantize_and_train(qbits):
input_file = './rlbitwidth.tfmodels/caffe2tf/tfmodels/alexnet/alexnet.ckpt'
print('==================================================================')
print('Quantization')
print('==================================================================')
""" Quantization """
""" 1) we initialize based on the quantized input pattern"""
nbits = 16
path_save = '../nn_quant_and_run_code/results/quantized/alexnet/'
path_save_q = path_save + 'train_1_init_alexnet_layers_quant_16Oct.pickle'
#layers_sorted = load.get_layers('/backup/amir-tc/rl_quantization/rl_quantization.code/nn_quant_and_run_code/rlbitwidth.tfmodels/caffe2tf/tfmodels/alexnet/alexnet.py')
layers_sorted = load.get_layers(
'./rlbitwidth.tfmodels/caffe2tf/tfmodels/alexnet/alexnet.py')
#bits_q = [nbits] * len(layers_sorted)
bits_q = qbits
path_params = input_file
quantize_network(path_params, layers_sorted, path_save_q, bits_q)
print('==================================================================')
print('TRAINING')
print('==================================================================')
""" Run Training """
#param_path = path_save_q
# use the full precision weights for initialization
param_path = input_file
path_save = '../nn_quant_and_run_code/results/quantized/alexnet/alexnet'
save_path_params = path_save + 'train_1_layers_quant_retrained_16Oct.pickle'
acc, netparams = eval_imagenet('alexnet',
param_path,
qbits,
shift_back,
trainable=True,
err_mean=None,
err_stddev=None,
train_vars=None,
cost_factor=75.,
n_epoch=1)
print(acc)
# AHMED: debug
#print('retrained = ', np.amax(netparams['weights']['conv2']))
#print('len set = ', len(set(np.array(netparams['weights']['conv2']))))
# ------------
with open(save_path_params, 'wb') as f:
pickle.dump(netparams, f)
print('==================================================================')
print('TRAINING DONE!')
print('==================================================================')
def run_network(net_name, param_path, qbits, istrain, cost_factor, n_epoch):
if param_path:
path = param_path
else:
ckpt_path = CKPT_PATH + net_name + '/' + net_name + '.ckpt'
path = ckpt_path
err_mean = [0.0, 0.0, 0.0, 0.0] #order: input, weights, biases, layers
err_stddev = [0.0, 0.0, 0.0, 0.0]
train_vars = [False, True, False, False]
#istrain = True
if qbits:
""" Quantization """
print('==================================================================')
print('Quantization')
print('==================================================================')
network = 'lenet'
path_save = './quantized_models/'+ network +'/'
path_save_q = path_save + network +'train_1_test_retrained_quantized.pickle'
#layers_sorted = load.get_layers('/backup/amir-tc/rl_quantization/rl_quantization.code/nn_quant_and_run_code/rlbitwidth.tfmodels/caffe2tf/tfmodels/alexnet/alexnet.py')
layers_sorted = load.get_layers('./rlbitwidth.tfmodels/caffe2tf/tfmodels/'+ network +'/'+ network +'.py')
print('lenet #layers = ', len(layers_sorted))
bits_q = qbits
quantize_network(path, layers_sorted, path_save_q, bits_q)
path = path_save_q
print('==================================================================')
print('INFERENCE')
print('==================================================================')
param_path = path_save_q
if net_name == 'lenet':
return eval_lenet(net_name=net_name, param_path=param_path, qbits=[], layer_index=0, trainable=False, n_epoch=n_epoch)
else:
return eval_imagenet(net_name, ckpt_path, trainable=istrain, err_mean=err_mean, err_stddev=err_stddev, train_vars=train_vars, cost_factor=cost_factor, n_epoch=n_epoch)
def shift_layers(layers, shift, path_ckpt, path_save):
netparams = get_netparams(path_ckpt)
weights, biases = netparams['weights'], netparams['biases']
mean, variance, scale, offset = netparams['mean'], netparams[
'variance'], netparams['scale'], netparams['offset']
weights_normalized = netparams['weights']
#print(weights_normalized[layers[0]])
for layer in layers:
# saturate
#weights_normalized[layer][weights_normalized[layer] > 1/2**(shift[layer]+1)] = 1/2**(shift[layer]+1) - 1/2**32
#weights_normalized[layer][weights_normalized[layer] < -1/2**(shift[layer]+1)] = -(1/2**(shift[layer]+1) - 1/2**32)
weights_normalized[layer][
weights_normalized[layer] > 1 /
2**(shift[layer])] = 1 / 2**(shift[layer] + 1) - 1 / 2**32
weights_normalized[layer][
weights_normalized[layer] < -1 /
2**(shift[layer])] = -(1 / 2**(shift[layer] + 1) - 1 / 2**32)
# shift left
bin_shift = 2**(shift[layer])
print(bin_shift)
weights_normalized[layer] = np.multiply(weights_normalized[layer],
bin_shift)
print(layer)
print(max(weights_normalized[layer].ravel()))
print('------------')
with open(path_save + '_layers_shift_10May.pickle', 'w') as f:
pickle.dump(
[weights_normalized, biases, mean, variance, scale, offset], f)
# under_quantize
path_params = path_save + '_layers_shift_10May.pickle' # normalized layer (shifted)
#path_save_q = path_save + '_layers_shift_quant_res2a_branch2b-2sh-3bits_14May.pickle'
# (2)/3
path_save_q = path_save + 'resnet18_layers_shift_quant_res5a_branch1_1sh-4bits_14May.pickle'
#path_save = '/home/ahmed/projects/NN_quant/results/quantized/resnet18/resnet18_layers_shift_and_quant.pickle'
layers_sorted = get_layers(
'/home/ahmed/projects/NN_quant/rlbitwidth.tfmodels/caffe2tf/tfmodels/resnet18/resnet18.py'
)
bits_q = [10] * len(layers_sorted)
for layer in layers:
#bits_q[layers_sorted.index('res2a_branch1')] = 9
#bits_q[layers_sorted.index('res2a_branch2a')] = 8
bits_q[layers_sorted.index(layer)] = 10 - shift[layer]
# (3)/3
quantize_layers = [
'res2a_branch1', 'res2a_branch2a', 'res2a_branch2b', 'res2b_branch2a',
'res2b_branch2b', 'res3a_branch1'
]
for layer in quantize_layers:
bits_q[layers_sorted.index(layer)] = 5 - shift[layer]
#bits_q[layers_sorted.index('res3a_branch2a')] = 8
bits_q[layers_sorted.index('res3a_branch2b')] = 5
bits_q[layers_sorted.index('res3b_branch2a')] = 4
bits_q[layers_sorted.index('res3b_branch2b')] = 3
bits_q[layers_sorted.index('res4a_branch1')] = 3
bits_q[layers_sorted.index('res4a_branch2a')] = 6
#bits_q[layers_sorted.index('res4a_branch2b')] = 8
bits_q[layers_sorted.index('res4b_branch2a')] = 6
bits_q[layers_sorted.index('res4b_branch2b')] = 4
bits_q[layers_sorted.index('res5a_branch1')] = 4
'''
bits_q[layers_sorted.index('res3b_branch2b')] = 5
bits_q[layers_sorted.index('res4a_branch1')] = 5
bits_q[layers_sorted.index('res4a_branch2a')] = 5
bits_q[layers_sorted.index('res4a_branch2b')] = 5
bits_q[layers_sorted.index('res4b_branch2a')] = 5
bits_q[layers_sorted.index('res4b_branch2b')] = 5
bits_q[layers_sorted.index('res5a_branch1')] = 5
bits_q[layers_sorted.index('res5a_branch2a')] = 5
bits_q[layers_sorted.index('res5a_branch2b')] = 5
bits_q[layers_sorted.index('res5b_branch2a')] = 5
bits_q[layers_sorted.index('res5b_branch2b')] = 5
'''
print(bits_q)
quantize_network(path_params, layers_sorted, path_save_q, bits_q)
