adaline_learning.c File Reference

Adaptive Linear Neuron (ADALINE) implementation More...

#include <assert.h>
#include <limits.h>
#include <math.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

Include dependency graph for adaline_learning.c:

Data Structures
struct	adaline
	structure to hold adaline model parameters More...

Macros
#define	MAX_ADALINE_ITER   500
	Maximum number of iterations to learn.
#define	ADALINE_ACCURACY   1e-5
	convergence accuracy \(=1\times10^{-5}\)

Functions
struct adaline	new_adaline (const int num_features, const double eta)
	Default constructor.
void	delete_adaline (struct adaline *ada)
	delete dynamically allocated memory
int	adaline_activation (double x)
	Heaviside activation function
char *	adaline_get_weights_str (const struct adaline *ada)
	Operator to print the weights of the model.
int	adaline_predict (struct adaline *ada, const double *x, double *out)
	predict the output of the model for given set of features
double	adaline_fit_sample (struct adaline *ada, const double *x, const int y)
	Update the weights of the model using supervised learning for one feature vector.
void	adaline_fit (struct adaline *ada, double **X, const int *y, const int N)
	Update the weights of the model using supervised learning for an array of vectors.
void	test1 (double eta)
	test function to predict points in a 2D coordinate system above the line \(x=y\) as +1 and others as -1.
void	test2 (double eta)
	test function to predict points in a 2D coordinate system above the line \(x+3y=-1\) as +1 and others as -1.
void	test3 (double eta)
	test function to predict points in a 3D coordinate system lying within the sphere of radius 1 and centre at origin as +1 and others as -1.
int	main (int argc, char **argv)
	Main function.

Detailed Description

Adaptive Linear Neuron (ADALINE) implementation

source ADALINE is one of the first and simplest single layer artificial neural network. The algorithm essentially implements a linear function

\[ f\left(x_0,x_1,x_2,\ldots\right) = \sum_j x_jw_j+\theta \]

where \(x_j\) are the input features of a sample, \(w_j\) are the coefficients of the linear function and \(\theta\) is a constant. If we know the \(w_j\), then for any given set of features, \(y\) can be computed. Computing the \(w_j\) is a supervised learning algorithm wherein a set of features and their corresponding outputs are given and weights are computed using stochastic gradient descent method.

Author

Krishna Vedala

Function Documentation

main()

int main	(	int	argc,
		char **	argv
	)

Main function.

{
    srand(time(NULL));  // initialize random number generator
 
    double eta = 0.1;  // default value of eta
    if (argc == 2)     // read eta value from commandline argument if present
        eta = strtof(argv[1], NULL);
 
    test1(eta);
 
    printf("Press ENTER to continue...\n");
    getchar();
 
    test2(eta);
 
    printf("Press ENTER to continue...\n");
    getchar();
 
    test3(eta);
 
    return 0;
}

Here is the call graph for this function:

test1()

void test1

(

double

eta

)

test function to predict points in a 2D coordinate system above the line \(x=y\) as +1 and others as -1.

Note that each point is defined by 2 values or 2 features.

Parameters

[in]

eta

learning rate (optional, default=0.01)

{
    struct adaline ada = new_adaline(2, eta);  // 2 features
 
    const int N = 10;  // number of sample points
    const double saved_X[10][2] = {{0, 1},  {1, -2},   {2, 3},   {3, -1},
                                   {4, 1},  {6, -5},   {-7, -3}, {-8, 5},
                                   {-9, 2}, {-10, -15}};
 
    double **X = (double **)malloc(N * sizeof(double *));
    const int Y[10] = {1,  -1, 1, -1, -1,
                       -1, 1,  1, 1,  -1};  // corresponding y-values
    for (int i = 0; i < N; i++)
    {
        X[i] = (double *)saved_X[i];
    }
 
    printf("------- Test 1 -------\n");
    printf("Model before fit: %s\n", adaline_get_weights_str(&ada));
 
    adaline_fit(&ada, X, Y, N);
    printf("Model after fit: %s\n", adaline_get_weights_str(&ada));
 
    double test_x[] = {5, -3};
    int pred = adaline_predict(&ada, test_x, NULL);
    printf("Predict for x=(5,-3): % d\n", pred);
    assert(pred == -1);
    printf(" ...passed\n");
 
    double test_x2[] = {5, 8};
    pred = adaline_predict(&ada, test_x2, NULL);
    printf("Predict for x=(5, 8): % d\n", pred);
    assert(pred == 1);
    printf(" ...passed\n");
 
    // for (int i = 0; i < N; i++)
    //     free(X[i]);
    free(X);
    delete_adaline(&ada);
}

Here is the call graph for this function:

test2()

void test2

(

double

eta

)

test function to predict points in a 2D coordinate system above the line \(x+3y=-1\) as +1 and others as -1.

Note that each point is defined by 2 values or 2 features. The function will create random sample points for training and test purposes.

