def test_inception_v3_imagenet(device_id):
    if cntk_device(device_id).type() != DeviceKind_GPU:
        pytest.skip('test only runs on GPU')
    try_set_default_device(cntk_device(device_id))

    current_path = os.getcwd()
    base_path = prepare_ImageNet_data()
    # change dir to locate data.zip correctly
    os.chdir(base_path)

    from _cntk_py import set_fixed_random_seed, force_deterministic_algorithms
    set_fixed_random_seed(1)
    force_deterministic_algorithms()

    train_data = os.path.join(base_path, 'train_map.txt')
    test_data = os.path.join(base_path, 'val_map.txt')

    try:
        error = inception_v3_train_and_eval(train_data, test_data, minibatch_size=8, epoch_size=200,
                                            max_epochs=4, restore=False, testing_parameters=(200, 8))
    finally:
        os.chdir(current_path)

    expected_error = 0.99
    assert np.allclose(error, expected_error, atol=TOLERANCE_ABSOLUTE)
def test_inception_v3_imagenet(device_id):
    if cntk_device(device_id).type() != DeviceKind_GPU:
        pytest.skip('test only runs on GPU')
    try_set_default_device(cntk_device(device_id))

    current_path = os.getcwd()
    base_path = prepare_ImageNet_data()
    # change dir to locate data.zip correctly
    os.chdir(base_path)

    from _cntk_py import set_fixed_random_seed, force_deterministic_algorithms
    set_fixed_random_seed(1)
    force_deterministic_algorithms()

    train_data = os.path.join(base_path, 'train_map.txt')
    test_data = os.path.join(base_path, 'val_map.txt')

    try:
        error = inception_v3_train_and_eval(train_data,
                                            test_data,
                                            minibatch_size=8,
                                            epoch_size=200,
                                            max_epochs=4,
                                            restore=False,
                                            testing_parameters=(200, 8))
    finally:
        os.chdir(current_path)

    expected_error = 0.99
    assert np.allclose(error, expected_error, atol=TOLERANCE_ABSOLUTE)
def test_alexnet_error(device_id):
    if cntk_device(device_id).type() != DeviceKind_GPU:
        pytest.skip('test only runs on GPU')
    set_default_device(cntk_device(device_id))

    base_path = prepare_ImageNet_data()
    # change dir to locate data.zip correctly
    os.chdir(base_path)

    from _cntk_py import set_computation_network_trace_level, set_fixed_random_seed, force_deterministic_algorithms
    set_computation_network_trace_level(1)
    set_fixed_random_seed(
        1
    )  # BUGBUG: has no effect at present  # TODO: remove debugging facilities once this all works
    #force_deterministic_algorithms()
    # TODO: do the above; they lead to slightly different results, so not doing it for now

    # for test purpose we train and test on same data
    train_data = os.path.join(base_path, 'val1024_map.txt')
    test_data = os.path.join(base_path, 'val1024_map.txt')

    test_error = alexnet_train_and_eval(train_data,
                                        test_data,
                                        num_quantization_bits=32,
                                        minibatch_size=16,
                                        epoch_size=64,
                                        max_epochs=2)
def test_alexnet_imagenet_distributed_block_momentum(device_id):
    params = [
        "-n", "2", "-m", "8", "-e", "16", "-datadir",
        prepare_ImageNet_data(), "-b", "1600", "-r", "-device",
        str(device_id)
    ]
    mpiexec_test(device_id, script_under_test, mpiexec_params, params, 0.99,
                 False)
def test_alexnet_imagenet_distributed_1bitsgd(device_id):
    params = [
        "-n", "2", "-datadir",
        prepare_ImageNet_data(), "-q", "1", "-m", "8", "-e", "16", "-r",
        "-device",
        str(device_id)
    ]
    mpiexec_test(device_id, script_under_test, mpiexec_params, params, 0.99,
                 True)
