Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://www.arrayfire.org/docs/machine_learning_2neural_network_8cpp-example.htm below:

ArrayFire: machine_learning/neural_network.cpp

#include <math.h>

#include <stdio.h>

#include <string>

#include <vector>

#include "mnist_common.h"

using std::vector;

std::string toStr(

dt) {

switch (dt) {

:

;

:

;

default: return "N/A";

}

}

accuracy(

&predicted,

&target) {

val, plabels, tlabels;

max(val, tlabels, target, 1);

max(val, plabels, predicted, 1);

100 * count<float>(plabels == tlabels) / tlabels.

();

}

deriv(

&out) {

out * (1 - out); }

error(

&out,

&pred) {

dif = (out - pred);

((

)(sum<float>(dif * dif)));

}

class ann {

private:

int num_layers;

vector<array> weights;

vector<array> forward_propagate(

&input);

back_propagate(

vector<array> signal,

&pred,

const double &alpha);

public:

ann(vector<int> layers,

range,

dt =

);

train(

&input,

&target,

alpha = 1.0,

int max_epochs = 300, int batch_size = 100,

double maxerr = 1.0, bool verbose = false);

};

}

vector<array> ann::forward_propagate(

&input) {

vector<array> signal(num_layers);

signal[0] = input;

for (int i = 0; i < num_layers - 1; i++) {

in = add_bias(signal[i]);

}

return signal;

}

ann::back_propagate(

vector<array> signal,

&target,

const double &alpha) {

out = signal[num_layers - 1];

err = (out - target);

m = target.

(0);

for (int i = num_layers - 2; i >= 0; i--) {

in = add_bias(signal[i]);

delta = (deriv(out) * err).T();

out = signal[i];

err = err(span,

(1, out.

(1)));

}

}

ann::ann(vector<int> layers,

range,

dt)

: num_layers(layers.size()), weights(layers.size() - 1), datatype(dt) {

std::cout

<< "Initializing weights using a random uniformly distribution between "

<< -

/ 2 <<

<<

/ 2 <<

<< toStr(datatype) << std::endl;

for (int i = 0; i < num_layers - 1; i++) {

(datatype !=

) weights[i] = weights[i].

(datatype);

}

}

vector<array> signal = forward_propagate(input);

out = signal[num_layers - 1];

return out;

}

ann::train(

&input,

&target,

alpha,

int max_epochs, int batch_size, double maxerr, bool verbose) {

num_samples = input.

(0);

const int num_batches = num_samples / batch_size;

double err = 0;

for (int i = 0; i < max_epochs; i++) {

for (int j = 0; j < num_batches - 1; j++) {

int st = j * batch_size;

int en = st + batch_size - 1;

vector<array> signals = forward_propagate(x);

out = signals[num_layers - 1];

back_propagate(signals, y, alpha);

}

int st = (num_batches - 1) * batch_size;

int en = num_samples - 1;

out = predict(input(

(st, en), span));

err = error(out, target(

(st, en), span));

if (err < maxerr) {

printf("Converged on Epoch: %4d\n", i + 1);

return err;

}

if (verbose) {

if ((i + 1) % 10 == 0)

printf("Epoch: %4d, Error: %0.4f\n", i + 1, err);

}

}

return err;

}

ann_demo(

console,

perc,

dt) {

printf("** ArrayFire ANN Demo **\n\n");

train_images, test_images;

train_target, test_target;

int num_classes, num_train, num_test;

float frac = (float)(perc) / 100.0;

setup_mnist<true>(&num_classes, &num_train, &num_test, train_images,

test_images, train_target, test_target, frac);

train_images = train_images.

(dt);

test_images = test_images.

(dt);

train_target = train_target.

(dt);

}

feature_size = train_images.

() / num_train;

train_feats =

(train_images, feature_size, num_train).

();

test_feats =

(test_images, feature_size, num_test).

();

train_target = train_target.

();

