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. More...

void	delete_adaline (struct adaline *ada)
	delete dynamically allocated memory More...

int	adaline_activation (double x)
	Heaviside activation function More...

char *	adaline_get_weights_str (const struct adaline *ada)
	Operator to print the weights of the model. More...

int	adaline_predict (struct adaline ada, const double x, double *out)
	predict the output of the model for given set of features More...

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. More...

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. More...

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. More...

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. More...

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. More...

int	main (int argc, char **argv)
	Main function. More...

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:

Data Structures

Macros

Functions

Detailed Description

Function Documentation

◆ main()

◆ test1()

◆ test2()

◆ test3()