Perceptron: Difference between revisions

{{trans|Python}}

 

 

T Perceptron

print(‘Trained’)

L(row) result

 

{{out}}

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi <br> or android 32 bits with application Termux}}

/* ARM assembly Raspberry PI or andoid with termux */

/* program perceptron3.s */

/***************************************************/

.include "../affichage.inc"

=={{header|Delphi}}==

{{libheader| System.SysUtils}}

{{libheader| System.UITypes}}

{{Trans|Java}}

unit main;

 

end;

 

Form settings (main.dfm)

object Form1: TForm1

ClientHeight = 360

end

end

{{out}}

[[https://ibb.co/pX7QHLS]]

{{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

Yo solo lo transcribo.<br>

I just transcribe it.

Function rnd2 As Single

Return Rnd()-Rnd()

Sleep 100

Wend

 

=={{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]]

 

 

=={{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:

=={{header|Nim}}==

{{trans|Pascal}}

 

type

train(weights, 4)

echo "Output from perceptron after 5 training runs:"

 

{{out}}

=={{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

IupClose()

end procedure

 

=={{header|Python}}==

{{header|Python 3}}

 

TRAINING_LENGTH = 2000

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|Raku}}==

{{trans|Go}}

 

use MagickWand;

$o.create( $w, $h, "white" );

$perc.draw($o);

 

=={{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

=={{header|Wren}}==

{{trans|Pascal}}

 

var rand = Random.new()

train.call(weights, 4)

System.print("Output from perceptron after 5 training runs:")

 

{{out}}

=={{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]]