ix | bootable standalone zzstructure editor | Editor library

Looking at the result of Cachegrind, it doesn't look like the memory is your bottleneck. The NN has to be stored in memory anyway, but if it's too large that your program's having a lot of L1 cache misses, then it's worth thinking to try to minimize L1 misses, but 1.7% of L1 (data) miss rate is not a problem.

So you're trying to make this run fast anyway. Looking at your code, what's happening at the most inner loop is very simple (load-> multiply -> add -> store), and it doesn't have any side effect other than the final store. This kind of code is easily parallelizable, for example, by multithreading or vectorizing. I think you'll know how to make this run in multiple threads seeing that you can write code with some complexity, and you asked in comments how to manually vectorize the code.

I will explain that part, but one thing to bear in mind is that once you choose to manually vectorize the code, it will often be tied to certain CPU architectures. Let's not consider non-AMD64 compatible CPUs like ARM. Still, you have the option of MMX, SSE, AVX, and AVX512 to choose as an extension for vectorized computation, and each extension has multiple versions. If you want maximum portability, SSE2 is a reasonable choice. SSE2 appeared with Pentium 4, and it supports 128-bit vectors. For this post I'll use AVX2, which supports 128-bit and 256-bit vectors. It runs fine on your CPU, and has reasonable portability these days, supported from Haswell (2013) and Excavator (2015).

The pattern you're using in the inner loop is called FMA (fused multiply and add). AVX2 has an instruction for this. Have a look at this function and the compiled output.

ix 0 doesn't produce a lens, but a traversal.¹

Informally, a lens is a "path" that will definitively reach a single value (if you follow it within a hypothetical larger value). A traversal is a path to zero or more values. You can set or view the single target of a lens. And you can set the zero or more targets of a traversal (this simply updates all of them that are present, which is a no-op if there are zero present). But viewing the targets of a traversal is less straightforward.

If view simply took a traversal, and an outer structure, and gave you the target value, then it would have a problem. If there are multiple targets, how should it decide which to return? And if there are zero targets, it can't return anything; it would have to be partial. What it needs is a way of condensing zero-or-more values into a single value, so it can return that. And the Monoid class provides exactly the facilities to do that; mempty for if there aren't any targets at all, and <> to condense multiple values to a single one. So view with a traversal² actually requires a Monoid constraint on the returned type, and that's why you're getting the complaint about No instance for (Monoid Int) arising from a use of `ix'.

And in case it isn't clear, you can often compose (with .) different types of optics (the general term for "lens-ish things", including lenses, traversals, and several others). But the result has the capabilities of the least capable of the two inputs. So even though your inner and w are full lenses, composing them with a traversal produced by ix results in a traversal, not a lens.

But in this case you know that you're using ix. The specific kind of traversals ix makes end up having zero or one target, rather than the zero or more targets that traversals have in general. So you could use preview instead of view; for a traversal it will produce a Maybe containing Just the first target of the traversal, or Nothing if there weren't any. A Maybe is exactly what the type system deems appropriate here, since ix can't guarantee there will be a target value, but there won't be more than one.

In my experience, when I try to view something and get this Monoid instance error, it almost always means I have an optic that can't guarantee a result and I should actually be using preview to get a Maybe.

Simple example:

If you are sure that the key is present then you can use fromJust to turn the Maybe User into a User:

Just use the tf.keras.callbacks.CSVLogger and any regression metric you want to log during training:

You can use np.delete() to delete the columns/rows that you want. This will return a new array

https://numpy.org/doc/stable/reference/generated/numpy.delete.html

You need a (?=[LXVI]) lookahead at the start that would require at least one Roman number letter at the start of the string:

If you insist on sorting out the sorting business in the return statement itself can use a ternary

Here is the final code. The algorithm has been modified to suit the OP. I have left the original code below.

This use a greedy algorithm: the first available value is returned, and no attempt is made to merge in turn. Each time a task finishes, the next one for the same enumerator goes to the back, ensuring fairness.

The algorithm is as follows:

• The function accepts a params array of sources.
• Early bail-out if no source enumerables are provided.
• Create a list to hold the enumerators along with their respective tasks as tuples.
• Get each enumerator, call MoveNextAsync and store the pair in the list.
• In a loop, call Task.WhenAny on the whole list.
• Take the resulting Task and find its location in the list.
• Hold the tuple in a variable and remove it from the list.
• If it returned true, then yield the value and call MoveNextAsync again for the matching enumerator, pushing the resulting tuple to the back of the list.
• If it returns false, then Dispose the enumerator.
• Continue looping until the list is empty.
• finally block disposes any remaining enumerators.
• There is also an overload to provide a cancellation token

There are some efficiencies to be had in terms of allocations etc. I've left that as an exercise to the reader.

when you use cmap="gray" in plt.imshow() you must either unscale your output or set vmin and vmax. From what I see you scaled by dividing 255, so you must multiply your data by 255 or, alternativle set vmin=0, vmax=1 Option1: