Adaline learning algorithm

Collaboration diagram for Adaline learning algorithm:

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.

Detailed Description

Function Documentation

adaline_activation()

int adaline_activation

(

double

x

)

Heaviside activation function

Parameters

x	activation function input

Returns

\(f(x)= \begin{cases}1 & \forall\; x > 0\\ -1 & \forall\; x \le0 \end{cases}\)

{ return x > 0 ? 1 : -1; }

adaline_fit()

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.

Parameters

[in]	ada	adaline model to train
[in]	X	array of feature vector
[in]	y	known output value for each feature vector
[in]	N	number of training samples

{
    double avg_pred_error = 1.f;
 
    int iter;
    for (iter = 0;
         (iter < MAX_ADALINE_ITER) && (avg_pred_error > ADALINE_ACCURACY);
         iter++)
    {
        avg_pred_error = 0.f;
 
        // perform fit for each sample
        for (int i = 0; i < N; i++)
        {
            double err = adaline_fit_sample(ada, X[i], y[i]);
            avg_pred_error += fabs(err);
        }
        avg_pred_error /= N;
 
        // Print updates every 200th iteration
        // if (iter % 100 == 0)
        printf("\tIter %3d: Training weights: %s\tAvg error: %.4f\n", iter,
               adaline_get_weights_str(ada), avg_pred_error);
    }
 
    if (iter < MAX_ADALINE_ITER)
        printf("Converged after %d iterations.\n", iter);
    else
        printf("Did not converged after %d iterations.\n", iter);
}

Here is the call graph for this function:

adaline_fit_sample()

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.

Parameters

[in]	ada	adaline model to fit
[in]	x	feature vector
[in]	y	known output value

Returns

correction factor

{
    /* output of the model with current weights */
    int p = adaline_predict(ada, x, NULL);
    int prediction_error = y - p;  // error in estimation
    double correction_factor = ada->eta * prediction_error;
 
    /* update each weight, the last weight is the bias term */
    for (int i = 0; i < ada->num_weights - 1; i++)
    {
        ada->weights[i] += correction_factor * x[i];
    }
    ada->weights[ada->num_weights - 1] += correction_factor;  // update bias
 
    return correction_factor;
}

Here is the call graph for this function:

adaline_get_weights_str()

char * adaline_get_weights_str

(

const struct adaline *

ada

)

Operator to print the weights of the model.

Parameters

ada	model for which the values to print

Returns

pointer to a NULL terminated string of formatted weights

{
    static char out[100];  // static so the value is persistent
 
    sprintf(out, "<");
    for (int i = 0; i < ada->num_weights; i++)
    {
        sprintf(out, "%s%.4g", out, ada->weights[i]);
        if (i < ada->num_weights - 1)
            sprintf(out, "%s, ", out);
    }
    sprintf(out, "%s>", out);
    return out;
}

adaline_predict()

int adaline_predict	(	struct adaline *	ada,
		const double *	x,
		double *	out
	)

predict the output of the model for given set of features

Parameters

[in]	ada	adaline model to predict
[in]	x	input vector
[out]	out	optional argument to return neuron output before applying activation function (NULL to ignore)

Returns

model prediction output

{
    double y = ada->weights[ada->num_weights - 1];  // assign bias value
 
    for (int i = 0; i < ada->num_weights - 1; i++) y += x[i] * ada->weights[i];
 
    if (out)  // if out variable is not NULL
        *out = y;
 
    // quantizer: apply ADALINE threshold function
    return adaline_activation(y);
}

Here is the call graph for this function:

delete_adaline()

void delete_adaline

(

struct adaline *

ada

)

delete dynamically allocated memory

Parameters

[in]

ada

model from which the memory is to be freed.

{
    if (ada == NULL)
        return;
 
    free(ada->weights);
};

new_adaline()

struct adaline new_adaline	(	const int	num_features,
		const double	eta
	)

Default constructor.

Parameters

[in]	num_features	number of features present
[in]	eta	learning rate (optional, default=0.1)

Returns

new adaline model

{
    if (eta <= 0.f || eta >= 1.f)
    {
        fprintf(stderr, "learning rate should be > 0 and < 1\n");
        exit(EXIT_FAILURE);
    }
 
    // additional weight is for the constant bias term
    int num_weights = num_features + 1;
    struct adaline ada;
    ada.eta = eta;
    ada.num_weights = num_weights;
    ada.weights = (double *)malloc(num_weights * sizeof(double));
    if (!ada.weights)
    {
        perror("Unable to allocate error for weights!");
        return ada;
    }
 
    // initialize with random weights in the range [-50, 49]
    for (int i = 0; i < num_weights; i++) ada.weights[i] = 1.f;
    // ada.weights[i] = (double)(rand() % 100) - 50);
 
    return ada;
}