Function ann_demo

examples/machine_learning/neural_network.cpp:180–256

}

int ann_demo(bool console, int perc, const dtype dt) {
    printf("** ArrayFire ANN Demo **\n\n");

    array train_images, test_images;
    array train_target, test_target;
    int num_classes, num_train, num_test;

    // Load mnist data
    float frac = (float)(perc) / 100.0;
    setup_mnist<true>(&num_classes, &num_train, &num_test, train_images,
                      test_images, train_target, test_target, frac);
    if (dt != f32) {
        train_images = train_images.as(dt);
        test_images  = test_images.as(dt);
        train_target = train_target.as(dt);
    }

    int feature_size = train_images.elements() / num_train;

    // Reshape images into feature vectors
    array train_feats = moddims(train_images, feature_size, num_train).T();
    array test_feats  = moddims(test_images, feature_size, num_test).T();

    train_target = train_target.T();
    test_target  = test_target.T();

    // Network parameters
    vector<int> layers;
    layers.push_back(train_feats.dims(1));
    layers.push_back(100);
    layers.push_back(50);
    layers.push_back(num_classes);

    // Create network: architecture, range, datatype
    ann network(layers, 0.05, dt);

    // Train network
    timer::start();
    network.train(train_feats, train_target,
                  2.0,    // learning rate / alpha
                  250,    // max epochs
                  100,    // batch size
                  0.5,    // max error
                  true);  // verbose
    af::sync();
    double train_time = timer::stop();

    // Run the trained network and test accuracy.
    array train_output = network.predict(train_feats);
    array test_output  = network.predict(test_feats);

    // Benchmark prediction
    af::sync();
    timer::start();
    for (int i = 0; i < 100; i++) { network.predict(test_feats); }
    af::sync();
    double test_time = timer::stop() / 100;