fnn revisions, add Japanese alias demo

Author: phantomics

demos/cnn/demo.lisp

@@ -26,8 +26,8 @@
         (if (= 1 (slot-value idx-input 'rank))
             (slot-value idx-input 'data)
             (make-array (loop :for d :across (slot-value idx-input 'dimensions) :collect d)
-                        :displaced-to (slot-value idx-input 'data)
-                        :element-type (array-element-type (slot-value idx-input 'data))))))))
+                        :element-type (array-element-type (slot-value idx-input 'data))
+                        :displaced-to (slot-value idx-input 'data)))))))
 
 (april-load (with (:space cnn-demo-space))
             (asdf:system-relative-pathname (intern (package-name *package*) "KEYWORD") "cnn.apl"))
@@ -101,7 +101,7 @@ tests ← 100 ⍝ 10000
 ⎕ ← ' ' ⋄ ⎕ ← '--' ⋄ ⎕ ← ' '
 
 t       ← timeFactors⊥¯4↑⎕ts
-correct ← +/(⎕←tests↑[0]telabs) = ⎕←(tests↑[0]teimgs) testZhang⍤2⊢k1 b1 k2 b2 fc b
+correct ← +/(tests↑[0]telabs) = (tests↑[0]teimgs) testZhang⍤2⊢k1 b1 k2 b2 fc b
 
 ⎕ ← 'Recognition testing completed in ',formatElapsed t
 ⎕ ← (⍕correct),' images out of ',(⍕tests),' recognized correctly.'

demos/fnn/demo.lisp

@@ -33,28 +33,50 @@ MakeNormalArray ← {
 ∘○ To Verify ○∘
 Normally Distributed Array Elements
 
-Evaluate (verify-normal-array) to see an array of normally-distributed floating point numbers. Optionally, pass a shape like #(2 3 4) to this function to receive an array of the corresponding shape.
+* (verify-normal-array)
 
-Evaluate (verify-normal-distrib) to see a vector representing the distribution of values generated by MakeNormalArray.
+Evaluate this to see an array of normally-distributed floating point numbers. Optionally, pass a shape like #(2 3 4) to this function to receive an array of the corresponding shape.
 
-Evaluate (verify-plot-normal-distrib) to see a plot of the value distribution generated by MakeNormalArray. Try smaller counts as with (verify-plot-normal-vector 100) to see a less normal distribution and larger counts like 10,000 to see a more normal distribution. You may pass a width value as the second argument to control the width of the plot, i.e. (verify-plot-normal-vector :count 1000 :width 40) will produce a plot whose rows may be no longer than 40 characters.
+You can optionally pass a set of dimensions to the function:
+
+(verify-normal-array 2 3)
+
+* (verify-normal-distrib)
+
+Evaluate this to see a vector representing the distribution of values generated by MakeNormalArray. This function optionally takes a length argument to determine the length of the normal vector created:
+
+(verify-normal-distrib 100)
+
+* (verify-plot-normal-distrib)
+
+Evaluate this to see a plot of the value distribution generated by MakeNormalArray. To use less elements and see a less normal distribution, try:
+
+(verify-plot-normal-distrib :count 100)
+
+Or try with larger counts like 10,000 to see a more normal distribution. You may pass a width argument to control the width of the plot: 
+
+(verify-plot-normal-distrib :count 1000 :width 40)
+
+This will produce a plot whose rows may be no longer than 40 characters.
 |#
 
-(defun verify-normal-array (&optional (shape 10))
-  "Generate an array of normally-distributed floating point numbers."
-  (april-c (with (:space fnn-demo-space)) "MakeNormalArray" shape))
+(defun verify-normal-array (&rest shape)
+  "Generate an array of normally-distributed floating point numbers with an optional shape."
+  (let ((shape (or shape '(10))))
+    (april-c (with (:space fnn-demo-space)) "MakeNormalArray" (coerce shape 'vector))))
 
 (defun verify-normal-distrib (&optional (count 1000))
   "Generate a vector of integers reflecting the distribution of floating point numbers in an array produced by MakeNormalArray."
   (april-c (with (:space fnn-demo-space))
-           "{{{¯1+≢⍵}⌸⍵,⍨⍳21}⊢⊢(2.0÷⍨¯11+⍳21)⍸MakeNormalArray ⍵}"
+           "{{{1-⍨≢⍵}⌸⍵,⍨⍳21}(2÷⍨⎕IO-⍨¯10+⍳21)⍸MakeNormalArray ⍵}"
            count))
 
 (defun verify-plot-normal-distrib (&key (count 1000) (width 80))
   "Plot the distribution of numbers generated using MakeNormalArray."
   (april-c (with (:space fnn-demo-space))
-           "{⍺{⎕←↑'⎕'⍴¨⍨⌊⍺×⍵÷⌈/⍵}{{¯1+≢⍵}⌸⍵,⍨⍳21}⊢⊢(2.0÷⍨¯11+⍳21)⍸MakeNormalArray ⍵ ⋄ 'Plotted.'}"
-           count width))
+           "{⍺{⎕←↑'⎕'⍴¨⍨⌊⍺×⍵÷⌈/⍵}{{1-⍨≢⍵}⌸⍵,⍨⍳21}(2÷⍨⎕IO-⍨¯10+⍳21)⍸MakeNormalArray ⍵}"
+           count width)
+  (format nil "Distribution of ~a random numbers plotted with width ~a." count width))
 
 #|
 -- Functions --
@@ -90,14 +112,19 @@ InitWeightMatrices ← {
 ∘○ To Verify ○∘
 Neural Network Structure
 
-Evaluate (verify-network-structure) to see the printed structure of a random neural network. Optionally, choose a shape for the network by passing a vector of dimensions to the function, as with (verify-network-structure #(2 5 3)).
+* (verify-network-structure)
+
+Evaluate this to see the printed structure of a random neural network. Optionally, you can set a shape for the network by passing a set of dimensions as the argument, like this:
+
+(verify-network-structure 1 3 2)
 |#
 
-(defun verify-network-structure (&optional (shape #(3 6 2)))
+(defun verify-network-structure (&rest shape)
   "Display the structure of a neural network with an optionally specified shape."
-  (april-c (with (:space fnn-demo-space))
-           "{⎕←display InitNetwork ⍵ ⋄ 'Neural network structure.'}"
-           shape))
+  (let ((shape (or shape #(3 6 2))))
+    (april-c (with (:space fnn-demo-space))
+             "{⎕←display InitNetwork ⍵ ⋄ 'Printed network strucure with base shape ',(⍕⍵),'.'}"
+             (coerce shape 'vector))))
 
 #|
 -- Function --
@@ -161,17 +188,32 @@ DF ← {
 ∘○ To Verify ○∘
 Activation and Neural Network Output
 
-Evaluate (verify-activation-output) to see the output of the LeakyReLU function with an optional input value and its standard leaky parameter of 0.1. Evaluate (verify-network-output) to see the printed output of a random neural network. As with (verify-network-structure), you can optionally choose a shape for the input network.
+* (verify-activation-output)
+
+Evaluate this to see the output of the LeakyReLU function. You can pass it a series of input values:
+
+(verify-activation-output 10.0d0 -20.0d0 30.0d0)
+
+* (verify-network-output)
+
+Evaluate this to see the printed output of a random neural network. As with (verify-network-structure), you can optionally set a shape:
+
+(verify-network-output 2 5 3)
 |#
 
-(defun verify-activation-output (&optional (input #(1.0d0 -2.0d0 3.0d0 -4.0d0)))
-  (april-c (with (:space fnn-demo-space)) "LeakyReLU.F" input))
+(defun verify-activation-output (&rest input)
+  "Display the output of the LeakyReLU activation function called on an optionally specified series of numbers."
+  (let ((input (or input #(1.0d0 -2.0d0 3.0d0 -4.0d0))))
+    (april-c (with (:space fnn-demo-space)) "LeakyReLU.F" (coerce input 'vector))))
 
-(defun verify-network-output (&optional (shape #(3 6 2)))
+(defun verify-network-output (&rest shape)
   "Display the output of a forward pass through a neural network."
-  (april-c (with (:space fnn-demo-space))
-           "{⎕←display (InitNetwork ⍵) (LeakyReLU.F _ForwardPass) ⍪1 0 0 ⋄ 'Neural network output.'}"
-           shape))
+  (let ((shape (or shape #(3 6 2))))
+    (april-c (with (:space fnn-demo-space))
+             "{ 
+⎕←display (InitNetwork ⍵) (LeakyReLU.F _ForwardPass) ⍪1↑⍨⊃⍵
+'Printed output of neural network with shape ',(⍕⍵),'.'}"
+             (coerce shape 'vector))))
 
 #|
 -- Function --
@@ -209,9 +251,23 @@ DF ← {
 ∘○ To Verify ○∘
 Loss Function and Its Derivative
 
-Evaluate (verify-loss-convergence) to see a vector of the output from the derivative loss function with a given input and the output of the algorithmically derived loss function given the same input and a given dx value. For example, you can run (verify-loss-convergence :input 5 :dx 0.1)  To see the same with a series of dx values, evaluate (verify-loss-convergence-series), optionally with input as with (verify-loss-convergence-series :input 5 :series #(0.1d0 0.01d0 0.001d0)).
+* (verify-loss-convergence)
+
+Evaluate this to see a vector of the output from the derivative loss function with a given input and the output of the algorithmically derived loss function given the same input and a given dx value. For example: 
+
+(verify-loss-convergence :input 5 :dx 0.1)  
+
+* (verify-loss-convergence-series)
+
+Evaluate this to see the same with a series of dx values, optionally with input:
 
-The (verify-network-output-loss)
+(verify-loss-convergence-series :input 5 :series #(0.1d0 0.01d0 0.001d0)).
+
+* (verify-network-output-loss)
+
+Evaluate this to see the loss value for a given input and output to a network. You can set a shape for the network as well as specifying the input and target values:
+
+(verify-network-output-loss :shape #(3 6 2) :input #(2 0) :target #(0 1))
 |#
 
 (defun verify-loss-convergence (&key (input 3) (dx 0.1))
@@ -269,9 +325,11 @@ _Train ← {
   ⊢⊢(⊢⊣⌽¯1↓xs){
     W ← ⍵⊃⌽Ws ⋄ b ← ⍵⊃⌽bs ⋄ x ← ⍺
     
-    dbs ,← ⊂dx×dfAct b+W+.×x
-    dx  ⊢← (⍉W)+.×⊃⌽dbs
-    dWs ,← ⊂(⊃⌽dbs)+.×⍉x
+    dbs ,← ⊂db ← dx×dfAct b+W+.×x
+    ⍝ dx  ⊢← (⍉W)+.×⊃⌽dbs
+    dx  ⊢← db+.×⍨⍉W
+    ⍝ dWs ,← ⊂(⊃⌽dbs)+.×⍉x
+    dWs ,← ⊂db+.×⍉x
   }¨⊢⊣⍳≢Ws
   (0.001×⌽dWs) (0.001×⌽dbs)
 }
@@ -281,7 +339,17 @@ _Train ← {
 ∘○ To Verify ○∘
 Trained Network States
 
-Evaluate (verify-training-output) to either 1. initialize a neural network if none is stored or 2. perform an iteration of training upon the stored neural network. You can start again with a fresh network by evaluating (verify-training-output-restart). As with (verify-loss-applied), (verify-training-output) can take 3 arguments specifying the shape of the network, its input and its target. 
+* (verify-training-output)
+
+Evaluate this to either 1. initialize a neural network if none is stored or 2. perform an iteration of training upon the stored neural network.
+
+* (verify-training-output-restart)
+
+Evaluate this to start again with a fresh neural network.
+
+As with (verify-loss-applied), (verify-training-output) can take 3 arguments specifying the shape of the network, its input and its target:
+
+(verify-training-output :shape #(3 6 2) :input #(0 2) :target 1)
 
 The input and target values will be reshaped into vectors matching the first and last dimensions of the network, respectively. Changing the shape, input or target values when a network exists will cause the network to be rebuilt with those values applying.
 |#
@@ -291,9 +359,9 @@ The input and target values will be reshaped into vectors matching the first and
   (defun verify-training-output-restart ()
     "Clear the network state of the training output test function."
     (setf net-state nil))
-  (defun verify-training-output (&optional (shape #(2 5 3)) (input 0) (target 0))
+  (defun verify-training-output (&key (shape #(2 5 3)) (input 0) (target 0))
     "Get the output of a training iteration upon a neural network with an optionally specified shape, input and target."
-    (unless (not (equalp shape net-shape))
+    (unless (equalp shape net-shape)
       (setf net-shape shape
             net-state nil))
     (unless (equalp input net-input)
@@ -304,7 +372,7 @@ The input and target values will be reshaped into vectors matching the first and
       (setf net-target target
             derived-target (april-c "{⍪⍺⍴⍨⊃⌽⍵}" net-shape target)
             net-state nil))
-    ;; (print (list :ns net-state shape net-shape input net-input target net-target))
+    ;; (print (list :ns net-state shape net-shape input net-input))
     (if net-state
         (setf net-state (april (with (:space fnn-demo-space)
                                      (:state :in ((net net-state) (target derived-target)
@@ -381,11 +449,27 @@ The following functions implement tools for importing the MNIST data into arrays
 #|
 ○∘ To Demonstrate ∘○
 
-Evaluate (load-digit-training-data) followed by (build-digit-network) to load the MNIST training data and build a neural network. Then, run (train-digit-network) to train the network. Optionally, a count may be passed to (train-digit-network) if you wish to train the network on a limited subset of the MNIST training data rather than training on all 60,000 images.
+* (load-digit-training-data)
+
+Evaluate this, followed by...
+
+* (build-digit-network)
+
+...to load the MNIST training data and build a neural network. Then:
+
+* (train-digit-network) 
+
+Evaluate this to train the network. Optionally, a count argument may be passed if you wish to train the network on a limited subset of the MNIST training data rather than training on all 60,000 images:
+
+(train-digit-network 2000)
 
 The functions (get-net-state) (get-data-segment) and (set-data-segment) are utility functions which may be useful in analyzing the data passing through the network.
 
+The (build-digit-network) function can optionally be passed a set of intermediate dimensions. For example:
+
+(build-digit-network 12 18)
 
+Will yield a training network with shape 728 12 18 10. The default shape is 728 16 16 10, which has been found to produce good results with the MNIST digit set, but you can use dimensional inputs to experiment with other structures.
 |#
 
 (let ((net-shape) (net-state) (image-size 0) (training-data) (training-labels)
@@ -407,11 +491,12 @@ The functions (get-net-state) (get-data-segment) and (set-data-segment) are util
                                       :displaced-to training-data :displaced-index-offset 0)))
     (april-c "{'Loaded ',(⍕⍴⍵),' MNIST training images with labels.'}" training-labels))
 
-  (defun build-digit-network (&optional (intermediate-shape #(16 16)))
+  (defun build-digit-network (&rest intermediate-shape)
     "Generate a neural network with an optionally specified intermediate state (not determined by the input or output shapes)."
-    (setf net-shape (april-c "{⊃,/⍺ ⍵ 10}" intermediate-shape image-size)
-          net-state (april-c (with (:space fnn-demo-space)) "InitNetwork" net-shape))
-    (april-c "{'Built MNIST digit recognition network with shape ',(⍕⍵),'.'}" net-shape))
+    (let ((intermediate-shape (or intermediate-shape #(16 16))))
+      (setf net-shape (april-c "{⍵,⍺,10}" image-size (coerce intermediate-shape 'vector))
+            net-state (april-c (with (:space fnn-demo-space)) "InitNetwork" net-shape))
+      (april-c "{'Built MNIST digit recognition network with shape ',(⍕⍵),'.'}" net-shape)))
 
   (defun get-net-state ()
     "Retrieve the state of the neural network."

functions.lisp

@@ -196,7 +196,8 @@
 (defun apl-gcd (comparison-tolerance)
   "Implementation of greatest common denominator extended to complex numbers based on the complex-floor function."
   (lambda (omega alpha)
-    (if (or (complexp omega) (complexp alpha))
+    (if (not (or (complexp omega) (complexp alpha)))
+        (funcall (apl-xcy #'gcd) omega alpha)
         (if (zerop (funcall (apl-residue comparison-tolerance)
                             omega alpha))
             alpha (if (or (not (integerp (realpart omega)))
@@ -229,8 +230,7 @@
                                        (if (< (- comparison-tolerance)
                                               (realpart residue)
                                               comparison-tolerance)
-                                           residue (imagpart residue))))))
-        (funcall (apl-xcy #'gcd) omega alpha))))
+                                           residue (imagpart residue)))))))))
 
 (defun apl-lcm (comparison-tolerance)
   "Implementation of lease common multiple extended to complex numbers based on the complex-floor function."

libraries/extensions/jkanji/README.md

@@ -0,0 +1,9 @@
+# APRIL-EXT.JKANJI
+### _Your Name <[email protected]>_
+
+This is a project to do ... something.
+
+## License
+
+Specify license here
+

libraries/extensions/jkanji/april-ext.jkanji.asd

@@ -0,0 +1,11 @@
+;;;; april-ext.jkanji.asd
+
+(asdf:defsystem #:april-ext.jkanji
+  :description "An extension to April aliasing the lexicon with Japanese kanji."
+  :author "Andrew Sengul"
+  :license "Apache-2.0"
+  :version "1.0"
+  :serial t
+  :depends-on ("april")
+  :components ((:file "package")
+               (:file "jkanji")))