@ -0,0 +1,22 @@ | |||
GENANN - Minimal C Artificial Neural Network | |||
Copyright (c) 2015, 2016 Lewis Van Winkle | |||
http://CodePlea.com | |||
This software is provided 'as-is', without any express or implied | |||
warranty. In no event will the authors be held liable for any damages | |||
arising from the use of this software. | |||
Permission is granted to anyone to use this software for any purpose, | |||
including commercial applications, and to alter it and redistribute it | |||
freely, subject to the following restrictions: | |||
1. The origin of this software must not be misrepresented; you must not | |||
claim that you wrote the original software. If you use this software | |||
in a product, an acknowledgement in the product documentation would be | |||
appreciated but is not required. | |||
2. Altered source versions must be plainly marked as such, and must not be | |||
misrepresented as being the original software. | |||
3. This notice may not be removed or altered from any source distribution. | |||
@ -0,0 +1,33 @@ | |||
CC = gcc | |||
CCFLAGS = -ansi -Wall -Wshadow -O2 -g | |||
LFLAGS = -lm | |||
all: test example1 example2 example3 example4 | |||
test: test.o genann.o | |||
$(CC) $(CCFLAGS) -o $@ $^ $(LFLAGS) | |||
./$@ | |||
example1: example1.o genann.o | |||
$(CC) $(CCFLAGS) -o $@ $^ $(LFLAGS) | |||
example2: example2.o genann.o | |||
$(CC) $(CCFLAGS) -o $@ $^ $(LFLAGS) | |||
example3: example3.o genann.o | |||
$(CC) $(CCFLAGS) -o $@ $^ $(LFLAGS) | |||
example4: example4.o genann.o | |||
$(CC) $(CCFLAGS) -o $@ $^ $(LFLAGS) | |||
.c.o: | |||
$(CC) -c $(CCFLAGS) $< -o $@ | |||
clean: | |||
rm *.o | |||
rm *.exe | |||
rm persist.txt |
@ -0,0 +1,133 @@ | |||
#GENANN | |||
GENANN is a very minimal library for training and using feedforward artificial neural | |||
networks (ANN) in C. Its primary focus is on being simple, fast, and hackable. It achieves | |||
this by providing only the necessary functions and little extra. | |||
##Features | |||
- **ANSI C with no dependencies**. | |||
- Contained in a single source code and header file. | |||
- Simple. | |||
- Fast and thread-safe. | |||
- Easily extendible. | |||
- Implements backpropagation training. | |||
- Compatible with training by alternative methods (classic optimization, genetic algorithms, etc) | |||
- Includes examples and test suite. | |||
- Released under the zlib license - free for nearly any use. | |||
##Example Code | |||
Four example programs are included. | |||
- `example1.c` - Trains an ANN on the XOR function using backpropagation. | |||
- `example2.c` - Trains an ANN on the XOR function using random search. | |||
- `example3.c` - Loads and runs an ANN from a file. | |||
- `example4.c` - Trains an ANN on the [IRIS data-set](https://archive.ics.uci.edu/ml/datasets/Iris) using backpropagation. | |||
##Quick Example | |||
Here we create an ANN, train it on a set of labeled data using backpropagation, | |||
ask it to predict on a test data point, and then free it: | |||
```C | |||
#include "genann.h" | |||
/* New network with 5 inputs, | |||
* 2 hidden layer of 10 neurons each, | |||
* and 1 output. */ | |||
GENANN *ann = genann_init(5, 2, 10, 1); | |||
/* Learn on the training set. */ | |||
for (i = 0; i < 300; ++i) { | |||
for (j = 0; j < 100; ++j) | |||
genann_train(ann, training_data_input[j], training_data_output[j], 0.1); | |||
} | |||
/* Run the network and see what it predicts. */ | |||
printf("Output for the first test data point is: %f\n", *genann_run(ann, test_data_input[0])); | |||
genann_free(ann); | |||
``` | |||
Not that this example is to show API usage, it is not showing good machine | |||
learning techniques. In a real application you would likely want to learn on | |||
the test data in a random order. You would also want to monitor the learning to | |||
prevent over-fitting. | |||
##Usage | |||
###Creating and Freeing ANNs | |||
```C | |||
GENANN *genann_init(int inputs, int hidden_layers, int hidden, int outputs); | |||
GENANN *genann_copy(GENANN const *ann); | |||
void genann_free(GENANN *ann); | |||
``` | |||
Creating a new ANN is done with the `genann_init()` function. It's arguments | |||
are the number of inputs, the number of hidden layers, the number of neurons in | |||
each hidden layer, and the number of outputs. It returns a `GENANN` struct pointer. | |||
Calling `genann_copy()` will create a deep-copy of an existing GENANN struct. | |||
Call `genann_free()` when you're finished with an ANN returned by `genann_init()`. | |||
###Training ANNs | |||
```C | |||
void genann_train(GENANN const *ann, double const *inputs, double const *desired_outputs, double learning_rate); | |||
``` | |||
`genann_train()` will preform one update using standard backpropogation. It | |||
should be called by passing in an array of inputs, an array of expected output, | |||
and a learning rate. See *example1.c* for an example of learning with | |||
backpropogation. | |||
A primary design goal of GENANN was to store all the network weights in one | |||
contigious block of memory. This makes it easy and efficient to train the | |||
network weights directly using direct-search numeric optimizion algorthims, | |||
such as [Hill Climbing](https://en.wikipedia.org/wiki/Hill_climbing), | |||
[the Genetic Algorithm](https://en.wikipedia.org/wiki/Genetic_algorithm), [Simulated | |||
Annealing](https://en.wikipedia.org/wiki/Simulated_annealing), etc. | |||
These methods can be used by searching on the ANN's weights directly. | |||
Every `GENANN` struct contains the members `int total_weights;` and | |||
`double *weight;`. `*weight` points to an array of `total_weights` | |||
size which contains all weights used by the ANN. See *example2.c* for | |||
an example of training using random hill climbing search. | |||
###Saving and Loading ANNs | |||
```C | |||
GENANN *genann_read(FILE *in); | |||
void genann_write(GENANN const *ann, FILE *out); | |||
``` | |||
GENANN provides the `genann_read()` and `genann_write()` functions for loading or saving an ANN in a text-based format. | |||
###Evaluating | |||
```C | |||
double const *genann_run(GENANN const *ann, double const *inputs); | |||
``` | |||
Call `genann_run()` on a trained ANN to run a feed-forward pass on a given set of inputs. `genann_run()` | |||
will provide a pointer to the array of predicted outputs (of `ann->outputs` length). | |||
##Extra Resources | |||
The [comp.ai.neural-nets | |||
FAQ](http://www.faqs.org/faqs/ai-faq/neural-nets/part1/) is an excellent | |||
resource for an introduction to artificial neural networks. | |||
If you're looking for a heavier, more opinionated neural network library in C, | |||
I highly recommend the [FANN library](http://leenissen.dk/fann/wp/). Another | |||
good library is Peter van Rossum's [Lightweight Neural | |||
Network](http://lwneuralnet.sourceforge.net/), which despite its name, is | |||
heavier and has more features than GENANN. | |||
##Hints | |||
- All functions start with `genann_`. | |||
- The code is simple. Dig in and change things. | |||
@ -0,0 +1,150 @@ | |||
5.1,3.5,1.4,0.2,Iris-setosa | |||
4.9,3.0,1.4,0.2,Iris-setosa | |||
4.7,3.2,1.3,0.2,Iris-setosa | |||
4.6,3.1,1.5,0.2,Iris-setosa | |||
5.0,3.6,1.4,0.2,Iris-setosa | |||
5.4,3.9,1.7,0.4,Iris-setosa | |||
4.6,3.4,1.4,0.3,Iris-setosa | |||
5.0,3.4,1.5,0.2,Iris-setosa | |||
4.4,2.9,1.4,0.2,Iris-setosa | |||
4.9,3.1,1.5,0.1,Iris-setosa | |||
5.4,3.7,1.5,0.2,Iris-setosa | |||
4.8,3.4,1.6,0.2,Iris-setosa | |||
4.8,3.0,1.4,0.1,Iris-setosa | |||
4.3,3.0,1.1,0.1,Iris-setosa | |||
5.8,4.0,1.2,0.2,Iris-setosa | |||
5.7,4.4,1.5,0.4,Iris-setosa | |||
5.4,3.9,1.3,0.4,Iris-setosa | |||
5.1,3.5,1.4,0.3,Iris-setosa | |||
5.7,3.8,1.7,0.3,Iris-setosa | |||
5.1,3.8,1.5,0.3,Iris-setosa | |||
5.4,3.4,1.7,0.2,Iris-setosa | |||
5.1,3.7,1.5,0.4,Iris-setosa | |||
4.6,3.6,1.0,0.2,Iris-setosa | |||
5.1,3.3,1.7,0.5,Iris-setosa | |||
4.8,3.4,1.9,0.2,Iris-setosa | |||
5.0,3.0,1.6,0.2,Iris-setosa | |||
5.0,3.4,1.6,0.4,Iris-setosa | |||
5.2,3.5,1.5,0.2,Iris-setosa | |||
5.2,3.4,1.4,0.2,Iris-setosa | |||
4.7,3.2,1.6,0.2,Iris-setosa | |||
4.8,3.1,1.6,0.2,Iris-setosa | |||
5.4,3.4,1.5,0.4,Iris-setosa | |||
5.2,4.1,1.5,0.1,Iris-setosa | |||
5.5,4.2,1.4,0.2,Iris-setosa | |||
4.9,3.1,1.5,0.1,Iris-setosa | |||
5.0,3.2,1.2,0.2,Iris-setosa | |||
5.5,3.5,1.3,0.2,Iris-setosa | |||
4.9,3.1,1.5,0.1,Iris-setosa | |||
4.4,3.0,1.3,0.2,Iris-setosa | |||
5.1,3.4,1.5,0.2,Iris-setosa | |||
5.0,3.5,1.3,0.3,Iris-setosa | |||
4.5,2.3,1.3,0.3,Iris-setosa | |||
4.4,3.2,1.3,0.2,Iris-setosa | |||
5.0,3.5,1.6,0.6,Iris-setosa | |||
5.1,3.8,1.9,0.4,Iris-setosa | |||
4.8,3.0,1.4,0.3,Iris-setosa | |||
5.1,3.8,1.6,0.2,Iris-setosa | |||
4.6,3.2,1.4,0.2,Iris-setosa | |||
5.3,3.7,1.5,0.2,Iris-setosa | |||
5.0,3.3,1.4,0.2,Iris-setosa | |||
7.0,3.2,4.7,1.4,Iris-versicolor | |||
6.4,3.2,4.5,1.5,Iris-versicolor | |||
6.9,3.1,4.9,1.5,Iris-versicolor | |||
5.5,2.3,4.0,1.3,Iris-versicolor | |||
6.5,2.8,4.6,1.5,Iris-versicolor | |||
5.7,2.8,4.5,1.3,Iris-versicolor | |||
6.3,3.3,4.7,1.6,Iris-versicolor | |||
4.9,2.4,3.3,1.0,Iris-versicolor | |||
6.6,2.9,4.6,1.3,Iris-versicolor | |||
5.2,2.7,3.9,1.4,Iris-versicolor | |||
5.0,2.0,3.5,1.0,Iris-versicolor | |||
5.9,3.0,4.2,1.5,Iris-versicolor | |||
6.0,2.2,4.0,1.0,Iris-versicolor | |||
6.1,2.9,4.7,1.4,Iris-versicolor | |||
5.6,2.9,3.6,1.3,Iris-versicolor | |||
6.7,3.1,4.4,1.4,Iris-versicolor | |||
5.6,3.0,4.5,1.5,Iris-versicolor | |||
5.8,2.7,4.1,1.0,Iris-versicolor | |||
6.2,2.2,4.5,1.5,Iris-versicolor | |||
5.6,2.5,3.9,1.1,Iris-versicolor | |||
5.9,3.2,4.8,1.8,Iris-versicolor | |||
6.1,2.8,4.0,1.3,Iris-versicolor | |||
6.3,2.5,4.9,1.5,Iris-versicolor | |||
6.1,2.8,4.7,1.2,Iris-versicolor | |||
6.4,2.9,4.3,1.3,Iris-versicolor | |||
6.6,3.0,4.4,1.4,Iris-versicolor | |||
6.8,2.8,4.8,1.4,Iris-versicolor | |||
6.7,3.0,5.0,1.7,Iris-versicolor | |||
6.0,2.9,4.5,1.5,Iris-versicolor | |||
5.7,2.6,3.5,1.0,Iris-versicolor | |||
5.5,2.4,3.8,1.1,Iris-versicolor | |||
5.5,2.4,3.7,1.0,Iris-versicolor | |||
5.8,2.7,3.9,1.2,Iris-versicolor | |||
6.0,2.7,5.1,1.6,Iris-versicolor | |||
5.4,3.0,4.5,1.5,Iris-versicolor | |||
6.0,3.4,4.5,1.6,Iris-versicolor | |||
6.7,3.1,4.7,1.5,Iris-versicolor | |||
6.3,2.3,4.4,1.3,Iris-versicolor | |||
5.6,3.0,4.1,1.3,Iris-versicolor | |||
5.5,2.5,4.0,1.3,Iris-versicolor | |||
5.5,2.6,4.4,1.2,Iris-versicolor | |||
6.1,3.0,4.6,1.4,Iris-versicolor | |||
5.8,2.6,4.0,1.2,Iris-versicolor | |||
5.0,2.3,3.3,1.0,Iris-versicolor | |||
5.6,2.7,4.2,1.3,Iris-versicolor | |||
5.7,3.0,4.2,1.2,Iris-versicolor | |||
5.7,2.9,4.2,1.3,Iris-versicolor | |||
6.2,2.9,4.3,1.3,Iris-versicolor | |||
5.1,2.5,3.0,1.1,Iris-versicolor | |||
5.7,2.8,4.1,1.3,Iris-versicolor | |||
6.3,3.3,6.0,2.5,Iris-virginica | |||
5.8,2.7,5.1,1.9,Iris-virginica | |||
7.1,3.0,5.9,2.1,Iris-virginica | |||
6.3,2.9,5.6,1.8,Iris-virginica | |||
6.5,3.0,5.8,2.2,Iris-virginica | |||
7.6,3.0,6.6,2.1,Iris-virginica | |||
4.9,2.5,4.5,1.7,Iris-virginica | |||
7.3,2.9,6.3,1.8,Iris-virginica | |||
6.7,2.5,5.8,1.8,Iris-virginica | |||
7.2,3.6,6.1,2.5,Iris-virginica | |||
6.5,3.2,5.1,2.0,Iris-virginica | |||
6.4,2.7,5.3,1.9,Iris-virginica | |||
6.8,3.0,5.5,2.1,Iris-virginica | |||
5.7,2.5,5.0,2.0,Iris-virginica | |||
5.8,2.8,5.1,2.4,Iris-virginica | |||
6.4,3.2,5.3,2.3,Iris-virginica | |||
6.5,3.0,5.5,1.8,Iris-virginica | |||
7.7,3.8,6.7,2.2,Iris-virginica | |||
7.7,2.6,6.9,2.3,Iris-virginica | |||
6.0,2.2,5.0,1.5,Iris-virginica | |||
6.9,3.2,5.7,2.3,Iris-virginica | |||
5.6,2.8,4.9,2.0,Iris-virginica | |||
7.7,2.8,6.7,2.0,Iris-virginica | |||
6.3,2.7,4.9,1.8,Iris-virginica | |||
6.7,3.3,5.7,2.1,Iris-virginica | |||
7.2,3.2,6.0,1.8,Iris-virginica | |||
6.2,2.8,4.8,1.8,Iris-virginica | |||
6.1,3.0,4.9,1.8,Iris-virginica | |||
6.4,2.8,5.6,2.1,Iris-virginica | |||
7.2,3.0,5.8,1.6,Iris-virginica | |||
7.4,2.8,6.1,1.9,Iris-virginica | |||
7.9,3.8,6.4,2.0,Iris-virginica | |||
6.4,2.8,5.6,2.2,Iris-virginica | |||
6.3,2.8,5.1,1.5,Iris-virginica | |||
6.1,2.6,5.6,1.4,Iris-virginica | |||
7.7,3.0,6.1,2.3,Iris-virginica | |||
6.3,3.4,5.6,2.4,Iris-virginica | |||
6.4,3.1,5.5,1.8,Iris-virginica | |||
6.0,3.0,4.8,1.8,Iris-virginica | |||
6.9,3.1,5.4,2.1,Iris-virginica | |||
6.7,3.1,5.6,2.4,Iris-virginica | |||
6.9,3.1,5.1,2.3,Iris-virginica | |||
5.8,2.7,5.1,1.9,Iris-virginica | |||
6.8,3.2,5.9,2.3,Iris-virginica | |||
6.7,3.3,5.7,2.5,Iris-virginica | |||
6.7,3.0,5.2,2.3,Iris-virginica | |||
6.3,2.5,5.0,1.9,Iris-virginica | |||
6.5,3.0,5.2,2.0,Iris-virginica | |||
6.2,3.4,5.4,2.3,Iris-virginica | |||
5.9,3.0,5.1,1.8,Iris-virginica |
@ -0,0 +1,69 @@ | |||
1. Title: Iris Plants Database | |||
Updated Sept 21 by C.Blake - Added discrepency information | |||
2. Sources: | |||
(a) Creator: R.A. Fisher | |||
(b) Donor: Michael Marshall (MARSHALL%PLU@io.arc.nasa.gov) | |||
(c) Date: July, 1988 | |||
3. Past Usage: | |||
- Publications: too many to mention!!! Here are a few. | |||
1. Fisher,R.A. "The use of multiple measurements in taxonomic problems" | |||
Annual Eugenics, 7, Part II, 179-188 (1936); also in "Contributions | |||
to Mathematical Statistics" (John Wiley, NY, 1950). | |||
2. Duda,R.O., & Hart,P.E. (1973) Pattern Classification and Scene Analysis. | |||
(Q327.D83) John Wiley & Sons. ISBN 0-471-22361-1. See page 218. | |||
3. Dasarathy, B.V. (1980) "Nosing Around the Neighborhood: A New System | |||
Structure and Classification Rule for Recognition in Partially Exposed | |||
Environments". IEEE Transactions on Pattern Analysis and Machine | |||
Intelligence, Vol. PAMI-2, No. 1, 67-71. | |||
-- Results: | |||
-- very low misclassification rates (0% for the setosa class) | |||
4. Gates, G.W. (1972) "The Reduced Nearest Neighbor Rule". IEEE | |||
Transactions on Information Theory, May 1972, 431-433. | |||
-- Results: | |||
-- very low misclassification rates again | |||
5. See also: 1988 MLC Proceedings, 54-64. Cheeseman et al's AUTOCLASS II | |||
conceptual clustering system finds 3 classes in the data. | |||
4. Relevant Information: | |||
--- This is perhaps the best known database to be found in the pattern | |||
recognition literature. Fisher's paper is a classic in the field | |||
and is referenced frequently to this day. (See Duda & Hart, for | |||
example.) The data set contains 3 classes of 50 instances each, | |||
where each class refers to a type of iris plant. One class is | |||
linearly separable from the other 2; the latter are NOT linearly | |||
separable from each other. | |||
--- Predicted attribute: class of iris plant. | |||
--- This is an exceedingly simple domain. | |||
--- This data differs from the data presented in Fishers article | |||
(identified by Steve Chadwick, spchadwick@espeedaz.net ) | |||
The 35th sample should be: 4.9,3.1,1.5,0.2,"Iris-setosa" | |||
where the error is in the fourth feature. | |||
The 38th sample: 4.9,3.6,1.4,0.1,"Iris-setosa" | |||
where the errors are in the second and third features. | |||
5. Number of Instances: 150 (50 in each of three classes) | |||
6. Number of Attributes: 4 numeric, predictive attributes and the class | |||
7. Attribute Information: | |||
1. sepal length in cm | |||
2. sepal width in cm | |||
3. petal length in cm | |||
4. petal width in cm | |||
5. class: | |||
-- Iris Setosa | |||
-- Iris Versicolour | |||
-- Iris Virginica | |||
8. Missing Attribute Values: None | |||
Summary Statistics: | |||
Min Max Mean SD Class Correlation | |||
sepal length: 4.3 7.9 5.84 0.83 0.7826 | |||
sepal width: 2.0 4.4 3.05 0.43 -0.4194 | |||
petal length: 1.0 6.9 3.76 1.76 0.9490 (high!) | |||
petal width: 0.1 2.5 1.20 0.76 0.9565 (high!) | |||
9. Class Distribution: 33.3% for each of 3 classes. |
@ -0,0 +1 @@ | |||
2 1 2 1 -1.777 -5.734 -6.029 -4.460 -3.261 -3.172 2.444 -6.581 5.826 |
@ -0,0 +1,35 @@ | |||
#include <stdio.h> | |||
#include "genann.h" | |||
int main(int argc, char *argv[]) | |||
{ | |||
printf("GENANN example 1.\n"); | |||
printf("Train a small ANN to the XOR function using backpropagation.\n"); | |||
/* Input and expected out data for the XOR function. */ | |||
const double input[4][2] = {{0, 0}, {0, 1}, {1, 0}, {1, 1}}; | |||
const double output[4] = {0, 1, 1, 0}; | |||
int i; | |||
/* New network with 2 inputs, | |||
* 1 hidden layer of 2 neurons, | |||
* and 1 output. */ | |||
GENANN *ann = genann_init(2, 1, 2, 1); | |||
/* Train on the four labeled data points many times. */ | |||
for (i = 0; i < 300; ++i) { | |||
genann_train(ann, input[0], output + 0, 3); | |||
genann_train(ann, input[1], output + 1, 3); | |||
genann_train(ann, input[2], output + 2, 3); | |||
genann_train(ann, input[3], output + 3, 3); | |||
} | |||
/* Run the network and see what it predicts. */ | |||
printf("Output for [%1.f, %1.f] is %1.f.\n", input[0][0], input[0][1], *genann_run(ann, input[0])); | |||
printf("Output for [%1.f, %1.f] is %1.f.\n", input[1][0], input[1][1], *genann_run(ann, input[1])); | |||
printf("Output for [%1.f, %1.f] is %1.f.\n", input[2][0], input[2][1], *genann_run(ann, input[2])); | |||
printf("Output for [%1.f, %1.f] is %1.f.\n", input[3][0], input[3][1], *genann_run(ann, input[3])); | |||
genann_free(ann); | |||
return 0; | |||
} |
@ -0,0 +1,67 @@ | |||
#include <stdio.h> | |||
#include <stdlib.h> | |||
#include <math.h> | |||
#include "genann.h" | |||
int main(int argc, char *argv[]) | |||
{ | |||
printf("GENANN example 2.\n"); | |||
printf("Train a small ANN to the XOR function using random search.\n"); | |||
/* Input and expected out data for the XOR function. */ | |||
const double input[4][2] = {{0, 0}, {0, 1}, {1, 0}, {1, 1}}; | |||
const double output[4] = {0, 1, 1, 0}; | |||
int i; | |||
/* New network with 2 inputs, | |||
* 1 hidden layer of 2 neurons, | |||
* and 1 output. */ | |||
GENANN *ann = genann_init(2, 1, 2, 1); | |||
double err; | |||
double last_err = 1000; | |||
int count = 0; | |||
do { | |||
++count; | |||
if (count % 1000 == 0) { | |||
/* We're stuck, start over. */ | |||
genann_randomize(ann); | |||
} | |||
GENANN *save = genann_copy(ann); | |||
/* Take a random guess at the ANN weights. */ | |||
for (i = 0; i < ann->total_weights; ++i) { | |||
ann->weight[i] += ((double)rand())/RAND_MAX-0.5; | |||
} | |||
/* See how we did. */ | |||
err = 0; | |||
err += pow(*genann_run(ann, input[0]) - output[0], 2.0); | |||
err += pow(*genann_run(ann, input[1]) - output[1], 2.0); | |||
err += pow(*genann_run(ann, input[2]) - output[2], 2.0); | |||
err += pow(*genann_run(ann, input[3]) - output[3], 2.0); | |||
/* Keep these weights if they're an improvement. */ | |||
if (err < last_err) { | |||
genann_free(save); | |||
last_err = err; | |||
} else { | |||
genann_free(ann); | |||
ann = save; | |||
} | |||
} while (err > 0.01); | |||
printf("Finished in %d loops.\n", count); | |||
/* Run the network and see what it predicts. */ | |||
printf("Output for [%1.f, %1.f] is %1.f.\n", input[0][0], input[0][1], *genann_run(ann, input[0])); | |||
printf("Output for [%1.f, %1.f] is %1.f.\n", input[1][0], input[1][1], *genann_run(ann, input[1])); | |||
printf("Output for [%1.f, %1.f] is %1.f.\n", input[2][0], input[2][1], *genann_run(ann, input[2])); | |||
printf("Output for [%1.f, %1.f] is %1.f.\n", input[3][0], input[3][1], *genann_run(ann, input[3])); | |||
genann_free(ann); | |||
return 0; | |||
} |
@ -0,0 +1,39 @@ | |||
#include <stdio.h> | |||
#include <stdlib.h> | |||
#include "genann.h" | |||
const char *save_name = "example/xor.ann"; | |||
int main(int argc, char *argv[]) | |||
{ | |||
printf("GENANN example 3.\n"); | |||
printf("Load a saved ANN to solve the XOR function.\n"); | |||
FILE *saved = fopen(save_name, "r"); | |||
if (!saved) { | |||
printf("Couldn't open file: %s\n", save_name); | |||
exit(1); | |||
} | |||
GENANN *ann = genann_read(saved); | |||
fclose(saved); | |||
if (!ann) { | |||
printf("Error loading ANN from file.", save_name); | |||
exit(1); | |||
} | |||
/* Input data for the XOR function. */ | |||
const double input[4][2] = {{0, 0}, {0, 1}, {1, 0}, {1, 1}}; | |||
/* Run the network and see what it predicts. */ | |||
printf("Output for [%1.f, %1.f] is %1.f.\n", input[0][0], input[0][1], *genann_run(ann, input[0])); | |||
printf("Output for [%1.f, %1.f] is %1.f.\n", input[1][0], input[1][1], *genann_run(ann, input[1])); | |||
printf("Output for [%1.f, %1.f] is %1.f.\n", input[2][0], input[2][1], *genann_run(ann, input[2])); | |||
printf("Output for [%1.f, %1.f] is %1.f.\n", input[3][0], input[3][1], *genann_run(ann, input[3])); | |||
genann_free(ann); | |||
return 0; | |||
} |
@ -0,0 +1,111 @@ | |||
#include <stdio.h> | |||
#include <stdlib.h> | |||
#include <string.h> | |||
#include <math.h> | |||
#include "genann.h" | |||
/* This example is to illustrate how to use GENANN. | |||
* It is NOT an example of good machine learning techniques. | |||
*/ | |||
const char *iris_data = "example/iris.data"; | |||
double *input, *class; | |||
int samples; | |||
const char *class_names[] = {"Iris-setosa", "Iris-versicolor", "Iris-virginica"}; | |||
void load_data() { | |||
/* Load the iris data-set. */ | |||
FILE *in = fopen("example/iris.data", "r"); | |||
if (!in) { | |||
printf("Could not open file: %s\n", iris_data); | |||
exit(1); | |||
} | |||
/* Loop through the data to get a count. */ | |||
char line[1024]; | |||
while (!feof(in) && fgets(line, 1024, in)) { | |||
++samples; | |||
} | |||
fseek(in, 0, SEEK_SET); | |||
printf("Loading %d data points from %s\n", samples, iris_data); | |||
/* Allocate memory for input and output data. */ | |||
input = malloc(sizeof(double) * samples * 4); | |||
class = malloc(sizeof(double) * samples * 3); | |||
/* Read the file into our arrays. */ | |||
int i, j; | |||
for (i = 0; i < samples; ++i) { | |||
double *p = input + i * 4; | |||
double *c = class + i * 3; | |||
c[0] = c[1] = c[2] = 0.0; | |||
fgets(line, 1024, in); | |||
char *split = strtok(line, ","); | |||
for (j = 0; j < 4; ++j) { | |||
p[j] = atof(split); | |||
split = strtok(0, ","); | |||
} | |||
split[strlen(split)-1] = 0; | |||
if (strcmp(split, class_names[0]) == 0) {c[0] = 1.0;} | |||
else if (strcmp(split, class_names[1]) == 0) {c[1] = 1.0;} | |||
else if (strcmp(split, class_names[2]) == 0) {c[2] = 1.0;} | |||
else { | |||
printf("Unknown class %s.\n", split); | |||
exit(1); | |||
} | |||
/* printf("Data point %d is %f %f %f %f -> %f %f %f\n", i, p[0], p[1], p[2], p[3], c[0], c[1], c[2]); */ | |||
} | |||
fclose(in); | |||
} | |||
int main(int argc, char *argv[]) | |||
{ | |||
printf("GENANN example 4.\n"); | |||
printf("Train an ANN on the IRIS dataset using backpropagation.\n"); | |||
/* Load the data from file. */ | |||
load_data(); | |||
/* 4 inputs. | |||
* 1 hidden layer(s) of 4 neurons. | |||
* 3 outputs (1 per class) | |||
*/ | |||
GENANN *ann = genann_init(4, 1, 4, 3); | |||
int i, j; | |||
int loops = 5000; | |||
/* Train the network with backpropagation. */ | |||
printf("Training for %d loops over data.\n", loops); | |||
for (i = 0; i < loops; ++i) { | |||
for (j = 0; j < samples; ++j) { | |||
genann_train(ann, input + j*4, class + j*3, .01); | |||
} | |||
/* printf("%1.2f ", xor_score(ann)); */ | |||
} | |||
int correct = 0; | |||
for (j = 0; j < samples; ++j) { | |||
const double *guess = genann_run(ann, input + j*4); | |||
if (class[j*3+0] == 1.0) {if (guess[0] > guess[1] && guess[0] > guess[2]) ++correct;} | |||
else if (class[j*3+1] == 1.0) {if (guess[1] > guess[0] && guess[1] > guess[2]) ++correct;} | |||
else if (class[j*3+2] == 1.0) {if (guess[2] > guess[0] && guess[2] > guess[1]) ++correct;} | |||
else {printf("Logic error.\n"); exit(1);} | |||
} | |||
printf("%d/%d correct (%0.1f%%).\n", correct, samples, (double)correct / samples * 100.0); | |||
genann_free(ann); | |||
return 0; | |||
} |
@ -0,0 +1,346 @@ | |||
/* | |||
* GENANN - Minimal C Artificial Neural Network | |||
* | |||
* Copyright (c) 2015, 2016 Lewis Van Winkle | |||
* | |||
* http://CodePlea.com | |||
* | |||
* This software is provided 'as-is', without any express or implied | |||
* warranty. In no event will the authors be held liable for any damages | |||
* arising from the use of this software. | |||
* | |||
* Permission is granted to anyone to use this software for any purpose, | |||
* including commercial applications, and to alter it and redistribute it | |||
* freely, subject to the following restrictions: | |||
* | |||
* 1. The origin of this software must not be misrepresented; you must not | |||
* claim that you wrote the original software. If you use this software | |||
* in a product, an acknowledgement in the product documentation would be | |||
* appreciated but is not required. | |||
* 2. Altered source versions must be plainly marked as such, and must not be | |||
* misrepresented as being the original software. | |||
* 3. This notice may not be removed or altered from any source distribution. | |||
* | |||
*/ | |||
#include "genann.h" | |||
#include <stdlib.h> | |||
#include <string.h> | |||
#include <math.h> | |||
#include <assert.h> | |||
#include <stdio.h> | |||
#define LOOKUP_SIZE 4096 | |||
double genann_act_sigmoid(double a) { | |||
if (a < -45.0) return 0; | |||
if (a > 45.0) return 1; | |||
return 1.0 / (1 + exp(-a)); | |||
} | |||
double genann_act_sigmoid_cached(double a) { | |||
/* If you're optimizing for memory usage, just | |||
* delete this entire function and replace references | |||
* of genann_act_sigmoid_cached to genann_act_sigmoid | |||
*/ | |||
const double min = -15.0; | |||
const double max = 15.0; | |||
static double interval; | |||
static int initialized = 0; | |||
static double lookup[LOOKUP_SIZE]; | |||
/* Calculate entire lookup table on first run. */ | |||
if (!initialized) { | |||
interval = (max - min) / LOOKUP_SIZE; | |||
int i; | |||
for (i = 0; i < LOOKUP_SIZE; ++i) { | |||
lookup[i] = genann_act_sigmoid(min + interval * i); | |||
} | |||
/* This is down here to make this thread safe. */ | |||
initialized = 1; | |||
} | |||
int i; | |||
i = (int)((a-min)/interval+0.5); | |||
if (i <= 0) return lookup[0]; | |||
if (i >= LOOKUP_SIZE) return lookup[LOOKUP_SIZE-1]; | |||
return lookup[i]; | |||
} | |||
double genann_act_threshold(double a) { | |||
return a > 0; | |||
} | |||
GENANN *genann_init(int inputs, int hidden_layers, int hidden, int outputs) { | |||
if (hidden_layers < 0) return 0; | |||
if (inputs < 1) return 0; | |||
if (outputs < 1) return 0; | |||
if (hidden_layers > 0 && hidden < 1) return 0; | |||
const int hidden_weights = hidden_layers ? (inputs+1) * hidden + (hidden_layers-1) * (hidden+1) * hidden : 0; | |||
const int output_weights = (hidden_layers ? (hidden+1) : (inputs+1)) * outputs; | |||
const int total_weights = (hidden_weights + output_weights); | |||
const int total_neurons = (inputs + hidden * hidden_layers + outputs); | |||
/* Allocate extra size for weights, outputs, and deltas. */ | |||
const int size = sizeof(GENANN) + sizeof(double) * (total_weights + total_neurons + (total_neurons - inputs)); | |||
GENANN *ret = malloc(size); | |||
if (!ret) return 0; | |||
ret->inputs = inputs; | |||
ret->hidden_layers = hidden_layers; | |||
ret->hidden = hidden; | |||
ret->outputs = outputs; | |||
ret->total_weights = total_weights; | |||
ret->total_neurons = total_neurons; | |||
/* Set pointers. */ | |||
ret->weight = (double*)((char*)ret + sizeof(GENANN)); | |||
ret->output = ret->weight + ret->total_weights; | |||
ret->delta = ret->output + ret->total_neurons; | |||
genann_randomize(ret); | |||
ret->activation_hidden = genann_act_sigmoid_cached; | |||
ret->activation_output = genann_act_sigmoid_cached; | |||
return ret; | |||
} | |||
GENANN *genann_read(FILE *in) { | |||
int inputs, hidden_layers, hidden, outputs; | |||
fscanf(in, "%d %d %d %d", &inputs, &hidden_layers, &hidden, &outputs); | |||
GENANN *ann = genann_init(inputs, hidden_layers, hidden, outputs); | |||
int i; | |||
for (i = 0; i < ann->total_weights; ++i) { | |||
fscanf(in, " %le", ann->weight + i); | |||
} | |||
return ann; | |||
} | |||
GENANN *genann_copy(GENANN const *ann) { | |||
const int size = sizeof(GENANN) + sizeof(double) * (ann->total_weights + ann->total_neurons + (ann->total_neurons - ann->inputs)); | |||
GENANN *ret = malloc(size); | |||
if (!ret) return 0; | |||
memcpy(ret, ann, size); | |||
/* Set pointers. */ | |||
ret->weight = (double*)((char*)ret + sizeof(GENANN)); | |||
ret->output = ret->weight + ret->total_weights; | |||
ret->delta = ret->output + ret->total_neurons; | |||
return ret; | |||
} | |||
void genann_randomize(GENANN *ann) { | |||
int i; | |||
for (i = 0; i < ann->total_weights; ++i) { | |||
double r = GENANN_RANDOM(); | |||
/* Sets weights from -0.5 to 0.5. */ | |||
ann->weight[i] = r - 0.5; | |||
} | |||
} | |||
void genann_free(GENANN *ann) { | |||
/* The weight, output, and delta pointers go to the same buffer. */ | |||
free(ann); | |||
} | |||
double const *genann_run(GENANN const *ann, double const *inputs) { | |||
double const *w = ann->weight; | |||
double *o = ann->output + ann->inputs; | |||
double const *i = ann->output; | |||
/* Copy the inputs to the scratch area, where we also store each neuron's | |||
* output, for consistency. This way the first layer isn't a special case. */ | |||
memcpy(ann->output, inputs, sizeof(double) * ann->inputs); | |||
int h, j, k; | |||
const GENANN_ACTFUN act = ann->activation_hidden; | |||
const GENANN_ACTFUN acto = ann->activation_output; | |||
/* Figure hidden layers, if any. */ | |||
for (h = 0; h < ann->hidden_layers; ++h) { | |||
for (j = 0; j < ann->hidden; ++j) { | |||
double sum = 0; | |||
for (k = 0; k < (h == 0 ? ann->inputs : ann->hidden) + 1; ++k) { | |||
if (k == 0) { | |||
sum += *w++ * -1.0; | |||
} else { | |||
sum += *w++ * i[k-1]; | |||
} | |||
} | |||
*o++ = act(sum); | |||
} | |||
i += (h == 0 ? ann->inputs : ann->hidden); | |||
} | |||
double const *ret = o; | |||
/* Figure output layer. */ | |||
for (j = 0; j < ann->outputs; ++j) { | |||
double sum = 0; | |||
for (k = 0; k < (ann->hidden_layers ? ann->hidden : ann->inputs) + 1; ++k) { | |||
if (k == 0) { | |||
sum += *w++ * -1.0; | |||
} else { | |||
sum += *w++ * i[k-1]; | |||
} | |||
} | |||
*o++ = acto(sum); | |||
} | |||
/* Sanity check that we used all weights and wrote all outputs. */ | |||
assert(w - ann->weight == ann->total_weights); | |||
assert(o - ann->output == ann->total_neurons); | |||
return ret; | |||
} | |||
void genann_train(GENANN const *ann, double const *inputs, double const *desired_outputs, double learning_rate) { | |||
/* To begin with, we must run the network forward. */ | |||
genann_run(ann, inputs); | |||
int h, j, k; | |||
/* First set the output layer deltas. */ | |||
{ | |||
double const *o = ann->output + ann->inputs + ann->hidden * ann->hidden_layers; /* First output. */ | |||
double *d = ann->delta + ann->hidden * ann->hidden_layers; /* First delta. */ | |||
double const *t = desired_outputs; /* First desired output. */ | |||
/* Set output layer deltas. */ | |||
for (j = 0; j < ann->outputs; ++j) { | |||
*d = (*t - *o) * *o * (1.0 - *o); | |||
++o; ++d; ++t; | |||
} | |||
} | |||
/* Set hidden layer deltas, start on last layer and work backwards. */ | |||
/* Note that loop is skipped in the case of hidden_layers == 0. */ | |||
for (h = ann->hidden_layers - 1; h >= 0; --h) { | |||
/* Find first output and delta in this layer. */ | |||
double const *o = ann->output + ann->inputs + (h * ann->hidden); | |||
double *d = ann->delta + (h * ann->hidden); | |||
/* Find first delta in following layer (which may be hidden or output). */ | |||
double const * const dd = ann->delta + ((h+1) * ann->hidden); | |||
/* Find first weight in following layer (which may be hidden or output). */ | |||
double const * const ww = ann->weight + ((ann->inputs+1) * ann->hidden) + ((ann->hidden+1) * ann->hidden * (h)); | |||
for (j = 0; j < ann->hidden; ++j) { | |||
double delta = 0; | |||
for (k = 0; k < (h == ann->hidden_layers-1 ? ann->outputs : ann->hidden); ++k) { | |||
const double forward_delta = dd[k]; | |||
const int windex = k * (ann->hidden + 1) + (j + 1); | |||
const double forward_weight = ww[windex]; | |||
delta += forward_delta * forward_weight; | |||
} | |||
*d = *o * (1.0-*o) * delta; | |||
++d; ++o; | |||
} | |||
} | |||
/* Train the outputs. */ | |||
{ | |||
/* Find first output delta. */ | |||
double const *d = ann->delta + ann->hidden * ann->hidden_layers; /* First output delta. */ | |||
/* Find first weight to first output delta. */ | |||
double *w = ann->weight + (ann->hidden_layers | |||
? ((ann->inputs+1) * ann->hidden + (ann->hidden+1) * ann->hidden * (ann->hidden_layers-1)) | |||
: (0)); | |||
/* Find first output in previous layer. */ | |||
double const * const i = ann->output + (ann->hidden_layers | |||
? (ann->inputs + (ann->hidden) * (ann->hidden_layers-1)) | |||
: 0); | |||
/* Set output layer deltas. */ | |||
for (j = 0; j < ann->outputs; ++j) { | |||
for (k = 0; k < (ann->hidden_layers ? ann->hidden : ann->inputs) + 1; ++k) { | |||
if (k == 0) { | |||
*w++ += *d * learning_rate * -1.0; | |||
} else { | |||
*w++ += *d * learning_rate * i[k-1]; | |||
} | |||
} | |||
++d; | |||
} | |||
assert(w - ann->weight == ann->total_weights); | |||
} | |||
/* Train the hidden layers. */ | |||
for (h = ann->hidden_layers - 1; h >= 0; --h) { | |||
/* Find first delta in this layer. */ | |||
double const *d = ann->delta + (h * ann->hidden); | |||
/* Find first input to this layer. */ | |||
double const *i = ann->output + (h | |||
? (ann->inputs + ann->hidden * (h-1)) | |||
: 0); | |||
/* Find first weight to this layer. */ | |||
double *w = ann->weight + (h | |||
? ((ann->inputs+1) * ann->hidden + (ann->hidden+1) * (ann->hidden) * (h-1)) | |||
: 0); | |||
for (j = 0; j < ann->hidden; ++j) { | |||
for (k = 0; k < (h == 0 ? ann->inputs : ann->hidden) + 1; ++k) { | |||
if (k == 0) { | |||
*w++ += *d * learning_rate * -1.0; | |||
} else { | |||
*w++ += *d * learning_rate * i[k-1]; | |||
} | |||
} | |||
++d; | |||
} | |||
} | |||
} | |||
void genann_write(GENANN const *ann, FILE *out) { | |||
fprintf(out, "%d %d %d %d", ann->inputs, ann->hidden_layers, ann->hidden, ann->outputs); | |||
int i; | |||
for (i = 0; i < ann->total_weights; ++i) { | |||
fprintf(out, " %.20e", ann->weight[i]); | |||
} | |||
} | |||
@ -0,0 +1,103 @@ | |||
/* | |||
* GENANN - Minimal C Artificial Neural Network | |||
* | |||
* Copyright (c) 2015, 2016 Lewis Van Winkle | |||
* | |||
* http://CodePlea.com | |||
* | |||
* This software is provided 'as-is', without any express or implied | |||
* warranty. In no event will the authors be held liable for any damages | |||
* arising from the use of this software. | |||
* | |||
* Permission is granted to anyone to use this software for any purpose, | |||
* including commercial applications, and to alter it and redistribute it | |||
* freely, subject to the following restrictions: | |||
* | |||
* 1. The origin of this software must not be misrepresented; you must not | |||
* claim that you wrote the original software. If you use this software | |||
* in a product, an acknowledgement in the product documentation would be | |||
* appreciated but is not required. | |||
* 2. Altered source versions must be plainly marked as such, and must not be | |||
* misrepresented as being the original software. | |||
* 3. This notice may not be removed or altered from any source distribution. | |||
* | |||
*/ | |||
#ifndef __GENANN_H__ | |||
#define __GENANN_H__ | |||
#include <stdio.h> | |||
#ifndef GENANN_RANDOM | |||
/* We use the following for uniform random numbers between 0 and 1. | |||
* If you have a better function, redefine this macro. */ | |||
#define GENANN_RANDOM() (((double)rand())/RAND_MAX) | |||
#endif | |||
typedef double (*GENANN_ACTFUN)(double a); | |||
typedef struct GENANN { | |||
/* How many inputs, outputs, and hidden neurons. */ | |||
int inputs, hidden_layers, hidden, outputs; | |||
/* Which activation function to use for hidden neurons. Default: gennann_act_sigmoid_cached*/ | |||
GENANN_ACTFUN activation_hidden; | |||
/* Which activation function to use for output. Default: gennann_act_sigmoid_cached*/ | |||
GENANN_ACTFUN activation_output; | |||
/* Total number of weights, and size of weights buffer. */ | |||
int total_weights; | |||
/* Total number of neurons + inputs and size of output buffer. */ | |||
int total_neurons; | |||
/* All weights (total_weights long). */ | |||
double *weight; | |||
/* Stores input array and output of each neuron (total_neurons long). */ | |||
double *output; | |||
/* Stores delta of each hidden and output neuron (total_neurons - inputs long). */ | |||
double *delta; | |||
} GENANN; | |||
/* Creates and returns a new ann. */ | |||
GENANN *genann_init(int inputs, int hidden_layers, int hidden, int outputs); | |||
/* Creates ANN from file saved with genann_write. */ | |||
GENANN *genann_read(FILE *in); | |||
/* Sets weights randomly. Called by init. */ | |||
void genann_randomize(GENANN *ann); | |||
/* Returns a new copy of ann. */ | |||
GENANN *genann_copy(GENANN const *ann); | |||
/* Frees the memory used by an ann. */ | |||
void genann_free(GENANN *ann); | |||
/* Runs the feedforward algorithm to calculate the ann's output. */ | |||
double const *genann_run(GENANN const *ann, double const *inputs); | |||
/* Does a single backprop update. */ | |||
void genann_train(GENANN const *ann, double const *inputs, double const *desired_outputs, double learning_rate); | |||
/* Saves the ann. */ | |||
void genann_write(GENANN const *ann, FILE *out); | |||
double genann_act_sigmoid(double a); | |||
double genann_act_sigmoid_cached(double a); | |||
double genann_act_threshold(double a); | |||
#endif /*__GENANN_H__*/ |
@ -0,0 +1,127 @@ | |||
/* | |||
* | |||
* MINCTEST - Minimal C Test Library - 0.1 | |||
* | |||
* Copyright (c) 2014, 2015, 2016 Lewis Van Winkle | |||
* | |||
* http://CodePlea.com | |||
* | |||
* This software is provided 'as-is', without any express or implied | |||
* warranty. In no event will the authors be held liable for any damages | |||
* arising from the use of this software. | |||
* | |||
* Permission is granted to anyone to use this software for any purpose, | |||
* including commercial applications, and to alter it and redistribute it | |||
* freely, subject to the following restrictions: | |||
* | |||
* 1. The origin of this software must not be misrepresented; you must not | |||
* claim that you wrote the original software. If you use this software | |||
* in a product, an acknowledgement in the product documentation would be | |||
* appreciated but is not required. | |||
* 2. Altered source versions must be plainly marked as such, and must not be | |||
* misrepresented as being the original software. | |||
* 3. This notice may not be removed or altered from any source distribution. | |||
* | |||
*/ | |||
/* | |||
* MINCTEST - Minimal testing library for C | |||
* | |||
* | |||
* Example: | |||
* | |||
* void test1() { | |||
* lok('a' == 'a'); | |||
* } | |||
* | |||
* void test2() { | |||
* lequal(5, 6); | |||
* lfequal(5.5, 5.6); | |||
* } | |||
* | |||
* int main() { | |||
* lrun("test1", test1); | |||
* lrun("test2", test2); | |||
* lresults(); | |||
* return lfails != 0; | |||
* } | |||
* | |||
* | |||
* | |||
* Hints: | |||
* All functions/variables start with the letter 'l'. | |||
* | |||
*/ | |||
#ifndef __MINCTEST_H__ | |||
#define __MINCTEST_H__ | |||
#include <stdio.h> | |||
#include <math.h> | |||
#include <time.h> | |||
/* How far apart can floats be before we consider them unequal. */ | |||
#define LTEST_FLOAT_TOLERANCE 0.001 | |||
/* Track the number of passes, fails. */ | |||
/* NB this is made for all tests to be in one file. */ | |||
static int ltests = 0; | |||
static int lfails = 0; | |||
/* Display the test results. */ | |||
#define lresults() do {\ | |||
if (lfails == 0) {\ | |||
printf("ALL TESTS PASSED (%d/%d)\n", ltests, ltests);\ | |||
} else {\ | |||
printf("SOME TESTS FAILED (%d/%d)\n", ltests-lfails, ltests);\ | |||
}\ | |||
} while (0) | |||
/* Run a test. Name can be any string to print out, test is the function name to call. */ | |||
#define lrun(name, test) do {\ | |||
const int ts = ltests;\ | |||
const int fs = lfails;\ | |||
const clock_t start = clock();\ | |||
printf("\t%-14s", name);\ | |||
test();\ | |||
printf("pass:%2d fail:%2d %4dms\n",\ | |||
(ltests-ts)-(lfails-fs), lfails-fs,\ | |||
(int)((clock() - start) * 1000 / CLOCKS_PER_SEC));\ | |||
} while (0) | |||
/* Assert a true statement. */ | |||
#define lok(test) do {\ | |||
++ltests;\ | |||
if (!(test)) {\ | |||
++lfails;\ | |||
printf("%s:%d error \n", __FILE__, __LINE__);\ | |||
}} while (0) | |||
/* Assert two integers are equal. */ | |||
#define lequal(a, b) do {\ | |||
++ltests;\ | |||
if ((a) != (b)) {\ | |||
++lfails;\ | |||
printf("%s:%d (%d != %d)\n", __FILE__, __LINE__, (a), (b));\ | |||
}} while (0) | |||
/* Assert two floats are equal (Within LTEST_FLOAT_TOLERANCE). */ | |||
#define lfequal(a, b) do {\ | |||
++ltests;\ | |||
if (fabs((double)(a)-(double)(b)) > LTEST_FLOAT_TOLERANCE) {\ | |||
++lfails;\ | |||
printf("%s:%d (%f != %f)\n", __FILE__, __LINE__, (double)(a), (double)(b));\ | |||
}} while (0) | |||
#endif /*__MINCTEST_H__*/ |
@ -0,0 +1,276 @@ | |||
/* | |||
* GENANN - Minimal C Artificial Neural Network | |||
* | |||
* Copyright (c) 2015, 2016 Lewis Van Winkle | |||
* | |||
* http://CodePlea.com | |||
* | |||
* This software is provided 'as-is', without any express or implied | |||
* warranty. In no event will the authors be held liable for any damages | |||
* arising from the use of this software. | |||
* | |||
* Permission is granted to anyone to use this software for any purpose, | |||
* including commercial applications, and to alter it and redistribute it | |||
* freely, subject to the following restrictions: | |||
* | |||
* 1. The origin of this software must not be misrepresented; you must not | |||
* claim that you wrote the original software. If you use this software | |||
* in a product, an acknowledgement in the product documentation would be | |||
* appreciated but is not required. | |||
* 2. Altered source versions must be plainly marked as such, and must not be | |||
* misrepresented as being the original software. | |||
* 3. This notice may not be removed or altered from any source distribution. | |||
* | |||
*/ | |||
#include "genann.h" | |||
#include "minctest.h" | |||
#include <stdio.h> | |||
#include <math.h> | |||
#include <stdlib.h> | |||
void basic() { | |||
GENANN *ann = genann_init(1, 0, 0, 1); | |||
lequal(ann->total_weights, 2); | |||
double a; | |||
a = 0; | |||
ann->weight[0] = 0; | |||
ann->weight[1] = 0; | |||
lfequal(0.5, *genann_run(ann, &a)); | |||
a = 1; | |||
lfequal(0.5, *genann_run(ann, &a)); | |||
a = 11; | |||
lfequal(0.5, *genann_run(ann, &a)); | |||
a = 1; | |||
ann->weight[0] = 1; | |||
ann->weight[1] = 1; | |||
lfequal(0.5, *genann_run(ann, &a)); | |||
a = 10; | |||
ann->weight[0] = 1; | |||
ann->weight[1] = 1; | |||
lfequal(1.0, *genann_run(ann, &a)); | |||
a = -10; | |||
lfequal(0.0, *genann_run(ann, &a)); | |||
genann_free(ann); | |||
} | |||
void xor() { | |||
GENANN *ann = genann_init(2, 1, 2, 1); | |||
ann->activation_hidden = genann_act_threshold; | |||
ann->activation_output = genann_act_threshold; | |||
lequal(ann->total_weights, 9); | |||
/* First hidden. */ | |||
ann->weight[0] = .5; | |||
ann->weight[1] = 1; | |||
ann->weight[2] = 1; | |||
/* Second hidden. */ | |||
ann->weight[3] = 1; | |||
ann->weight[4] = 1; | |||
ann->weight[5] = 1; | |||
/* Output. */ | |||
ann->weight[6] = .5; | |||
ann->weight[7] = 1; | |||
ann->weight[8] = -1; | |||
double input[4][2] = {{0, 0}, {0, 1}, {1, 0}, {1, 1}}; | |||
double output[4] = {0, 1, 1, 0}; | |||
lfequal(output[0], *genann_run(ann, input[0])); | |||
lfequal(output[1], *genann_run(ann, input[1])); | |||
lfequal(output[2], *genann_run(ann, input[2])); | |||
lfequal(output[3], *genann_run(ann, input[3])); | |||
genann_free(ann); | |||
} | |||
void backprop() { | |||
GENANN *ann = genann_init(1, 0, 0, 1); | |||
double input, output; | |||
input = .5; | |||
output = 1; | |||
double first_try = *genann_run(ann, &input); | |||
genann_train(ann, &input, &output, .5); | |||
double second_try = *genann_run(ann, &input); | |||
lok(fabs(first_try - output) > fabs(second_try - output)); | |||
genann_free(ann); | |||
} | |||
void train_and() { | |||
double input[4][2] = {{0, 0}, {0, 1}, {1, 0}, {1, 1}}; | |||
double output[4] = {0, 0, 0, 1}; | |||
GENANN *ann = genann_init(2, 0, 0, 1); | |||
int i, j; | |||
for (i = 0; i < 50; ++i) { | |||
for (j = 0; j < 4; ++j) { | |||
genann_train(ann, input[j], output + j, .8); | |||
} | |||
} | |||
ann->activation_output = genann_act_threshold; | |||
lfequal(output[0], *genann_run(ann, input[0])); | |||
lfequal(output[1], *genann_run(ann, input[1])); | |||
lfequal(output[2], *genann_run(ann, input[2])); | |||
lfequal(output[3], *genann_run(ann, input[3])); | |||
genann_free(ann); | |||
} | |||
void train_or() { | |||
double input[4][2] = {{0, 0}, {0, 1}, {1, 0}, {1, 1}}; | |||
double output[4] = {0, 1, 1, 1}; | |||
GENANN *ann = genann_init(2, 0, 0, 1); | |||
genann_randomize(ann); | |||
int i, j; | |||
for (i = 0; i < 50; ++i) { | |||
for (j = 0; j < 4; ++j) { | |||
genann_train(ann, input[j], output + j, .8); | |||
} | |||
} | |||
ann->activation_output = genann_act_threshold; | |||
lfequal(output[0], *genann_run(ann, input[0])); | |||
lfequal(output[1], *genann_run(ann, input[1])); | |||
lfequal(output[2], *genann_run(ann, input[2])); | |||
lfequal(output[3], *genann_run(ann, input[3])); | |||
genann_free(ann); | |||
} | |||
void train_xor() { | |||
double input[4][2] = {{0, 0}, {0, 1}, {1, 0}, {1, 1}}; | |||
double output[4] = {0, 1, 1, 0}; | |||
GENANN *ann = genann_init(2, 1, 2, 1); | |||
int i, j; | |||
for (i = 0; i < 300; ++i) { | |||
for (j = 0; j < 4; ++j) { | |||
genann_train(ann, input[j], output + j, 3); | |||
} | |||
/* printf("%1.2f ", xor_score(ann)); */ | |||
} | |||
ann->activation_output = genann_act_threshold; | |||
lfequal(output[0], *genann_run(ann, input[0])); | |||
lfequal(output[1], *genann_run(ann, input[1])); | |||
lfequal(output[2], *genann_run(ann, input[2])); | |||
lfequal(output[3], *genann_run(ann, input[3])); | |||
genann_free(ann); | |||
} | |||
void persist() { | |||
GENANN *first = genann_init(1000, 5, 50, 10); | |||
FILE *out = fopen("persist.txt", "w"); | |||
genann_write(first, out); | |||
fclose(out); | |||
FILE *in = fopen("persist.txt", "r"); | |||
GENANN *second = genann_read(in); | |||
fclose(out); | |||
lequal(first->inputs, second->inputs); | |||
lequal(first->hidden_layers, second->hidden_layers); | |||
lequal(first->hidden, second->hidden); | |||
lequal(first->outputs, second->outputs); | |||
lequal(first->total_weights, second->total_weights); | |||
int i; | |||
for (i = 0; i < first->total_weights; ++i) { | |||
lok(first->weight[i] == second->weight[i]); | |||
} | |||
genann_free(first); | |||
genann_free(second); | |||
} | |||
void copy() { | |||
GENANN *first = genann_init(1000, 5, 50, 10); | |||
GENANN *second = genann_copy(first); | |||
lequal(first->inputs, second->inputs); | |||
lequal(first->hidden_layers, second->hidden_layers); | |||
lequal(first->hidden, second->hidden); | |||
lequal(first->outputs, second->outputs); | |||
lequal(first->total_weights, second->total_weights); | |||
int i; | |||
for (i = 0; i < first->total_weights; ++i) { | |||
lfequal(first->weight[i], second->weight[i]); | |||
} | |||
genann_free(first); | |||
genann_free(second); | |||
} | |||
void sigmoid() { | |||
double i = -20; | |||
const double max = 20; | |||
const double d = .0001; | |||
while (i < max) { | |||
lfequal(genann_act_sigmoid(i), genann_act_sigmoid_cached(i)); | |||
i += d; | |||
} | |||
} | |||
int main(int argc, char *argv[]) | |||
{ | |||
printf("GENANN TEST SUITE\n"); | |||
srand(100); | |||
lrun("basic", basic); | |||
lrun("xor", xor); | |||
lrun("backprop", backprop); | |||
lrun("train and", train_and); | |||
lrun("train or", train_or); | |||
lrun("train xor", train_xor); | |||
lrun("persist", persist); | |||
lrun("copy", copy); | |||
lrun("sigmoid", sigmoid); | |||
lresults(); | |||
return lfails != 0; | |||
} |