Exemplo n.º 1
0
def test_overridable_args(model, optimizer, train_with_fp_copy):
    model_copy = deepcopy(model)
    conv_override = OrderedDict([(acts_key, 8), (wts_key, 8), (bias_key, 32), ('prop', 123), ('unexpetcted_prop', 456)])
    overrides = OrderedDict([('conv1', conv_override)])
    q = DummyQuantizer(model_copy, optimizer=optimizer, overrides=overrides, train_with_fp_copy=train_with_fp_copy)
    pytest_raises_wrapper(TypeError, 'Expecting TypeError when overrides contains unexpected args', q.prepare_model)

    model_copy = deepcopy(model)
    relu_override = OrderedDict([(acts_key, 8), (wts_key, None), (bias_key, None),
                                 ('overridable_prop', 123), ('unexpetcted_prop', 456)])
    overrides = OrderedDict([('relu1', relu_override)])
    q = DummyQuantizer(model_copy, optimizer=optimizer, overrides=overrides, train_with_fp_copy=train_with_fp_copy)
    pytest_raises_wrapper(TypeError, 'Expecting TypeError when overrides contains unexpected args', q.prepare_model)

    model_copy = deepcopy(model)
    conv_override = OrderedDict([(acts_key, 8), (wts_key, 8), (bias_key, 32), ('prop', 123)])
    overrides = OrderedDict([('conv1', conv_override)])
    q = DummyQuantizer(model_copy, optimizer=optimizer, overrides=overrides, train_with_fp_copy=train_with_fp_copy)
    q.prepare_model()
    assert model_copy.conv1.prop == 123

    model_copy = deepcopy(model)
    relu_override = OrderedDict([(acts_key, 8), (wts_key, None), (bias_key, None),
                                ('overridable_prop', 123)])
    overrides = OrderedDict([('relu1', relu_override)])
    q = DummyQuantizer(model_copy, optimizer=optimizer, overrides=overrides, train_with_fp_copy=train_with_fp_copy)
    q.prepare_model()
    assert model_copy.relu1.overridable_prop == 123
Exemplo n.º 2
0
def test_overrides_ordered_dict(model):
    pytest_raises_wrapper(
        TypeError,
        'Expecting TypeError when overrides is not an OrderedDict',
        DummyQuantizer,
        model,
        overrides={'testing': {
            'testing': '123'
        }})
Exemplo n.º 3
0
def test_get_tensor_mean_n_stds_min_max():
    pytest_raises_wrapper(ValueError,
                          'Expecting ValueError with n_stds = 0',
                          qu.get_tensor_mean_n_stds_min_max,
                          test_tensor,
                          n_stds=0)

    mean = torch.tensor(-16.)
    std = torch.tensor(62.87447738647461)

    t_min, t_max = qu.get_tensor_mean_n_stds_min_max(test_tensor)
    torch.testing.assert_allclose(t_min, mean - std)
    torch.testing.assert_allclose(t_max, mean + std)

    t_min, t_max = qu.get_tensor_mean_n_stds_min_max(test_tensor, n_stds=2)
    torch.testing.assert_allclose(t_min, torch.tensor(-95.))
    torch.testing.assert_allclose(t_max, torch.tensor(87.))
Exemplo n.º 4
0
def test_get_tensor_avg_max_abs():
    pytest_raises_wrapper(ValueError,
                          too_large_dim_msg,
                          qu.get_tensor_avg_max_abs,
                          test_tensor_2d,
                          across_dim=2)
    pytest_raises_wrapper(ValueError,
                          too_large_dim_msg,
                          qu.get_tensor_avg_max_abs,
                          test_tensor_2d,
                          across_dim=6)

    t_abs = qu.get_tensor_avg_max_abs(test_tensor_2d)
    assert torch.equal(t_abs, torch.tensor(95.))

    t_abs = qu.get_tensor_avg_max_abs(test_tensor_2d, across_dim=0)
    assert torch.equal(t_abs, torch.tensor(83.))

    t_abs = qu.get_tensor_avg_max_abs(test_tensor_4d, across_dim=0)
    assert torch.equal(t_abs, torch.tensor(94.5))
Exemplo n.º 5
0
def test_get_tensor_max_abs():
    pytest_raises_wrapper(ValueError,
                          too_large_dim_msg,
                          qu.get_tensor_max_abs,
                          test_tensor_2d,
                          per_dim=2)
    pytest_raises_wrapper(ValueError,
                          too_large_dim_msg,
                          qu.get_tensor_max_abs,
                          test_tensor_2d,
                          per_dim=6)

    t_abs = qu.get_tensor_max_abs(test_tensor_4d)
    assert torch.equal(t_abs, torch.tensor(95.))

    t_abs = qu.get_tensor_max_abs(test_tensor_4d, per_dim=0)
    assert torch.equal(t_abs, torch.tensor([94., 95.]))

    t_abs = qu.get_tensor_max_abs(test_tensor_2d, per_dim=0)
    assert torch.equal(t_abs, torch.tensor([93., 94., 87., 86., 83., 95.]))
Exemplo n.º 6
0
def test_get_tensor_avg_min_max():
    pytest_raises_wrapper(ValueError,
                          too_large_dim_msg,
                          qu.get_tensor_avg_min_max,
                          test_tensor_2d,
                          across_dim=2)
    pytest_raises_wrapper(ValueError,
                          too_large_dim_msg,
                          qu.get_tensor_avg_min_max,
                          test_tensor_2d,
                          across_dim=6)

    t_min, t_max = qu.get_tensor_avg_min_max(test_tensor_2d)
    assert torch.equal(t_min, torch.tensor(-95.))
    assert torch.equal(t_max, torch.tensor(87.))

    t_min, t_max = qu.get_tensor_avg_min_max(test_tensor_2d, across_dim=0)
    assert torch.equal(t_min, torch.tensor(-83.))
    assert torch.equal(t_max, torch.tensor(72.))

    t_min, t_max = qu.get_tensor_avg_min_max(test_tensor_4d, across_dim=0)
    assert torch.equal(t_min, torch.tensor(-94.5))
    assert torch.equal(t_max, torch.tensor(85.))
Exemplo n.º 7
0
def test_get_tensor_min_max():
    pytest_raises_wrapper(ValueError,
                          too_large_dim_msg,
                          qu.get_tensor_min_max,
                          test_tensor_2d,
                          per_dim=2)
    pytest_raises_wrapper(ValueError,
                          too_large_dim_msg,
                          qu.get_tensor_min_max,
                          test_tensor_2d,
                          per_dim=6)

    t_min, t_max = qu.get_tensor_min_max(test_tensor_4d)
    assert torch.equal(t_min, torch.tensor(-95.))
    assert torch.equal(t_max, torch.tensor(87.))

    t_min, t_max = qu.get_tensor_min_max(test_tensor_4d, per_dim=0)
    assert torch.equal(t_min, torch.tensor([-94., -95.]))
    assert torch.equal(t_max, torch.tensor([87., 83.]))

    t_min, t_max = qu.get_tensor_min_max(test_tensor_2d, per_dim=0)
    assert torch.equal(t_min,
                       torch.tensor([-93., -94., -56., -86., -74., -95.]))
    assert torch.equal(t_max, torch.tensor([33., 79., 87., 81., 83., 69.]))