void BasicBrain::makeNN() { assert(layout_.numLayers_ >= 3); assert(layout_.numLayers_ < 20); unsigned int* layerArray = new unsigned int[layout_.numLayers_]; layerArray[0] = layout_.numInputs_; for(size_t i = 1; i < (layout_.numLayers_ - 1); i++) { layerArray[i] = layout_.neuronsPerHidden; } layerArray[layout_.numLayers_ - 1] = layout_.numOutputs; nn_ = fann_create_standard_array(layout_.numLayers_, layerArray); fann_set_activation_function_hidden(nn_, FANN_SIGMOID_SYMMETRIC); fann_set_activation_function_output(nn_, FANN_SIGMOID_SYMMETRIC); inputs_ = new fann_type[layout_.numInputs_]; reset(); delete[] layerArray; #ifdef _CHECK_BRAIN_ALLOC size_t id = ++nnAllocCnt_; nnAllocs_[nn_] = id; std::cerr << "alloc: " << id << std::endl; #endif }
FANN_EXTERNAL struct fann *FANN_API fann_create_standard(unsigned int num_layers, ...) { struct fann *ann; va_list layer_sizes; int i; unsigned int *layers = (unsigned int *) fann_calloc(num_layers, sizeof(unsigned int)); if(layers == NULL) { fann_error(NULL, FANN_E_CANT_ALLOCATE_MEM); return NULL; } va_start(layer_sizes, num_layers); for(i = 0; i < (int) num_layers; i++) { layers[i] = va_arg(layer_sizes, unsigned int); } va_end(layer_sizes); ann = fann_create_standard_array(num_layers, layers); fann_free(layers); return ann; }
int main(int argc, char *argv[]) { unsigned int layers[3] = {38, 17, 9}; struct fann *ann = fann_create_standard_array(3, layers); fann_set_activation_function_hidden(ann, FANN_SIGMOID_SYMMETRIC); fann_set_activation_function_output(ann, FANN_LINEAR); fann_train_on_file(ann, "scotland.data", 100000, 100, 0.00001); fann_save(ann, "scotland_test.net"); fann_destroy(ann); return 0; }
/*** * @function rspamd_fann.create(nlayers, [layer1, ... layern]) * Creates new neural network with `nlayers` that contains `layer1`...`layern` * neurons in each layer * @param {number} nlayers number of layers * @param {number} layerI number of neurons in each layer * @return {fann} fann object */ static gint lua_fann_create (lua_State *L) { #ifndef WITH_FANN return 0; #else struct fann *f, **pfann; guint nlayers, *layers, i; nlayers = luaL_checknumber (L, 1); if (nlayers > 0) { layers = g_malloc (nlayers * sizeof (layers[0])); if (lua_type (L, 2) == LUA_TNUMBER) { for (i = 0; i < nlayers; i ++) { layers[i] = luaL_checknumber (L, i + 2); } } else if (lua_type (L, 2) == LUA_TTABLE) { for (i = 0; i < nlayers; i ++) { lua_rawgeti (L, 2, i + 1); layers[i] = luaL_checknumber (L, -1); lua_pop (L, 1); } } f = fann_create_standard_array (nlayers, layers); fann_set_activation_function_hidden (f, FANN_SIGMOID_SYMMETRIC); fann_set_activation_function_output (f, FANN_SIGMOID_SYMMETRIC); fann_set_training_algorithm (f, FANN_TRAIN_INCREMENTAL); fann_randomize_weights (f, 0, 1); if (f != NULL) { pfann = lua_newuserdata (L, sizeof (gpointer)); *pfann = f; rspamd_lua_setclass (L, "rspamd{fann}", -1); } else { lua_pushnil (L); } g_free (layers); } else { lua_pushnil (L); } return 1; #endif }
bool ViFann::setStructure(const Type &type, const QList<int> &neurons, const qreal &connectionRate) { #ifdef GPU if(type != Standard) { LOG("The GPU version of FANN currently doesn't support shortcut, sparse or cascade networks.", QtFatalMsg); exit(-1); } #endif clear(); mType = type; mInputCount = neurons.first(); mOutputCount = neurons.last(); mNeurons.clear(); for(mI = 0; mI < neurons.size(); ++mI) { if(neurons[mI] != 0) mNeurons.append(neurons[mI]); } if(mInput == NULL) delete [] mInput; if(mOutput == NULL) delete [] mOutput; mInput = new float[mInputCount]; mOutput = new float[mOutputCount]; unsigned int layers = mNeurons.size(); unsigned int layerNeurons[layers]; for(mI = 0; mI < layers; ++mI) layerNeurons[mI] = mNeurons[mI]; if(type == Standard) mNetwork = fann_create_standard_array(layers, layerNeurons); #ifndef GPU else if(type == Sparse) { mNetwork = fann_create_sparse_array(connectionRate, layers, layerNeurons); mConnectionRate = connectionRate; } else if(type == Shortcut) mNetwork = fann_create_shortcut_array(layers, layerNeurons); #endif else return false; fann_set_train_stop_function(mNetwork, FANN_STOPFUNC_MSE); if(ENABLE_CALLBACK) { fann_set_callback(mNetwork, &ViFann::trainCallback); mMseTotal.clear(); mMseCount = 0; } return true; }
/*! fann.create_standard(num_layers, neurons_1, neurons_2, ..., neurons_n) *# Creates a neural network with {{num_layers}}.\n *# The i'th layer will have {{neurons_i}} neurons (the function must thus have *# {{num_layers+1}} parameters in total). *x ann = fann.create_standard(3, 2, 3, 1) *- */ static int ann_create_standard(lua_State *L) { struct fann **ann; int num_layers, i; unsigned int *layers; luaL_argcheck(L, lua_isinteger(L,1), 1, "First argument to fann.create_standard() must be an integer"); num_layers = lua_tointeger(L, 1); #ifdef FANN_VERBOSE printf("Creating neural net, %d layers\n", num_layers); #endif if(num_layers < 1) luaL_error(L, "Neural network must have at least one layer"); if(lua_gettop(L) < num_layers + 1) luaL_error(L, "Neural net has %d layers, so fann.open() must have %d parameters", num_layers, num_layers + 1); layers = lua_newuserdata(L, num_layers*(sizeof *layers)); for(i = 0; i < num_layers; i++) { int n = luaL_checkinteger(L, i + 2); if(n < 1) { luaL_error(L, "Layer %d must have at least 1 neuron", i); } #ifdef FANN_VERBOSE printf("Layer %d to have %d neurons\n", i, n); #endif layers[i] = n; } ann = lua_newuserdata(L, sizeof *ann); luaL_getmetatable(L, FANN_METATABLE); lua_setmetatable(L, -2); *ann = fann_create_standard_array(num_layers, layers); if(!*ann) { luaL_error(L, "Unable to create neural network"); } return 1; }
int main() { const float desired_error = (const float) 0.0001; const unsigned int max_epochs = 350; const unsigned int epochs_between_reports = 25; struct fann *ann; struct fann_train_data *train_data; unsigned int i = 0; printf("Creating network.\n"); train_data = fann_read_train_from_file("ann_training_data"); // Using incremental training -> shuffle training data fann_shuffle_train_data(train_data); // ann = fann_create_standard(num_layers, // train_data->num_input, num_neurons_hidden, train_data->num_output); //ann = fann_create_standard(500, 2, 50, 50, 21); unsigned int layers[4] = {150, 70, 30, 22}; ann = fann_create_standard_array(4, layers); printf("Training network.\n"); fann_set_activation_function_hidden(ann, FANN_SIGMOID_SYMMETRIC_STEPWISE); fann_set_activation_function_output(ann, FANN_LINEAR_PIECE); //FANN_SIGMOID_STEPWISE); fann_set_training_algorithm(ann, FANN_TRAIN_INCREMENTAL); fann_train_on_data(ann, train_data, max_epochs, epochs_between_reports, desired_error); printf("Saving network.\n"); fann_save(ann, "mymoves_gestures.net"); printf("Cleaning up.\n"); fann_destroy_train(train_data); fann_destroy(ann); return 0; }
int main() { const float desired_error = (const float) 0.01; const unsigned int max_epochs = 50000; const unsigned int epochs_between_reports = 10; unsigned int layers []= {6, 200, 200, 4}; struct fann * ann = fann_create_standard_array(4, layers); fann_set_activation_function_layer(ann, FANN_SIGMOID_SYMMETRIC, 1); fann_set_activation_function_layer(ann, FANN_SIGMOID_SYMMETRIC, 2); fann_set_activation_function_layer(ann, FANN_SIGMOID_SYMMETRIC, 3); fann_train_on_file(ann, "../training_file", max_epochs, epochs_between_reports, desired_error); fann_save(ann, "wii.net"); fann_destroy(ann); return 0; }
/*** * @function rspamd_fann.create(nlayers, [layer1, ... layern]) * Creates new neural network with `nlayers` that contains `layer1`...`layern` * neurons in each layer * @param {number} nlayers number of layers * @param {number} layerI number of neurons in each layer * @return {fann} fann object */ static gint lua_fann_create (lua_State *L) { #ifndef WITH_FANN return 0; #else struct fann *f, **pfann; guint nlayers, *layers, i; nlayers = luaL_checknumber (L, 1); if (nlayers > 0) { layers = g_malloc (nlayers * sizeof (layers[0])); for (i = 0; i < nlayers; i ++) { layers[i] = luaL_checknumber (L, i + 2); } f = fann_create_standard_array (nlayers, layers); if (f != NULL) { pfann = lua_newuserdata (L, sizeof (gpointer)); *pfann = f; rspamd_lua_setclass (L, "rspamd{fann}", -1); } else { lua_pushnil (L); } } else { lua_pushnil (L); } return 1; #endif }
/* Creates a feedforward, layered net which is an "unrolled" recurrent network. For example, the recurrent net: A <-> B <-> C<- (where C autosynapses) Becomes (unrolled two time steps): A B C input layer \/ \/| A B C hidden layer I \/ \/| A B C output layer */ FANN_EXTERNAL struct fann *FANN_API fann_create_unrolled_recurrent( unsigned int num_neurons, fann_type *weights, unsigned int time_steps) { struct fann *ann = NULL; unsigned int *layers = NULL; unsigned int num_layers = time_steps + 1; unsigned int layern = 0; struct fann_layer *curr_layer = NULL; struct fann_neuron *curr_neuron = NULL; fann_type *curr_weights = weights; /************************************* CREATE THE FEEDFORWARD STRUCTURE *************************************/ /* Allocate number of neurons per layer array */ layers = (unsigned int *)calloc(num_layers, sizeof(unsigned int)); if (layers == NULL) { return NULL; } /* Populate each layer with the number of neurons */ for (layern=0; layern < num_layers; layern++) { layers[layern] = num_neurons; } /* Create the feedforward network */ ann = fann_create_standard_array(num_layers, layers); fann_safe_free(layers); /*printf("REQUESTED: LAYERS=%d, NEURONS/LAYER=%d\n", num_layers, num_neurons); printf("NUM LAYERS: %d\n", ann->last_layer - ann->first_layer); printf("IN: %d, NEURONS: %d, OUTPUT: %d\n", ann->num_input, ann->num_neurons, ann->num_output);*/ /************************************* SET THE FEEDFORWARD WEIGHTS *************************************/ /* Visit each layer */ for (curr_layer = ann->first_layer; curr_layer != ann->last_layer; curr_layer++) { /* The weights are the same for each feedforward layer! */ curr_weights = weights; /* Copy the weight matrix into the neurons, one row per neuron */ for (curr_neuron = curr_layer->first_neuron; curr_neuron != curr_layer->last_neuron; curr_neuron++) { memcpy(curr_neuron->weights, curr_weights, num_neurons * num_neurons * sizeof(fann_type)); curr_weights += num_neurons; } } return ann; }
/* arguments (all required): - data filename - topology, as number of neurons per layer separated by dashes - epochs (integer) - learning rate (0.0-1.0 float) - output filename */ int main(int argc, char **argv) { // Argument 1: data filename. const char *datafn = argv[1]; // Argument 2: topology. unsigned int layer_sizes[MAX_LAYERS]; unsigned int num_layers = 0; char *token = strtok(argv[2], "-"); while (token != NULL) { layer_sizes[num_layers] = atoi(token); ++num_layers; token = strtok(NULL, "-"); } // Argument 3: epoch count. unsigned int max_epochs = atoi(argv[3]); // Argument 4: learning rate. float learning_rate = atof(argv[4]); // Argument 5: output filename. const char *outfn = argv[5]; struct fann *ann; ann = fann_create_standard_array(num_layers, layer_sizes); // Misc parameters. fann_set_training_algorithm(ann, FANN_TRAIN_RPROP); fann_set_activation_steepness_hidden(ann, 0.5); fann_set_activation_steepness_output(ann, 0.5); fann_set_activation_function_hidden(ann, FANN_SIGMOID); fann_set_activation_function_output(ann, FANN_SIGMOID); //fann_set_train_stop_function(ann, FANN_STOPFUNC_BIT); //fann_set_bit_fail_limit(ann, 0.01f); struct fann_train_data *data; data = fann_read_train_from_file(datafn); fann_init_weights(ann, data); fann_set_learning_rate(ann, learning_rate); fann_train_on_data( ann, data, max_epochs, 10, // epochs between reports DESIRED_ERROR ); printf("Testing network. %f\n", fann_test_data(ann, data)); fann_type *calc_out; for(unsigned int i = 0; i < fann_length_train_data(data); ++i) { calc_out = fann_run(ann, data->input[i]); } printf("RMSE = %f\n", sqrt(fann_get_MSE(ann))); fann_save(ann, outfn); fann_destroy_train(data); fann_destroy(ann); return 0; }
int main(int argc, char *argv[]) { struct fann_train_data *dadosTreino, *dadosTeste; struct fann *ANN; fann_type *ANN_Answers; int *layers, i, j, aux; chromosome chromo; float erro = 0.0; checkArgs(argc, argv); buildChromosome(argv, &chromo); checkDatasetFiles(); dadosTreino = fann_read_train_from_file(nomeArqTreino); layers = (int *) calloc(2+chromo.qntCamadasOcultas, sizeof(int)); layers[0] = qntNeuroniosEntrada; layers[2+chromo.qntCamadasOcultas-1] = qntNeuroniosSaida; aux = chromo.neurOcultos; for (i=1; i < 2+chromo.qntCamadasOcultas-1 ; i++) { layers[i] = aux; aux = aux/2; } // CRIANDO A RNA: ANN = fann_create_standard_array(2+chromo.qntCamadasOcultas, layers); // TREINO fann_set_learning_rate(ANN, chromo.learnRate); fann_set_learning_momentum(ANN, chromo.moment); fann_set_activation_function_hidden( ANN, chromo.fcOculta ); fann_set_activation_function_output( ANN, chromo.fcSaida ); fann_set_training_algorithm(ANN, chromo.algAprend ); if (fann_get_training_algorithm(ANN) == FANN_TRAIN_QUICKPROP) fann_set_quickprop_decay(ANN, chromo.decay); // Em python, o treino ficava entre um try. // Se desse erro, escrevia "Resultado: 999.0" e exit fann_train_on_data(ANN, dadosTreino, chromo.epocasTreino, 50, desiredError); fann_destroy_train(dadosTreino); // TESTES: dadosTeste = fann_read_train_from_file( nomeArqValidacao); // Em python, o teste também ficava entre um try. // Se desse erro, escrevia "Resultado: 999.0" e exit for(i = 0; i < fann_length_train_data(dadosTeste); i++) { ANN_Answers = fann_run(ANN, dadosTeste->input[i]); if (ANN_Answers == NULL) { printf("Resultado: 999.0\n"); exit(2); } for (j=0; j < qntNeuroniosSaida; j++) erro += (float) powf(fann_abs(ANN_Answers[j] - dadosTeste->output[i][j]), 2); } printf("Resultado: %f\n", erro/(fann_length_train_data(dadosTeste)-1)); fann_destroy_train(dadosTeste); saveANN(argc, argv, ANN); fann_destroy(ANN); }
/*** * @function rspamd_fann.create_full(params) * Creates new neural network with parameters: * - `layers` {table/numbers}: table of layers in form: {N1, N2, N3 ... Nn} where N is number of neurons in a layer * - `activation_hidden` {string}: activation function type for hidden layers (`tanh` by default) * - `activation_output` {string}: activation function type for output layer (`tanh` by default) * - `sparsed` {float}: create sparsed ANN, where number is a coefficient for sparsing * - `learn` {string}: learning algorithm (quickprop, rprop or incremental) * - `randomize` {boolean}: randomize weights (true by default) * @return {fann} fann object */ static gint lua_fann_create_full (lua_State *L) { #ifndef WITH_FANN return 0; #else struct fann *f, **pfann; guint nlayers, *layers, i; const gchar *activation_hidden = NULL, *activation_output, *learn_alg = NULL; gdouble sparsed = 0.0; gboolean randomize_ann = TRUE; GError *err = NULL; if (lua_type (L, 1) == LUA_TTABLE) { lua_pushstring (L, "layers"); lua_gettable (L, 1); if (lua_type (L, -1) != LUA_TTABLE) { return luaL_error (L, "bad layers attribute"); } nlayers = rspamd_lua_table_size (L, -1); if (nlayers < 2) { return luaL_error (L, "bad layers attribute"); } layers = g_new0 (guint, nlayers); for (i = 0; i < nlayers; i ++) { lua_rawgeti (L, -1, i + 1); layers[i] = luaL_checknumber (L, -1); lua_pop (L, 1); } lua_pop (L, 1); /* Table */ if (!rspamd_lua_parse_table_arguments (L, 1, &err, "sparsed=N;randomize=B;learn=S;activation_hidden=S;activation_output=S", &sparsed, &randomize_ann, &learn_alg, &activation_hidden, &activation_output)) { g_free (layers); if (err) { gint r; r = luaL_error (L, "invalid arguments: %s", err->message); g_error_free (err); return r; } else { return luaL_error (L, "invalid arguments"); } } if (sparsed != 0.0) { f = fann_create_standard_array (nlayers, layers); } else { f = fann_create_sparse_array (sparsed, nlayers, layers); } if (f != NULL) { pfann = lua_newuserdata (L, sizeof (gpointer)); *pfann = f; rspamd_lua_setclass (L, "rspamd{fann}", -1); } else { g_free (layers); return luaL_error (L, "cannot create fann"); } fann_set_activation_function_hidden (f, string_to_activation_func (activation_hidden)); fann_set_activation_function_output (f, string_to_activation_func (activation_output)); fann_set_training_algorithm (f, string_to_learn_alg (learn_alg)); if (randomize_ann) { fann_randomize_weights (f, 0, 1); } g_free (layers); } else { return luaL_error (L, "bad arguments"); } return 1; #endif }
int sci_fann_create(char * fname) { int * pi_command_addr = NULL; int m_layers, n_layers, * pi_layers_addr = NULL; int * pi_conn_addr = NULL; char * Command = NULL; double * layers = NULL, conn = 0.0; unsigned int * ui_layers = NULL; int res, numLayers, i; struct fann * result_ann = NULL; SciErr _sciErr; if (Rhs<2) { Scierror(999,"%s usage: ann = %s(command,[layers ...])", fname, fname); return 0; } _sciErr = getVarAddressFromPosition(pvApiCtx, 1, &pi_command_addr); if (_sciErr.iErr) { printError(&_sciErr, 0); return 0; } getAllocatedSingleString(pvApiCtx, pi_command_addr, &Command); _sciErr = getVarAddressFromPosition(pvApiCtx, 2, &pi_layers_addr); if (_sciErr.iErr) { printError(&_sciErr, 0); return 0; } _sciErr = getMatrixOfDouble(pvApiCtx, pi_layers_addr, &m_layers, &n_layers, &layers); if ((n_layers != 1) & (m_layers !=1)) { Scierror(999,"%s: Layers must be a vector!",fname); return 0; } numLayers = m_layers * n_layers; ui_layers = (unsigned int *)MALLOC(numLayers*sizeof(unsigned int)); for(i=0; i<numLayers; i++) ui_layers[i] = layers[i]; if (strcmp(Command,"standard") == 0) { freeAllocatedSingleString(Command); // fann_create_standard_array Just like fann_create_standard, but with an array of layer sizes instead of individual parameters. result_ann = fann_create_standard_array(numLayers,ui_layers); FREE(ui_layers); if (result_ann==NULL) { Scierror(999,"%s: not able to create standard network\n",fname); return 0; } } if (strcmp(Command,"sparse") == 0) { freeAllocatedSingleString(Command); // fann_create_sparse_array Just like fann_create_sparse, but with an array of layer sizes instead of individual parameters. _sciErr = getVarAddressFromPosition(pvApiCtx, 3, &pi_conn_addr); if (_sciErr.iErr) { printError(&_sciErr, 0); return 0; } getScalarDouble(pvApiCtx, pi_conn_addr, &conn); result_ann = fann_create_sparse_array(conn,numLayers,ui_layers); FREE(ui_layers); if (result_ann==NULL) { Scierror(999,"%s: not able to create sparse network\n",fname); return 0; } } if (strcmp(Command,"shortcut") == 0) { freeAllocatedSingleString(Command); // fann_create_shortcut_array Just like fann_create_shortcut, but with an array of layer sizes instead of individual parameters. result_ann = fann_create_shortcut_array(numLayers,ui_layers); FREE(ui_layers); if (result_ann==NULL) { Scierror(999,"%s: not able to create shortcut network\n",fname); return 0; } } //Create the struct representing this ann in scilab res = createScilabFannStructFromCFannStruct(result_ann, Rhs + 1); if (res==-1) return 0; LhsVar(1) = Rhs + 1; return 0; }