Code viewer for World: test2

// Cloned by Abdelshafa Abdala on 15 Nov 2021 from World "Character recognition neural network Practical 2" by Pratiksha Biradar 
// Please leave this clone trail here.
 
const PIXELS=28,
PIXELSSQUARED=PIXELS*PIXELS,

NOTRAIN=6e4,
NOTEST=1e4,


noinput=PIXELSSQUARED,
nohidden=64,
nooutput=10,

learningrate=.1;

let do_training=!0;

const TRAINPERSTEP=50,
TESTPERSTEP=5,

ZOOMFACTOR=5,
ZOOMPIXELS=5*PIXELS,

canvaswidth=PIXELS+ZOOMPIXELS+50,
canvasheight=3*ZOOMPIXELS+100,


DOODLE_THICK=14,
DOODLE_BLUR=2;

let mnist,nn,

doodle,demo,
nnType=1,
trainrun=1,
train_index=0,

testrun=1,
test_index=0,
total_tests=0,
total_correct=0,
doodle_exists=!1,
demo_exists=!1,

mousedrag=!1;

var train_inputs,test_inputs,demo_inputs,doodle_inputs,thehtml;
function randomWeight()
{
    return AB.randomFloatAtoB(-.5,.5)}$("#runheaderbox").css({"max-height":"95vh"}),
    thehtml=" <button id='save' onclick='saveData();' class='normbutton mybutton' >Save work</button> ",
    AB.msg(thehtml,1),
    
    thehtml="<hr> <h1> 1. Doodle </h1> Top row: Doodle (left) and shrunk (right). <br>  Draw your doodle in top LHS. <button onclick='wipeDoodle();' class='normbutton' >Clear doodle</button> <br> ",
    AB.msg(thehtml,2),
    
    thehtml="<hr> <h1> 2. Training </h1> Middle row: Training image magnified (left) and original (right). <br>   <button onclick='do_training = false;' class='normbutton' >Stop training</button> <br> ",
    AB.msg(thehtml,4),
    
    thehtml="<h3> Hidden tests </h3> ",
    AB.msg(thehtml,6),
    
    thehtml="<hr> <h1> 3. Demo </h1> Bottom row: Test image magnified (left) and  original (right). <br> The network is <i>not</i> trained on any of these images. <br>  <button onclick='makeDemo();' class='normbutton' >Demo test image</button> <br> ",
    AB.msg(thehtml,8);
    
    const greenspan="<span style='font-weight:bold; font-size:x-large; color:darkgreen'> ";
    
    function setup()
    {
        createCanvas(canvaswidth,canvasheight),
        
        (
            doodle=createGraphics(ZOOMPIXELS,ZOOMPIXELS)).
            pixelDensity(1),
            
            
            AB.loadingScreen(),
            $.getScript("/uploads/codingtrain/matrix.js",function()
            {
                $.getScript("/uploads/biradap2/nn.js",function()
                
                {
                    $.getScript("/uploads/codingtrain/mnist.js",function()
                    {
                        $.getJSON("/uploads/biradap2/_data.0646079000.json",function(t)
                        {
                            console.log("All JS loaded"),
                            1===nnType?(nn=NeuralNetwork.deserialize(t),
                            
                            console.log("Activation function used here is: "+nn.getActivationFunction()),
                            console.log("Sigmoid function with loaded json")):2===nnType?(nn=new NeuralNetwork(noinput,nohidden,nooutput,learningrate,tanh),
                            console.log("Tanh function is used without loaded json")):
                            3===nnType?
                            (
                                nn=new NeuralNetwork(noinput,nohidden,nooutput,learningrate,sigmoid),
                                console.log("Activation function used here is: "+nn.getActivationFunction()),
                                console.log("Loading Default Neural Network")):
                                4===nnType?(nn=new NeuralNetwork(noinput,nohidden,nooutput,learningrate,relu),
                                console.log("Relu function is used without loaded json")):
                                console.log("No neural network has been specified"),loadData()})})})})}
                                
                                function saveData()
                                {
                                    AB.saveData(nn)
                                    
                                }
                                
                                function restoreData()
                                
                                {
                                    AB.restoreData
                                    
                                    (
                                        function(t)
                                        
                                        {
                                            nn=NeuralNetwork.deserialize(t),loadData(),
                                            
                                            console.log
                                            (
                                                "AB.restoredata"+NeuralNetwork.deserialize(t).serialize())})}
                                                
                                                function loadData()
                                                
                                                {
                                                    loadMNIST
                                                    
                                                    (
                                                        function(t)
                                                        
                                                        {
                                                            mnist=t,
                                                            
                                                            console.log("All data loaded into mnist object:"),
                                                            
                                                            console.log(mnist),
                                                            
                                                            AB.removeLoading()})}
                                                            
                                                            function getImage(t)
                                                            
                                                            {
                                                                
                                                                let e=createImage(PIXELS,PIXELS);e.loadPixels();
                                                                
                                                                for
                                                                (
                                                                    let n=0;
                                                                    n<PIXELSSQUARED;n++
                                                                    
                                                                    )
                                                                    
                                                                    {
                                                                        let o=t[n]
                                                                        
                                                                        i=4*n;
                                                                        e.pixels[i+0]=o,
                                                                        
                                                                        e.pixels[i+1]=o,
                                                                        e.pixels[i+2]=o,
                                                                        e.pixels[i+3]=255
                                                                        
                                                                    }
                                                                    return 
                                                                    
                                                                    e.updatePixels(),
                                                                    e
                                                                
                                                            }
                                                            function getInputs(t)
                                                            
                                                            {let e=[];
                                                            for
                                                            
                                                            (
                                                                let n=0;
                                                                
                                                                n<PIXELSSQUARED;n++
                                                                
                                                                )
                                                                {
                                                                    let o=t[n];
                                                                    
                                                                    e[n]=o/255
                                                                    
                                                                }
                                                                return 
                                                                
                                                                e
                                                                
                                                            }
                                                            
                                                            function trainit(t)
                                                            
                                                            {
                                                                let e=mnist.train_images[train_index],
                                                                n=mnist.train_labels[train_index];
                                                                
                                                                if(t)
                                                                {
                                                                    var
                                                                    
                                                                    o=getImage(e);
                                                                    
                                                                    image(o,0,ZOOMPIXELS+50,ZOOMPIXELS,ZOOMPIXELS),
                                                                    image(o,ZOOMPIXELS+50,ZOOMPIXELS+50,PIXELS,PIXELS)}
                                                                    let i=getInputs(e),
                                                                    
                                                                    s=[0,0,0,0,0,0,0,0,0,0];
                                                                    s[n]=1,
                                                                    train_inputs=i,
                                                                    nn.train(i,s),
                                                                    thehtml=" trainrun: "+trainrun+"<br> no: "+train_index,
                                                                    AB.msg(thehtml,5),
                                                                    ++train_index==NOTRAIN&&(train_index=0,
                                                                    console.log("finished trainrun: "+trainrun),trainrun++)
                                                                
                                                            }
                                                            
                                                            function testit()
                                                            
                                                            {
                                                                let t=mnist.test_images[test_index],
                                                                e=mnist.test_labels[test_index],
                                                                n=getInputs(t);
                                                                test_inputs=n;
                                                                
                                                                let o=findMax(nn.predict(n));
                                                                total_tests++,
                                                                o==e&&total_correct++;
                                                                let 
                                                                i=total_correct/total_tests*100;
                                                                thehtml=" testrun: "+testrun+"<br> no: "+total_tests+" <br>  correct: "+total_correct+"<br>  score: "+greenspan+i.toFixed(2)+"</span>",AB.msg(thehtml,7),++test_index==NOTEST&&
                                                                (
                                                                    console.log
                                                                    (
                                                                        "finished testrun: "+testrun+" score: "+i.toFixed(2)),
                                                                        testrun++,test_index=0,
                                                                        total_tests=0,
                                                                        total_correct=0
                                                                        )
                                                                
                                                            }
                                                            function find12(t)
                                                            {
                                                                let 
                                                                e=0,
                                                                n=0,
                                                                o=0,
                                                                i=0;
                                                                
                                                                
                                                                 let s = 0;          
                                                                    
                                                                    s<t.length;
                                                                    s++)t[s]>o?(e=s,o=t[s]);
                                                                    t[s]>i&&(n=s,i=t[s]);
                                                                   
                                                                       
                                                                    
                                                                    return[e,n];
                                                                
                                                            }
                                                            function findMax(t)
                                                            {
                                                                let e=0,
                                                                n=0;
                                                                for
                                                                (
                                                                    let 
                                                                    o=0;
                                                                    o<t.length;o++)t[o]>n&&(e=o,n=t[o]);
                                                                    
                                                                    return 
                                                                    e
                                                                
                                                            }
                                                            function draw()
                                                            {
                                                                if
                                                                (
                                                                    void 0!==mnist
                                                                    )
                                                                    {
                                                                        if(
                                                                            background("yellow"),
                                                                            do_training)
                                                                            {
                                                                                for
                                                                                (
                                                                                    let
                                                                                    t=0;
                                                                                    t<TRAINPERSTEP;
                                                                                    t++)trainit(0==t);
                                                                                    for
                                                                                    (
                                                                                        let 
                                                                                        t=0;
                                                                                        t<TESTPERSTEP;
                                                                                        t++)testit()}
                                                                                        if
                                                                                        (
                                                                                            demo_exists&&(drawDemo(),
                                                                                            guessDemo()),
                                                                                            doodle_exists&&(drawDoodle(),
                                                                                            guessDoodle()),
                                                                                            mouseIsPressed)
                                                                                            {
                                                                                                var
                                                                                                t=ZOOMPIXELS+20;
                                                                                                mouseX<t&&mouseY<t&&
                                                                                                pmouseX<t&&pmouseY<t&&(
                                                                                                    mousedrag=!0,
                                                                                                    doodle_exists=!0,
                                                                                                    doodle.stroke("white"),
                                                                                                    doodle.smooth(),
                                                                                                    doodle.strokeWeight
                                                                                                    (DOODLE_THICK),
                                                                                                    doodle.line
                                                                                                    (
                                                                                                        mouseX,mouseY,pmouseX,pmouseY))
                                                                                                
                                                                                            }
                                                                                            else mousedrag&&(mousedrag=!1,doodle.filter(BLUR,DOODLE_BLUR))}}
                                                                                            
                                                                                            function makeDemo()
                                                                                            {
                                                                                                demo_exists=!0;
                                                                                                var 
                                                                                                t=AB.randomIntAtoB(0,NOTEST-1);
                                                                                                demo=mnist.test_images[t];
                                                                                                var e=mnist.test_labels[t];
                                                                                                thehtml="Test image no: "+t+"<br>Classification: "+e+"<br>",
                                                                                                AB.msg(thehtml,9)}
                                                                                                
                                                                                                function drawDemo()
                                                                                                {
                                                                                                    var
                                                                                                    t=getImage(demo);
                                                                                                    image(t,0,canvasheight-ZOOMPIXELS,ZOOMPIXELS,ZOOMPIXELS),
                                                                                                    image(t,ZOOMPIXELS+50,canvasheight-ZOOMPIXELS,PIXELS,PIXELS)}
                                                                                                    function 
                                                                                                    guessDemo()
                                                                                                    {
                                                                                                        let t=getInputs(demo);demo_inputs=t;
                                                                                                        let e=findMax(nn.predict(t));thehtml=" We classify it as: "+greenspan+e+"</span>",AB.msg(thehtml,10)}
                                                                                                        function drawDoodle()
                                                                                                        {
                                                                                                            let t=doodle.get();
                                                                                                            image(t,0,0,ZOOMPIXELS,ZOOMPIXELS),
                                                                                                            image(t,ZOOMPIXELS+50,0,PIXELS,PIXELS)}
                                                                                                            function guessDoodle()
                                                                                                            {
                                                                                                                let t=doodle.get();t.resize(PIXELS,PIXELS),t.loadPixels();
                                                                                                                let e=[];
                                                                                                                for
                                                                                                                let n = 0;
                                                                                                                n<PIXELSSQUARED;
                                                                                                                
                                                                                                                
                                                                                                                n++)e[n]=t.pixels[4*n]/255;
                                                                                                                doodle_inputs=e;
                                                                                                                let n=find12(nn.predict(e));
                                                                                                                thehtml=" We classify it as: "+greenspan+n[0]+"</span> <br> No.2 guess is: "+greenspan+n[1]+"</span>",
                                                                                                                AB.msg(thehtml,3)}
                                                                                                                
                                                                                                                function wipeDoodle(){doodle_exists=!1,doodle.background("black")}
                                                                                                                function showInputs(t){
                                                                                                                    var e="";
                                                                                                                    for
                                                                                                                    (
                                                                                                                        let n=0;n<t.length;n++){n%PIXELS==0&&(e+="\n"),e=e+" "+t[n].toFixed(2)}
                                                                                                                        console.log(e)}