Perceptron Training Algorithm

# Create a data set that we want to train on. For this example
# we want to train on an AND boolean function.
and_training_set = []
and_training_set.append([1, 1])
and_training_set.append([1, 0])
and_training_set.append([0, 1])
and_training_set.append([0, 0])
and_labels = [1, 0, 0, 0]

learning_rate = 0.1

def predict(inputs, weights):
    # This multiplies each input but its appropriate weight and sums
    # them up. The bias weight is special because it's "input" is
    # always 1, so it is directly added to the list.
    val = sum([a*b for a,b in zip(inputs, weights[1:])]) + weights[0]

    # Finally, return the activation value as a Boolean value
    return 1 if val >= 0 else 0

def train(input_data, labels):
    # There is a weight for value in the input vector
    # plus one for the bias. We initialize the weights
    # to 0 for each value.
    weights = [0] * (len(and_training_set[0]) + 1)

    # Then randomly select inputs, update the weights if the output
    # was incorrect. We continue this procedure until all values are
    # classified correctly. Since we want to select randomly, and
    # input data is already random, we can just iterate over our
    # inputs until correctly classified.

    converged = False
    while not converged:
        # Iterate over all the samples - if we find any that is
        # not correct, then we set converged to False so we will
        # try again
        converged = True

        # Create pairs of the inputs and the label for that input vector
        # and iterate over the entire set.
        for inputs, label in zip(input_data, labels):
            prediction = predict (inputs, weights)

            if prediction != label:
                # If the prediction wasn't correct, then we have not yet
                # converged and will need to iterate again
                converged = False

                error = learning_rate * (label - prediction)

                # As per the algorithm, we also update our weights based
                # on the inputs and our prediction. To make this easy in Python
                # make an array with the bias and inputs. The bias goes first
                # since we have defined our first weight to be for the bias
                bias_inputs = [1] + inputs
                # Combine that with the weights that we just used
                weights = [(weight + error * input_val) for (weight, input_val) in zip(weights, bias_inputs)]

    return weights

weights = train(and_training_set, and_labels)

# Finally, we can use the weights to make predictions
prediction = predict([1, 0], weights)