addition of the methods fit and predict + simplification of example mnist

Author: Vandenplas, Jeremie

src/lib/mod_network.f90

@@ -26,18 +26,22 @@ module mod_network
 
     procedure, public, pass(self) :: accuracy
     procedure, public, pass(self) :: backprop
+    procedure, public, pass(self) :: fit_batch
     procedure, public, pass(self) :: fwdprop
     procedure, public, pass(self) :: init
     procedure, public, pass(self) :: load
     procedure, public, pass(self) :: loss
     procedure, public, pass(self) :: output
+    procedure, public, pass(self) :: predict_batch
     procedure, public, pass(self) :: save
     procedure, public, pass(self) :: set_activation
     procedure, public, pass(self) :: sync
     procedure, public, pass(self) :: train_batch
     procedure, public, pass(self) :: train_single
     procedure, public, pass(self) :: update
 
+    generic, public :: fit => fit_batch!, train_single
+    generic, public :: predict => predict_batch!, train_single
     generic, public :: train => train_batch, train_single
 
   end type network_type
@@ -117,6 +121,39 @@ pure subroutine backprop(self, y, dw, db)
 
   end subroutine backprop
 
+  subroutine fit_batch(self, x, y, eta,epochs,batch_size)
+    class(network_type), intent(in out) :: self
+    integer(ik),intent(in),optional::epochs,batch_size
+    real(rk), intent(in) :: x(:,:), y(:,:), eta
+
+    integer(ik)::i,n,nsamples,nbatch
+    integer(ik)::num_epochs,num_batch_size
+    integer(ik)::batch_start,batch_end
+
+    nsamples=size(y,dim=2)
+
+    num_epochs=1
+    if(present(epochs))num_epochs=epochs
+
+    num_batch_size=nsamples
+    if(present(batch_size))num_batch_size=batch_size
+
+    nbatch=nsamples/num_batch_size
+
+    epoch: do n=1,num_epochs
+     batch_end=0
+     mini_batches: do i=1,nbatch
+      batch_start=batch_end+1
+      batch_end=batch_start+batch_size-1
+      if(i.eq.nbatch)batch_end=nsamples
+   
+      call self%train(x(:,batch_start:batch_end),y(:,batch_start:batch_end),eta)
+       
+     enddo mini_batches
+    enddo epoch
+
+  end subroutine
+
   pure subroutine fwdprop(self, x)
     ! Performs the forward propagation and stores arguments to activation
     ! functions and activations themselves for use in backprop.
@@ -188,6 +225,20 @@ pure function output(self, x) result(a)
     end associate
   end function output
 
+  pure function predict_batch(self, x) result(a)
+    class(network_type), intent(in) :: self
+    real(rk), intent(in) :: x(:,:)
+    real(rk), allocatable :: a(:,:)
+
+    integer(ik) :: i
+
+    allocate(a(self%dims(size(self%dims)),size(x,dim=2)))
+    do i = 1, size(x, dim=2)
+     a(:,i)=self%output(x(:,i))
+    enddo
+ 
+  end function predict_batch
+
   subroutine save(self, filename)
     ! Saves the network to a file.
     class(network_type), intent(in out) :: self

src/tests/example_mnist.f90

@@ -12,14 +12,11 @@ program example_mnist
 
   real(rk), allocatable :: tr_images(:,:), tr_labels(:)
   real(rk), allocatable :: te_images(:,:), te_labels(:)
-  !real(rk), allocatable :: va_images(:,:), va_labels(:)
-  real(rk), allocatable :: input(:,:), output(:,:)
 
   type(network_type) :: net
 
   integer(ik) :: i, n, num_epochs
-  integer(ik) :: batch_size, batch_start, batch_end
-  real(rk) :: pos
+  integer(ik) :: batch_size
 
   call load_mnist(tr_images, tr_labels, te_images, te_labels)
 
@@ -33,28 +30,12 @@ program example_mnist
       net % accuracy(te_images, label_digits(te_labels)) * 100, ' %'
   end if
 
-  epochs: do n = 1, num_epochs
-    mini_batches: do i = 1, size(tr_labels) / batch_size
-
-      ! pull a random mini-batch from the dataset
-      call random_number(pos)
-      batch_start = int(pos * (size(tr_labels) - batch_size + 1))
-      batch_end = batch_start + batch_size - 1
-
-      ! prepare mini-batch
-      input = tr_images(:,batch_start:batch_end)
-      output = label_digits(tr_labels(batch_start:batch_end))
-
-      ! train the network on the mini-batch
-      call net % train(input, output, eta=3._rk)
-
-    end do mini_batches
-
-    if (this_image() == 1) then
-      write(*, '(a,i2,a,f5.2,a)') 'Epoch ', n, ' done, Accuracy: ',&
-        net % accuracy(te_images, label_digits(te_labels)) * 100, ' %'
-    end if
+  call net%fit(tr_images,label_digits(tr_labels),eta=3._rk,epochs=num_epochs,batch_size=batch_size)
+   
+  if (this_image() == 1) then
+    write(*, '(a,f5.2,a)') 'Epochs done, Accuracy: ',&
+     net % accuracy(te_images, label_digits(te_labels)) * 100, ' %'
+  endif
 
-  end do epochs
 
 end program example_mnist