NAME AI::Perceptron - example of a node in a neural network. SYNOPSIS use AI::Perceptron; my $p = AI::Perceptron->new ->num_inputs( 2 ) ->learning_rate( 0.04 ) ->threshold( 0.02 ) ->weights([ 0.1, 0.2 ]); my @inputs = ( 1.3, -0.45 ); # input can be any number my $target = 1; # output is always -1 or 1 my $current = $p->compute_output( @inputs ); print "current output: $current, target: $target\n"; $p->add_examples( [ $target, @inputs ] ); $p->max_iterations( 10 )->train or warn "couldn't train in 10 iterations!"; print "training until it gets it right\n"; $p->max_iterations( -1 )->train; # watch out for infinite loops DESCRIPTION This module is meant to show how a single node of a neural network works. Training is done by the *Stochastic Approximation of the Gradient-Descent* model. MODEL Model of a Perceptron +---------------+ X[1] o------ |W[1] T | X[2] o------ |W[2] +---------+ +-------------------+ . | . | ___ |_________| __ Squarewave |_______\ Output . | . | \ | S | __| Generator | / . | . | /__ | +-------------------+ X[n] o------ |W[n] | Sum | +-----+---------+ S = T + Sum( W[i]*X[i] ) as i goes from 1 -> n Output = 1 if S > 0; else -1 Where "X[n]" are the perceptron's *inputs*, "W[n]" are the *Weights* that get applied to the corresponding input, and "T" is the *Threshold*. The *squarewave generator* just turns the result into a positive or negative number. So in summary, when you feed the perceptron some numeric inputs you get either a positive or negative output depending on the input's weights and a threshold. TRAINING Usually you have to train a perceptron before it will give you the outputs you expect. This is done by giving the perceptron a set of examples containing the output you want for some given inputs: -1 => -1, -1 -1 => 1, -1 -1 => -1, 1 1 => 1, 1 If you've ever studied boolean logic, you should recognize that as the truth table for an "AND" gate (ok so we're using -1 instead of the commonly used 0, same thing really). You *train* the perceptron by iterating over the examples and adjusting the *weights* and *threshold* by some value until the perceptron's output matches the expected output of each example: while some examples are incorrectly classified update weights for each example that fails The value each weight is adjusted by is calculated as follows: delta[i] = learning_rate * (expected_output - output) * input[i] Which is know as a negative feedback loop - it uses the current output as an input to determine what the next output will be. Also, note that this means you can get stuck in an infinite loop. It's not a bad idea to set the maximum number of iterations to prevent that. CONSTRUCTOR new( [%args] ) Creates a new perceptron with the following default properties: num_inputs = 1 learning_rate = 0.01 threshold = 0.0 weights = empty list Ideally you should use the accessors to set the properties, but for backwards compatability you can still use the following arguments: Inputs => $number_of_inputs (positive int) N => $learning_rate (float) W => [ @weights ] (floats) The number of elements in *W* must be equal to the number of inputs plus one. This is because older version of AI::Perceptron combined the threshold and the weights a single list where W[0] was the threshold and W[1] was the first weight. Great idea, eh? :) That's why it's *DEPRECATED*. ACCESSORS num_inputs( [ $int ] ) Set/get the perceptron's number of inputs. learning_rate( [ $float ] ) Set/get the perceptron's number of inputs. weights( [ \@weights ] ) Set/get the perceptron's weights (floats). For backwards compatability, returns a list containing the *threshold* as the first element in list context: ($threshold, @weights) = $p->weights; This usage is *DEPRECATED*. threshold( [ $float ] ) Set/get the perceptron's number of inputs. training_examples( [ \@examples ] ) Set/get the perceptron's list of training examples. This should be a list of arrayrefs of the form: [ $expected_result => @inputs ] max_iterations( [ $int ] ) Set/get the perceptron's number of inputs, a negative value implies no maximum. METHODS compute_output( @inputs ) Computes and returns the perceptron's output (either -1 or 1) for the given inputs. See the above model for more details. add_examples( @training_examples ) Adds the @training_examples to to current list of examples. See training_examples() for more details. train( [ @training_examples ] ) Uses the *Stochastic Approximation of the Gradient-Descent* model to adjust the perceptron's weights until all training examples are classified correctly. @training_examples can be passed for convenience. These are passed to add_examples(). If you want to re-train the perceptron with an entirely new set of examples, reset the training_examples(). AUTHOR Steve Purkis COPYRIGHT Copyright (c) 1999-2003 Steve Purkis. All rights reserved. This package is free software; you can redistribute it and/or modify it under the same terms as Perl itself. REFERENCES *Machine Learning*, by Tom M. Mitchell. THANKS Himanshu Garg for his bug-report and feedback. Many others for their feedback. SEE ALSO Statistics::LTU, AI::jNeural, AI::NeuralNet::BackProp, AI::NeuralNet::Kohonen