Hey all,
I got following error:
RuntimeError: expected stride to be a single integer value or a list of 3 values to match the convolution dimensions, but got stride=[1, 1]
all I’ve found is to use unqueeze, but I already did. I’m just wondering because I my training setup everything works fine.
Train:
# Write a function that determines a threshold for input/output neurons to be set to zero
# (the ones which have been reduced in absolute value using the sparsity constraint).
# You can use the function topk (similar to nth_element in C++),
# which outputs both the values and indices sorted around a chosen quantile/percentile.
# Here we simply use the median to set 50% of values to zero.
# When applied correctly (as incoming & outgoing mask) for each Conv2d layer,
# it reduces the nonzero parameters by ~75% (the first incoming & last outgoing Conv2d are not masked).
# Note that BatchNorm has four tensors and two index masks have to be applied as follows:
# B = A[idx_next,:,:,:][:,idx_prev,:,:]
# Now you can replace all Conv2d and BatchNorm2d layers with smaller filters
# (and copy their weights) so that we have the following sequence of channels:
# 3, 32, 64, (2x)128, (3x)256, 512
def flop50k(net_trained,percentOut):
percentIn=1-percentOut
for feature_idx in range(29):
if isinstance(net_trained.features[feature_idx],(nn.BatchNorm2d)):
if feature_idx != 26:
sizeIn = int(net_trained.features[feature_idx].bias.size(0)*percentIn)
#layerBias = net_trained.features[feature_idx].bias
layerWeight = net_trained.features[feature_idx].weight
#bias_flopk = torch.topk(layerBias,sizeIn, largest=True)[1]
weight_flopk = torch.topk(layerWeight,sizeIn, largest=True)[1].sort()[0]
#net_trained.features[feature_idx].weight[weight_flopk] = 0
#net_trained.features[feature_idx].bias[bias_flopk] = 0
#net_trained.features[feature_idx-1].weight[bias_flopk,:,:,:] = 0
#net_trained.features[feature_idx-1].bias[bias_flopk,:,:,:] = 0
#save params of BatchNorm where the weights are above the treshold
#totalparams = net_trained.features[feature_idx].total_params
weightBatch = net_trained.features[feature_idx].weight[weight_flopk]
biasBatch = net_trained.features[feature_idx].bias[weight_flopk]
runnngmeanBatch = net_trained.features[feature_idx].running_mean[weight_flopk]
runningvarBatch = net_trained.features[feature_idx].running_var[weight_flopk]
#creating slimmer BatchNorm
net_trained.features[feature_idx] = nn.BatchNorm2d(int(sizeIn),
eps=1e-05, momentum=0.1,
affine=True,
track_running_stats=True)
net_trained.features[feature_idx].weight.data = weightBatch
net_trained.features[feature_idx].bias.data = biasBatch
net_trained.features[feature_idx].running_mean.data = runnngmeanBatch
net_trained.features[feature_idx].running_var.data = runningvarBatch
#adapt the joint Cov2d
weightConv = net_trained.features[feature_idx-1].weight
biasConv = net_trained.features[feature_idx-1].bias
# size(0) outchannel size(1) inchannel
sizeConv = weightConv.size()
#create new Conv layer
#don't reduce the first input channel size
if feature_idx == 1:
net_trained.features[feature_idx-1] = nn.Conv2d(sizeConv[1],
int(sizeConv[0]*percentIn),
kernel_size=3,
stride=1,
padding=1)
net_trained.features[feature_idx-1].weight.data = weightConv[weight_flopk,:,:,:]
net_trained.features[feature_idx-1].bias.data = biasConv[weight_flopk]
elif feature_idx == 26:
#Batch und conv auf 512
net_trained.features[feature_idx-1] = nn.Conv2d(int(sizeConv[1]*percentIn),
512,
kernel_size=3,
stride=1,
padding=1)
net_trained.features[feature_idx-1].weight.data = weightConv[:,weight_flopk_prev.view(1,-1),:,:]
net_trained.features[feature_idx-1].bias.data = biasConv[weight_flopk]
else:
net_trained.features[feature_idx-1] = nn.Conv2d(int(sizeConv[1]*percentIn),
int(sizeConv[0]*percentIn),
kernel_size=3,
stride=1,
padding=1)
net_trained.features[feature_idx-1].weight.data = weightConv[weight_flopk.view(-1,1),weight_flopk_prev.view(1,-1),:,:]
net_trained.features[feature_idx-1].bias.data = biasConv[weight_flopk]
#save the index for the inchannels of the next layer
weight_flopk_prev = weight_flopk
return net_trained
#net2.eval()
net3=copy.deepcopy(net2)
with torch.no_grad():
# SAVE THE TRAINED MODEL
net4 = flop50k(net3,0.5)
print(net3)
print(net4)
torch.save(net4.cpu(),'mdl_4_net4.pth')
Test:
# Evaluate the slimmed network (you could observe a slight improvement to ~92%)
# and confirm that the required computations are reduced to 12 GFlops
with torch.no_grad():
net4 = torch.load('mdl_4_net4.pth')
net4.eval()
test_num = img_test.size(0)
test_acc = 0.0
# LOOP over the testdata set
for i in range(test_num):
test_img = img_test[i,:,:,:].unsqueeze(0)
print(test_img.size())
test_label =label_test[0,i].cuda()
print(test_label.size())
output = net4(test_img).cuda()
accuracy = torch.mean((output.argmax(1)==test_label).float()).cuda()
test_acc += accuracy
test_acc /= test_num
print('Test accuracy:', test_acc)
