Strategies to speed up the code:

1. Instead of computing all the lines in one large array, then picking one, you should compute one line at the time, and keep only the best one iteratively. Loops in Python are slow, and vectorizing things is good, but the larger the image, and the more points around the circle you evaluate, the larger this intermediate array becomes. And large intermediate arrays are also slow. Instead, use [Numba](https://numba.pydata.org) to speed up the loops.

2. This line is way more expensive than it needs to be:

    ```python
    brightness = brightness_factor * brightness_decay(distance, decay_factor)
    ```
    `brightness_decay` draws the lines with a Gaussian profile. This is really good. But you're computing the Gaussian also for points far away from the line where the output will be (near) zero. You should evaluate the `brightness_decay` function only for pixels that are close to the line.

    Furthermore, the very next line erases a bunch of lines. Can't you determine first which lines you want to keep, and only draw those?

Other comments:

1. The function `cmyk_split` does two things: it reads an image from file, then it converts the color space and returns individual channels. The function name reveals only the latter action. It is best when functions do only one thing.

2. You're computing the string art for the cyan, magenta and yellow channels, but not for black channel (the 4th channel in CMYK).

3. I don't see the reason you needed to make `ImageTensor` derived from `torch.Tensor`. You could just use a `torch.Tensor` in your program. `_circle_mask` could be a regular function. You just add a few values (`img_shape`, `radius`, `center_y`, `center_x`) that you could equally well assign into a `torch.Tensor` object. Or just compute then when you need them. I think this `ImageTensor` object makes you code more difficult to read than it needs to be, it adds complication rather than simplifying things.

    I'll admit I'm biased against OOP. But I think classes should only be introduced when they simplify code or the API.