undefined

points

[-]

Maybe I'm missing something, but in this case, wouldn't being lazy would be pure overhead? I don't see anything can be lazy here. The reference computed once, nanoseconds before it's needed, and test cases computed at the time of comparison, then tossed away.

What would hope to be achieved by making this case lazy? If you wanted these to run in parallel, with a multi-gpu system, you would use the appropriate parallel interface.

by bee_rider149 days ago|

parent|

[-]

I mean if you wait long enough, it is asking for

  .abs().max().item()

of something that can be identified as definitionally zero.

by nomel149 days ago|

parent|

[-]

I don't understand. Since it's not using the parallel interface, only one operation can happen at a time. This would be, literally, sequential execution with extra overhead, in this case. Again, in this case, what would hope to be achieved from doing things lazily, since the lazy operations would immediately be followed by their evaluation?

The parallel interface, which is async, is probably what you're lookin for.

by Dylan16807148 days ago|

parent|

[-]

Let's look at the subtraction in this case.

If evaluation is lazy, then the subtraction operator gets fed two unevaluated matrix multiplies.

If it's a dumb subtraction operator, this gives us no benefit. Eventually it evaluates both and then subtracts. And it has some extra overhead like you said.

But if it's a smart subtraction operator, it can realize that both parameters are the same equation, and then it can return all 0s without evaluating anything.

And even better than just skipping the matrix math, "all 0s" can be a stub object that takes O(1) time to set up. And then .abs().max() will be instant too.

by nomel148 days ago|

parent|

[-]

I see now, thank you. I was stuck on the "lazy evaluation" part, rather than the optimization part they were actually suggesting.

by 148 days ago|

parent|

prev|

[-]

deleted

by bee_rider149 days ago|

parent|

prev|

[-]

The Python commands are encountered sequentially. One could image a library where the Python commands build the computation under the hood. Then, the library would be able to take advantage of situations like this one (or, more practically, reorder multiplications and/or avoid unnecessary temporaries).