Re: guile-user Digest, Vol 193, Issue 30

[Zelphir Kaltstahl <zelphirkaltstahl@gmail.com>]

On 26.12.18 18:00, guile-user-request@gnu.org wrote:
> Hello,
>
>> Is there some library, that enables high performance matrix operations
>> or even n-dimensional array operations? I am thinking of something like
>> NumPy in the Python ecosystem. I think NumPy in turn also uses some
>> lower level thing to do what it does. I think OpenBLAS or MKL, depending
>> on the architecture. I wonder if there is any wrapper around OpenBLAS
>> for Guile or something similar.
>> ...
> There are quite a few libs you might look at before you start to code your own:
>
> 	https://notabug.org/lloda
> 		...
> 		guile-newra
> 		guile-ffi-cblas
> 		...
> 		guile-ploy
> 		...
>
> 	AIscm
> 	http://wedesoft.github.io/aiscm
>
> I also wrote a set of n-dim array math ops (including matrix ops) for Guile-CV:
>
> 	https://www.gnu.org/software/guile-cv/
> 		the manual is available online, math and matrix ops are described in
> 		the 'Processing' section
>
> 	mentioning Guile-CV because images are just a collection of n-dim arrays.
> 	(see 'Image Structure and Accessors' in the manual).
>
> 	in Guile-CV, all (almost all) arrays are f32vectors - see (srfi srfi-4) in
> 	the Guile manual - math and matrix ops are written in C (but memory
> 	allocation entirely kept in scheme). multi channel ops are multi-threaded
>
> 	some of these math and matrix ops also work on s32 and f64 (undocumented so
> 	far): it would not take much to actually fully generalize all guile-cv math
> 	and matrix ops for the full set of (srfi srfi-4 ) types.
>
> Cheers,
> David

Thanks David,

I've added these to my notes for further investigation : )

In SciPy and if I am not mistaken in the Python bindings for OpenCV they
also use NumPy ndarray to represent images and it feels quite natural,
so it makes sense to me to use n-dimensional arrays for this.

It seems the "uniform numeric vectors" of Guile are an implementation of
the vectors in SRFI-4 as per:
https://www.gnu.org/software/guile/manual/html_node/Uniform-Numeric-Vectors.html#Uniform-Numeric-Vectors.

So far I have a very naive but working matrix operation implementation
here (WIP):

https://gitlab.com/ZelphirKaltstahl/neural-network/blob/dev/matrix.scm

(I know, it's not something no one has ever seen before :D)

I think, once I have a good idea about how to use a fitting library or
how to interface with a library of another programming language, I
should be able to switch how the data abstraction procedures work and
should directly gain the speed advantage for that. It is possible I
should structure my code more, for example by putting the tests in a
separate file etc. Or I should add another layer of abstraction between
the matrix operations and the data abstraction layer, maybe some kind of
"package of data abstraction" that I give the program as a parameter or
something. For now all that it is, is a hacky thing, with which I am
trying to reimplement some Python tutorial for neural networks, trying
to use matrix multiplication at the right places, after understanding
what those places are.

Yesterday I tried to use my transpose procedure and it turns out I
sooner run out of RAM (8GB) than the thing slows down. Once I run out of
RAM of course my machine hangs and I need to try to squeeze in some
Ctrl+C etc. Transposing a 1000x1000 was no issue, but going up to
1000x10000 exploded in my face :D Well, transposing is not the most
computationally expensive operation, so not a good measure and as I read
in the NumPy internals, there are way cleverer ways to handle
transposing, compared to the naive way I implemented it.

Regards,

Zelphir