Is there a way to map an array function to every column of a matrix?

[noahmartinwilliams]

There's a map function that applies a function to every element of an array, but I need one that works at the level of arrays and not elements. I've searched through the documentation and as far as I can tell there doesn't seem to be any function for it.

[tomsmeding]

Mapping over the columns of a matrix is equivalent to mapping over the rows of the matrix if you transpose before and after, so I'll just assume you want to map over the inner vectors of a 2-dimensional array.

If your function (that you want to map) can be written rank-polymorphically, i.e. with the type Acc (Array (sh :. Int) a) -> Acc (Array (sh :. Int) a) (where a is your element type), then there is nothing to do: just apply the function to the matrix (possibly with transposition before and after, see above), and it will automatically broadcast over the other dimensions.

Taking an Acc (Vector a) -> Acc (Vector a) function and mapping it over the rows of a 2-dimensional array is impossible in Accelerate due to the restriction on nested parallelism. You will have to do this with the help of rank-polymorphism / implicit broadcasting.

Does this perhaps already help?

[noahmartinwilliams]

Yes, the second case is what I was talking about doing. How hard do you think it would be to add such a function?

[tomsmeding]

Do you have a particular function in mind? Perhaps it can be written rank-polymorphically so that this whole discussion becomes unnecessary.

That said: what you suggest would amount to a vectorisation transformation: taking an existing Accelerate array function and lifting it up to a higher dimension.

For a bunch of primitives this would work fine: if the function does a generate, then lifting that generate up one dimension higher is easy and incurs no code changes, just a type change. But what if, say, the function uses awhile? Suppose we have this:

f :: Acc (Vector Int) -> Acc (Vector Int)
f a = awhile (\v -> map (< 0) (sum v))
             (\v -> let m = minimum v in map (- m) v)
             a

When lifting this to a function vectorisedF :: Acc (Matrix Int) -> Acc (Matrix Int), we have a problem: the number of iterations performed by the awhile might differ across the vectors in the input matrix! The result cannot be directly expressed using awhile any more. And if you try to dodge that problem by switching to a while on expression level, you can't compute partial minimums from an expression.

So no, vectorisation is not easy. It may be possible, but Accelerate does not support it currently, and it will not support it soon, in all likelihood.

[noahmartinwilliams]

I was hoping to try and write a neural network library that would operate on many samples all at once. It would take in a matrix where every column is a sample, train the neural net on those samples in parallel, return a new matrix where every column contains all the information of the neural net, and then I could average them all (I'm pretty sure that would combine all of what they learned).

Doing every column in parallel would speed things up. I'm having trouble thinking of another way to do this. I've tried using take, drop, and ++ to take off one column at a time, but then that doesn't seem to actually process it in parallel.

[tomsmeding]

Without code it's hard to give very concrete advice, but try writing your function that just operates on a single column. Then see if you can make this function also typecheck by changing the type (!) to work on an array or columns (i.e. a matrix). If you're matching on the shape of the input column as I1 n, for example, you will need to change that to _ ::. n to allow for further dimensions above the inner one.

You may find that it, almost automatically, just works! That's the idea of rank-polymorphism: almost everything in Accelerate automatically broadcasts over an array of inputs, as long as you take care to allow that by inspecting only the dimensions you care about and leaving open whether there are further dimensions above (with ::. as illustrated earlier).

If it doesn't work, feel free to share a (self-contained) piece of code that you're having trouble generalising to more input dimensions, and I can try to help.