Parameters

[in]

eta

learning rate (optional, default=0.01)

{
    struct adaline ada = new_adaline(2, eta);  // 2 features
 
    const int N = 50;  // number of sample points
 
    double **X = (double **)malloc(N * sizeof(double *));
    int *Y = (int *)malloc(N * sizeof(int));  // corresponding y-values
    for (int i = 0; i < N; i++) X[i] = (double *)malloc(2 * sizeof(double));
 
    // generate sample points in the interval
    // [-range2/100 , (range2-1)/100]
    int range = 500;          // sample points full-range
    int range2 = range >> 1;  // sample points half-range
    for (int i = 0; i < N; i++)
    {
        double x0 = ((rand() % range) - range2) / 100.f;
        double x1 = ((rand() % range) - range2) / 100.f;
        X[i][0] = x0;
        X[i][1] = x1;
        Y[i] = (x0 + 3. * x1) > -1 ? 1 : -1;
    }
 
    printf("------- Test 2 -------\n");
    printf("Model before fit: %s\n", adaline_get_weights_str(&ada));
 
    adaline_fit(&ada, X, Y, N);
    printf("Model after fit: %s\n", adaline_get_weights_str(&ada));
 
    int N_test_cases = 5;
    double test_x[2];
    for (int i = 0; i < N_test_cases; i++)
    {
        double x0 = ((rand() % range) - range2) / 100.f;
        double x1 = ((rand() % range) - range2) / 100.f;
 
        test_x[0] = x0;
        test_x[1] = x1;
        int pred = adaline_predict(&ada, test_x, NULL);
        printf("Predict for x=(% 3.2f,% 3.2f): % d\n", x0, x1, pred);
 
        int expected_val = (x0 + 3. * x1) > -1 ? 1 : -1;
        assert(pred == expected_val);
        printf(" ...passed\n");
    }
 
    for (int i = 0; i < N; i++) free(X[i]);
    free(X);
    free(Y);
    delete_adaline(&ada);
}

Here is the call graph for this function:

test3()

void test3

(

double

eta

)

test function to predict points in a 3D coordinate system lying within the sphere of radius 1 and centre at origin as +1 and others as -1.

Note that each point is defined by 3 values but we use 6 features. The function will create random sample points for training and test purposes. The sphere centred at origin and radius 1 is defined as: \(x^2+y^2+z^2=r^2=1\) and if the \(r^2<1\), point lies within the sphere else, outside.

Parameters

[in]

eta

learning rate (optional, default=0.01)

{
    struct adaline ada = new_adaline(6, eta);  // 2 features
 
    const int N = 50;  // number of sample points
 
    double **X = (double **)malloc(N * sizeof(double *));
    int *Y = (int *)malloc(N * sizeof(int));  // corresponding y-values
    for (int i = 0; i < N; i++) X[i] = (double *)malloc(6 * sizeof(double));
 
    // generate sample points in the interval
    // [-range2/100 , (range2-1)/100]
    int range = 200;          // sample points full-range
    int range2 = range >> 1;  // sample points half-range
    for (int i = 0; i < N; i++)
    {
        double x0 = ((rand() % range) - range2) / 100.f;
        double x1 = ((rand() % range) - range2) / 100.f;
        double x2 = ((rand() % range) - range2) / 100.f;
        X[i][0] = x0;
        X[i][1] = x1;
        X[i][2] = x2;
        X[i][3] = x0 * x0;
        X[i][4] = x1 * x1;
        X[i][5] = x2 * x2;
        Y[i] = (x0 * x0 + x1 * x1 + x2 * x2) <= 1 ? 1 : -1;
    }
 
    printf("------- Test 3 -------\n");
    printf("Model before fit: %s\n", adaline_get_weights_str(&ada));
 
    adaline_fit(&ada, X, Y, N);
    printf("Model after fit: %s\n", adaline_get_weights_str(&ada));
 
    int N_test_cases = 5;
    double test_x[6];
    for (int i = 0; i < N_test_cases; i++)
    {
        double x0 = ((rand() % range) - range2) / 100.f;
        double x1 = ((rand() % range) - range2) / 100.f;
        double x2 = ((rand() % range) - range2) / 100.f;
        test_x[0] = x0;
        test_x[1] = x1;
        test_x[2] = x2;
        test_x[3] = x0 * x0;
        test_x[4] = x1 * x1;
        test_x[5] = x2 * x2;
        int pred = adaline_predict(&ada, test_x, NULL);
        printf("Predict for x=(% 3.2f,% 3.2f): % d\n", x0, x1, pred);
 
        int expected_val = (x0 * x0 + x1 * x1 + x2 * x2) <= 1 ? 1 : -1;
        assert(pred == expected_val);
        printf(" ...passed\n");
    }
 
    for (int i = 0; i < N; i++) free(X[i]);
    free(X);
    free(Y);
    delete_adaline(&ada);
}

Here is the call graph for this function: