convolve | Simple demonstration of separable convolutions | Computer Vision library

This looks like you're trying to do a convolution, so jnp.convolve or similar would likely be a more performant approach.

That said, your example is a bit strange because n is never larger than 4, so you never access any but the first four elements of W. Also, you overwrite the previous value in each iteration of the inner loop, so each row of new_W just contained a scaled copy of one of the first four rows of W.

Changing your code to what I think you meant and using index_update to make it compatible with JAX's immutable arrays gives this:

This is a side effect of PIL. A PIL image with size (800,500) has 500 rows of 800 columns. When that becomes a numpy array, it has a shape of (500,800). So, it's not that the array is being transposed, it's that the two modules number the axes differently.

Note that 10**9 is an integer, which in numpy is interpreted as an int32, that is a 32-bit integer. The maximal value that can be represented in that type is 2147483647, if you go lager than that, you get an overflow. If you want to use integer types use np.int64 instead, otherwise use floating point numbers e.g. np.float:

Your new solution working, also is possible omit lambda function for simplier solution (with lambda working too):

it is (fortunately!) possible to achieve this with pytorch primitives. You are probably looking for functional conv1d. Below is how it works. I was not sure whether you wanted the derivative with respect to the input or the weights, so you have both, just keep the requires_grad that fits you needs :

Use:

In case you have the filtered image of normalized kernel, and the sum of the unnormalized kernel, all you have to do, is multiply the normalized image by the sum.

The rules of convolution is that you can switch the order:
Multiply the kernel by scaler, and filtering the image, is the same as filtering the image and multiply the result by scalar.

The following Python code demonstrates the solution:

If we read the docs for np.convolve, we see that with the default parameters, it returns an array that is one shorter than the sum of the lengths of the input array. That is if you call np.convolve(a, b), and len(a) = A and len(b) = B, the output is length A + B - 1.

This is because a convolution can be interpreted as integrating the product of two functions, with one of the functions shifted relative to the other. By default, np.convolve calculates this convolution for all points at which these functions overlap, so the length of the output is approximately the sum of the lengths of the input functions. In your case, x has length 100,000, and r has length 1,000, so the output length is 100,000 + 1,000 - 1 = 100,999.

You can change this behaviour with the mode parameter, so that np.convolve truncates the output automatically, but neither of the alternate options seem to match your use case. You could try supplying mode = same, which ensures the output is the same length as the longest input, and see what happens for your own interest though.

Since t - length 100,000 - and s need to be the same length so you can plot (I assume) s(t), you need to truncate the output s to a length of 100,000 to match.

This is what the notation [:len(x)] does. This is called "slice" notation, and the gist is that A[start:stop] allows you to select the subset of values in A from start (inclusive) to stop (exclusive). If you don't supply a start or end, it defaults to the start or end of the array respectively. So [:len(x)] picks from 0 to len(x) (exclusive) which gives you an array of length len(x). This ensures len(s) = len(x).

To do this, you should use your analytical function (with parameters) based on some assumption (not only polynomial functions). You can use curve_fit form scipy.optimize to find the unknown parameters of your analytic function that best fit your input data.

For example: