def test_row_pruning():
param = torch.tensor([[1., 2., 3.], [4., 5., 6.], [7., 8., 9.]])
from distiller.pruning import L1RankedStructureParameterPruner
masker = distiller.scheduler.ParameterMasker("why name")
zeros_mask_dict = {"some name": masker}
L1RankedStructureParameterPruner.rank_and_prune_rows(
0.5, param, "some name", zeros_mask_dict)
print(distiller.sparsity_rows(masker.mask))
assert math.isclose(distiller.sparsity_rows(masker.mask), 1 / 3)
pass
def test_sparsity():
zeros = torch.zeros(2, 3, 5, 6)
print(distiller.sparsity(zeros))
assert distiller.sparsity(zeros) == 1.0
assert distiller.sparsity_3D(zeros) == 1.0
assert distiller.density_3D(zeros) == 0.0
ones = torch.ones(12, 43, 4, 6)
assert distiller.sparsity(ones) == 0.0
x = torch.tensor([[1., 2., 0, 4., 0], [1., 2., 0, 4., 0]])
assert distiller.density(x) == 0.6
assert distiller.density_cols(x, transposed=False) == 0.6
assert distiller.sparsity_rows(x, transposed=False) == 0
x = torch.tensor([[0., 0., 0], [1., 4., 0], [1., 2., 0], [0., 0., 0]])
assert distiller.density(x) == 4 / 12
assert distiller.sparsity_rows(x, transposed=False) == 0.5
assert common.almost_equal(distiller.sparsity_cols(x, transposed=False),
1 / 3)
assert common.almost_equal(distiller.sparsity_rows(x), 1 / 3)
def weights_sparsity_summary(model,
return_total_sparsity=False,
param_dims=[2, 4]):
df = pd.DataFrame(columns=[
'Name', 'Shape', 'NNZ (dense)', 'NNZ (sparse)', 'Cols (%)', 'Rows (%)',
'Ch (%)', '2D (%)', '3D (%)', 'Fine (%)', 'Std', 'Mean', 'Abs-Mean'
])
pd.set_option('precision', 2)
params_size = 0
sparse_params_size = 0
summary_param_types = ['weight', 'bias']
for name, param in model.state_dict().items():
# Extract just the actual parameter's name, which in this context we treat as its "type"
curr_param_type = name.split('.')[-1]
if param.dim(
) in param_dims and curr_param_type in summary_param_types:
_density = distiller.density(param)
params_size += torch.numel(param)
sparse_params_size += param.numel() * _density
df.loc[len(df.index)] = ([
name,
distiller.size_to_str(param.size()),
torch.numel(param),
int(_density * param.numel()),
distiller.sparsity_cols(param) * 100,
distiller.sparsity_rows(param) * 100,
distiller.sparsity_ch(param) * 100,
distiller.sparsity_2D(param) * 100,
distiller.sparsity_3D(param) * 100, (1 - _density) * 100,
param.std().item(),
param.mean().item(),
param.abs().mean().item()
])
total_sparsity = (1 - sparse_params_size / params_size) * 100
df.loc[len(df.index)] = ([
'Total sparsity:', '-', params_size,
int(sparse_params_size), 0, 0, 0, 0, 0, total_sparsity, 0, 0, 0
])
if return_total_sparsity:
return df, total_sparsity
return df
def weights_sparsity_summary(model, return_total_sparsity=False, param_dims=[2,4]):
df = pd.DataFrame(columns=['Name', 'Shape', 'NNZ (dense)', 'NNZ (sparse)',
'Cols (%)','Rows (%)', 'Ch (%)', '2D (%)', '3D (%)',
'Fine (%)', 'Std', 'Mean', 'Abs-Mean'])
pd.set_option('precision', 2)
params_size = 0
sparse_params_size = 0
for name, param in model.state_dict().items():
if (param.dim() in param_dims) and any(type in name for type in ['weight', 'bias']):
_density = distiller.density(param)
params_size += torch.numel(param)
sparse_params_size += param.numel() * _density
df.loc[len(df.index)] = ([
name,
distiller.size_to_str(param.size()),
torch.numel(param),
int(_density * param.numel()),
distiller.sparsity_cols(param)*100,
distiller.sparsity_rows(param)*100,
distiller.sparsity_ch(param)*100,
distiller.sparsity_2D(param)*100,
distiller.sparsity_3D(param)*100,
(1-_density)*100,
param.std().item(),
param.mean().item(),
param.abs().mean().item()
])
total_sparsity = (1 - sparse_params_size/params_size)*100
df.loc[len(df.index)] = ([
'Total sparsity:',
'-',
params_size,
int(sparse_params_size),
0, 0, 0, 0, 0,
total_sparsity,
0, 0, 0])
if return_total_sparsity:
return df, total_sparsity
return df
def weights_sparsity_summary(model,
return_total_sparsity=False,
param_dims=[2, 4]):
df = pd.DataFrame(columns=[
"Name",
"Shape",
"NNZ (dense)",
"NNZ (sparse)",
"Cols (%)",
"Rows (%)",
"Ch (%)",
"2D (%)",
"3D (%)",
"Fine (%)",
"Std",
"Mean",
"Abs-Mean",
])
pd.set_option("precision", 2)
params_size = 0
sparse_params_size = 0
for name, param in model.state_dict().items():
# Extract just the actual parameter's name, which in this context we treat as its "type"
if param.dim() in param_dims and any(type in name
for type in ["weight", "bias"]):
_density = distiller.density(param)
params_size += torch.numel(param)
sparse_params_size += param.numel() * _density
df.loc[len(df.index)] = [
name,
distiller.size_to_str(param.size()),
torch.numel(param),
int(_density * param.numel()),
distiller.sparsity_cols(param) * 100,
distiller.sparsity_rows(param) * 100,
distiller.sparsity_ch(param) * 100,
distiller.sparsity_2D(param) * 100,
distiller.sparsity_3D(param) * 100,
(1 - _density) * 100,
param.std().item(),
param.mean().item(),
param.abs().mean().item(),
]
total_sparsity = (1 - sparse_params_size / params_size) * 100
df.loc[len(df.index)] = [
"Total sparsity:",
"-",
params_size,
int(sparse_params_size),
0,
0,
0,
0,
0,
total_sparsity,
0,
0,
0,
]
if return_total_sparsity:
return df, total_sparsity
return df