test_target = test_target.

();

vector<int> layers;

layers.push_back(train_feats.

(1));

layers.push_back(100);

layers.push_back(50);

layers.push_back(num_classes);

ann network(layers, 0.05, dt);

timer::start();

network.train(train_feats, train_target,

2.0,

250,

100,

0.5,

true);

double train_time = timer::stop();

train_output = network.predict(train_feats);

test_output = network.predict(test_feats);

timer::start();

for (int i = 0; i < 100; i++) { network.predict(test_feats); }

double test_time = timer::stop() / 100;

printf("\nTraining set:\n");

printf("Accuracy on training data: %2.2f\n",

accuracy(train_output, train_target));

printf("\nTest set:\n");

printf("Accuracy on testing data: %2.2f\n",

accuracy(test_output, test_target));

printf("\nTraining time: %4.4lf s\n", train_time);

printf("Prediction time: %4.4lf s\n\n", test_time);

if (!console) {

test_output = test_output.

();

display_results<true>(test_images, test_output, test_target.

(), 20);

}

return 0;

}

int main(int argc, char **argv) {

int device = argc > 1 ? atoi(argv[1]) : 0;

bool console = argc > 2 ? argv[2][0] == '-' : false;

int perc = argc > 3 ? atoi(argv[3]) : 60;

if (perc < 0 || perc > 100) {

std::cerr << "Bad perc arg: " << perc << std::endl;

return EXIT_FAILURE;

}

std::string dts = argc > 4 ? argv[4] : "f32";

if (dts == "f16")

else if (dts != "f32") {

std::cerr << "Unsupported datatype " << dts << ". Supported: f32 or f16"

<< std::endl;

return EXIT_FAILURE;

}

std::cerr << "Half not available for device " << device << std::endl;

return EXIT_FAILURE;

}

try {

return ann_demo(console, perc, dt);

return 0;

}

A multi dimensional data container.

dim4 dims() const

Get dimensions of the array.

const array as(dtype type) const

Casts the array into another data type.

array T() const

Get the transposed the array.

dim_t elements() const

Get the total number of elements across all dimensions of the array.

An ArrayFire exception class.

virtual const char * what() const

Returns an error message for the exception in a string format.

seq is used to create sequences for indexing af::array

@ f32

32-bit floating point values

@ f16

16-bit floating point value

AFAPI array sigmoid(const array &in)

C++ Interface to evaluate the logistical sigmoid function.

AFAPI array sqrt(const array &in)

C++ Interface to evaluate the square root.

AFAPI array matmulTT(const array &lhs, const array &rhs)

C++ Interface to multiply two matrices.

AFAPI array matmul(const array &lhs, const array &rhs, const matProp optLhs=AF_MAT_NONE, const matProp optRhs=AF_MAT_NONE)

C++ Interface to multiply two matrices.

AFAPI void grad(array &dx, array &dy, const array &in)

C++ Interface for calculating the gradients.

array constant(T val, const dim4 &dims, const dtype ty=(af_dtype) dtype_traits< T >::ctype)

C++ Interface to generate an array with elements set to a specified value.

AFAPI array range(const dim4 &dims, const int seq_dim=-1, const dtype ty=f32)

C++ Interface to generate an array with [0, n-1] values along the seq_dim dimension and tiled across ...

AFAPI bool isHalfAvailable(const int device)

Queries the current device for half precision floating point support.

AFAPI void setDevice(const int device)

Sets the current device.

AFAPI void sync(const int device=-1)

Blocks until the device is finished processing.

AFAPI array join(const int dim, const array &first, const array &second)

C++ Interface to join 2 arrays along a dimension.

AFAPI array moddims(const array &in, const dim4 &dims)

C++ Interface to modify the dimensions of an input array to a specified shape.

AFAPI array randu(const dim4 &dims, const dtype ty, randomEngine &r)

C++ Interface to create an array of random numbers uniformly distributed.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4