def test_alexnet_imagenet_distributed(device_id):
    params = [ "-n", "2",
               "-m", "8", 
               "-e", "16",
               "-datadir", prepare_ImageNet_data(),
               "-q", "32",
               "-r", 
               "-device", "0" ]
    mpiexec_test(device_id, script_under_test, params, 0.99, True)
def disabled_test_alexnet_imagenet_distributed_block_momentum(device_id):
    params = [ "-n", "2",
               "-m", "8",
               "-e", "16",
               "-datadir", prepare_ImageNet_data(),
               "-b", "1600",
               "-r",
               "-device", str(device_id) ]
    mpiexec_test(device_id, script_under_test, mpiexec_params, params, 0.99, False)
def test_bn_inception_imagenet_distributed(device_id):
    params = [
        "-n", "4", "-datadir",
        prepare_ImageNet_data(), "-q", "32", "-e", "300", "-m", "2", "-r",
        "-device",
        str(device_id)
    ]
    mpiexec_test(device_id, script_under_test, mpiexec_params, params, 0.99,
                 True)
def test_alexnet_imagenet_distributed(device_id):
    params = [ "-n", "2",
               "-m", "4", 
               "-e", "16",
               "-datadir", prepare_ImageNet_data(),
               "-q", "32",
               "-r", 
               "-device", "0" ]
    mpiexec_test(device_id, script_under_test, params, 0.99, True)
def test_bn_inception_imagenet_distributed(device_id):
    params = [ "-n", "4",
               "-datadir", prepare_ImageNet_data(),
               "-q", "32",
               "-e", "300",
               "-m", "2",
               "-r",
               "-device", str(device_id) ]
    mpiexec_test(device_id, script_under_test, mpiexec_params, params, 0.99, True, timeout_seconds=400)
def test_VGG16_imagenet_distributed(device_id):
    params = [ "-n", "2",
               "-m", "2",
               "-e", "2",
               "-datadir", prepare_ImageNet_data(),
               "-q", "32",
               "-device", str(device_id),
               "-r",
               "-testing"]

    # Currently we only test for CPU since the memory usage is very high for GPU (~6 GB)
    mpiexec_test(device_id, script_under_test, mpiexec_params, params, 0.99, True, timeout_seconds=500, use_only_cpu=True)
def test_inception_v3_imagenet_distributed(device_id):
    # Inception-V3 distributed test on ImageNet need plenty of memory,
    # for now, the test server might feel hard to handle
    pytest.skip('Mute Inception-V3 distributed test temporarily')

    params = ["-n", "2",
              "-datadir", prepare_ImageNet_data(),
              "-q", "32",
              "-e", "200",
              "-m", "2",
              "-r",
              "-device", str(device_id)]

    mpiexec_test(device_id, script_under_test, mpiexec_params, params, 0.99, True, timeout_seconds=400)
Beispiel #13
0
def test_VGG19_imagenet_distributed(device_id):
    params = [
        "-n", "2", "-m", "2", "-e", "2", "-datadir",
        prepare_ImageNet_data(), "-q", "32", "-device",
        str(device_id), "-r", "-testing"
    ]

    # Currently we only test for CPU since the memory usage is very high for GPU (~6 GB)
    mpiexec_test(device_id,
                 script_under_test,
                 mpiexec_params,
                 params,
                 0.99,
                 True,
                 timeout_seconds=500,
                 use_only_cpu=True)
Beispiel #14
0
def test_inception_v3_imagenet_distributed(device_id):
    # Inception-V3 distributed test on ImageNet need plenty of memory,
    # for now, the test server might feel hard to handle
    pytest.skip('Mute Inception-V3 distributed test temporarily')

    params = [
        "-n", "2", "-datadir",
        prepare_ImageNet_data(), "-q", "32", "-e", "200", "-m", "2", "-r",
        "-device",
        str(device_id)
    ]

    mpiexec_test(device_id,
                 script_under_test,
                 mpiexec_params,
                 params,
                 0.99,
                 True,
                 timeout_seconds=400)