Adaline Program in C

ADALINE stands for Adaptive Linear Neuron and is an artificial neural network model that was first introduced by Bernard Widrow and Ted Hoff in 1960. It is a single-layer neural network that can be used for binary classification problems, and it is considered one of the earliest models of artificial neural networks. In an ADALINE network, there is a single artificial neuron that receives inputs from multiple features, computes a linear combination of these inputs, and outputs the result. The weights of the inputs are adjusted during the training process to minimize the error between the actual and predicted outputs.

The training process in an ADALINE network is based on the gradient descent algorithm, where the weights are updated in the direction of the negative gradient of the cost function. The cost function is a measure of the difference between the predicted and actual outputs, and the objective is to minimize this difference. In the case of binary classification problems, the most commonly used cost function is the mean squared error.

The output of the ADALINE neuron is calculated using the following formula:

where w_0, w_1, w_2, ..., w_n are the weights of the inputs, x_1, x_2, ..., x_n are the inputs, and y is the output of the neuron.

Once the outputs are calculated, the weights are updated using the following formula:

where ? is the learning rate, d_j is the desired output, y is the actual output, and x_j is the input associated with weight w_j. The weights are updated for each training sample until the error between the predicted and actual outputs is minimized. One of the key advantages of ADALINE over other artificial neural network models is that it is simple and computationally efficient, making it ideal for problems with small amounts of data or limited computational resources. Additionally, because the ADALINE model only has a single layer of artificial neurons, it is relatively easy to understand and interpret the weights of the inputs.

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#define NUM_INPUTS 2
#define NUM_SAMPLES 4
#define MAX_EPOCHS 100
#define LEARNING_RATE 0.1

double inputs[NUM_SAMPLES][NUM_INPUTS+1] = {{1, 0, 0}, {1, 0, 1}, {1, 1, 0}, {1, 1, 1}};
double expected_outputs[NUM_SAMPLES] = {0, 1, 1, 0};
double dot_product(double weights[], double inputs[], int num_inputs) {
    double sum = 0.0;
    int i;
    for (i = 0; i < num_inputs; i++) {
        sum += weights[i] * inputs[i];
    }
    return sum;
}

double activation_function(double dot_product) {
    return dot_product;
}

double calculate_error(double expected, double actual) {
    return expected - actual;
}

void train(double inputs[][NUM_INPUTS+1], double expected_outputs[], double weights[], int num_inputs, int num_samples) {
    int i, j, epoch;
    double dot_product_value, actual_output, error;
    for (epoch = 0; epoch < MAX_EPOCHS; epoch++) {
        for (i = 0; i < num_samples; i++) {
            dot_product_value = dot_product(weights, inputs[i], num_inputs);
            actual_output = activation_function(dot_product_value);
            error = calculate_error(expected_outputs[i], actual_output);
            for (j = 0; j < num_inputs; j++) {
                weights[j] = weights[j] + LEARNING_RATE * error * inputs[i][j];
            }
        }
    }
}

int main() {
    double weights[NUM_INPUTS] = {0.0, 0.0, 0.0};
    int i, j;
    train(inputs, expected_outputs, weights, NUM_INPUTS, NUM_SAMPLES);
    for (i = 0; i < NUM_SAMPLES; i++) {
        double dot_product_value = dot_product(weights, inputs[i], NUM_INPUTS);
        double actual_output = activation_function(dot_product_value);
        printf("Inputs: ");
        for (j = 0; j < NUM_INPUTs; j++) {
            printf("%f ", inputs[i][j]);
        }
        printf("\n");
        printf("Expected output: %f\n", expected_outputs[i]);
        printf("Actual output: %f\n", actual_output);
        printf("\n");
    }
    return 0;
}

Output:

Inputs: 1.000000 0.000000 0.000000
Expected output: 0.000000

Explanation:

However, one of the major limitations of the ADALINE model is that it can only be used for linear problems. In other words, it is not capable of solving non-linear problems, which limits its applicability in a wide range of real-world problems. To address this limitation, the ADALINE model was later extended to include multiple layers of artificial neurons, leading to the development of multi-layer perceptron (MLP) networks. In conclusion, the ADALINE model is a simple and efficient artificial neural network that can be used for binary classification problems. Although it has limitations, it remains an important model in the history of artificial neural networks and has influenced the development of more complex models.

Next TopicAdam Number in C Program

← prev next →