Perceptron: Difference between revisions

* [https://youtu.be/dXuNAkHsos4?t=16m44s Machine Learning - Perceptrons (youtube)]

<br><br>

 

=={{header|Forth}}==

{{works with|GNU Forth}}

Where it says <code>[email protected]</code> it should say <code>f&#64;</code>.

here seed !

 

500 timesTrain evaluate ;

 

Example output:

<pre>After 0 trainings: 10.16 % accurate

After 500 trainings: 95.86 % accurate

After 1000 trainings: 99.8 % accurate</pre>

 

=={{header|Go}}==

<br>

This is based on the Java entry but just outputs the final image (as a .png file) rather than displaying its gradual build up. It also uses a different color scheme - blue and red circles with a black dividing line.

 

import (

perc.draw(dc, 2000)

dc.SavePNG("perceptron.png")

 

=={{header|Java}}==

{{works with|Java|8}}

import java.awt.event.ActionEvent;

import java.util.*;

});

}

 

=={{header|JavaScript}}==

Uses P5 lib.

const EPOCH = 1500, TRAINING = 1, TRANSITION = 2, SHOW = 3;

 

}

}

[[File:perceptronJS.png]]

 

Well, it seems I cannot upload an image :(

 

=={{header|Julia}}==

 

module SimplePerceptrons

 

end # module SimplePerceptrons

 

 

const SP = include("module.jl")

ahat, bhat = p.weights[1] / p.weights[2], -p.weights[3] / p.weights[2]

Plots.abline!(bhat, ahat, label = "predicted line")

 

=={{header|Kotlin}}==

{{trans|Java}}

 

import java.awt.*

}

}

 

=={{header|Lua}}==

Simple implementation allowing for any number of inputs (in this case, just 1), testing of the Perceptron, and training.

Perceptron.__index = Perceptron

 

print(i..":", node:test({i}))

end

{{out}}

<pre>Untrained results:

2: 5

</pre>

 

=={{header|Pascal}}==

This is a text-based implementation, using a 20x20 grid (just like the original Mark 1 Perceptron had). The rate of improvement drops quite markedly as you increase the number of training runs.

 

(*

writeln( 'Output from perceptron after 5 training runs:' );

showOutput( weights )

{{out}}

<pre>Target output for the function f(x) = 2x + 1:

learning rate, and max iterations. Plots accuracy vs. iterations and displays the training data

in blue/black=above/incorrect and green/red=below/incorrect [all blue/green = 100% accurate].

--

-- The learning curve turned out more haphazard than I imagined, and adding a

end procedure

function draw(bool bDraw=true)

-- (if bDraw is false, we just want the "correct" count)

IupClose()

end procedure

=={{header|Python}}==

{{header|Python 3}}

 

TRAINING_LENGTH = 2000

 

def feed_forward(self, inputs):

for i in range(len(inputs)):

 

def activate(self, value):

print('Trained')

for row in result:

{{out}}

<pre>

=={{header|Racket}}==

{{trans|Java}}

(require 2htdp/universe

2htdp/image)

(big-bang the-demo (to-draw draw-demo) (on-tick tick-handler)))

 

Run it and see the image for yourself, I can't get it onto RC!

 

=={{header|REXX}}==

{{trans|Java}}

Call init

Call time 'R'

y.i=nextDouble()*height

End

{{out}}

<pre>Point x f(x) r y ff ok zz

=={{header|Scala}}==

===Java Swing Interoperability===

import java.awt.event.ActionEvent

 

})

 

 

=={{header|Scheme}}==

(scheme case-lambda)

(scheme write)

", percent correct is "

(number->string (perceptron 'test test-set))

{{out}}

<pre>#(-0.5914540100624854 1.073343782042039 -0.29780862758499393)

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

 

activate

]

 

Example output:

<pre>After 0 trainings: 14.158 % accuracy

After 500 trainings: 99.777 % accuracy

After 1000 trainings: 98.523 % accuracy</pre>

 

=={{header|XLISP}}==

Like the Pascal example, this is a text-based program using a 20x20 grid. It is slightly more general, however, because it allows the function that is to be learnt and the perceptron's bias and learning constant to be passed as arguments to the <tt>trainer</tt> and <tt>perceptron</tt> objects.

(instance-variables weights bias learning-constant) )

(define-method (perceptron 'initialize b lc)

(newline)

(ptron 'learn training 4)

{{out}}

<pre>Target output for y = 2x + 1:

{{trans|Java}}

Uses the PPM class from http://rosettacode.org/wiki/Bitmap/Bresenham%27s_line_algorithm#zkl

const c=0.00001;

var [const] W=640, H=350;

foreach i in (weights.len()){ weights[i]+=c*error*xy1a[i] }

}

p.training.apply2(p.train);

 

pixmap.circle(x,y,8,color);

}

{{out}}

[[File:Perceptron.zkl.jpg]]