Векторизовать точечный продукт со скользящим окном

Вы можете использовать частичные суммы для сложности O (n):

ps = np.r_[0, np.cumsum(a*b)]
ps[3:]-ps[:-3]
# array([154, 319, 550, 847])

Или вариант, который ближе к исходному циклу for и позволяет избежать очень больших частичных сумм:

k = 3
d = a*b
d[k:] -= d[:-k].copy()
np.cumsum(d)[k-1:]
# array([154, 319, 550, 847])

Обновить в соответствии с обновленным Q.

Теперь это действительно свертка, поэтому решение @Divakar более или менее применимо. Только вы бы сворачивали a[::-1] и b напрямую. Если скорость является проблемой, вы можете попробовать заменить np.convolve на scipy.signal.fftconvolve, что в зависимости от размеров ваших операндов может быть значительно быстрее. Однако для очень маленьких операндов или операндов совершенно разной длины вы можете даже потерять некоторую скорость, поэтому обязательно попробуйте оба метода:

np.convolve(b, a[::-1], 'valid')
scipy.signal.fftconvolve(b, a[::-1], 'valid')

Подход №1

Используйте np.convolve для поэлементного умножения между двумя входы и с ядром всех единиц и size=3 -

np.convolve(a*b,np.ones(3),'valid')

Подход №2

Поскольку мы просто суммируем элементы в окне, мы также можем использовать _ 4_, вот так -

from scipy.ndimage.filters import uniform_filter1d as unif1d

def uniform_filter(a,W):
    hW = (W-1)//2
    return W*unif1d(a.astype(float),size=W, mode='constant')[hW:-hW]

out = uniform_filter(a*b,W=3)

Бенчмаркинг

Петлевой подход -

def loopy_approach(a,b):
    window = 3
    N = a.size-window+1

    result = np.empty([N,1])
    result[0] = a[0]*b[0]+a[1]*b[1]+a[2]*b[2]
    for i in range(N-1):
        result[i+1] = result[i]-a[i]*b[i]+a[i+window]*b[i+window]
    return result

Сроки и проверка -

In [147]: a = np.random.randint(0,100,(1000))
     ...: b = np.random.randint(0,100,(1000))
     ...: 

In [148]: out0 = loopy_approach(a,b).ravel()
     ...: out1 = np.convolve(a*b,np.ones(3),'valid')
     ...: out2 = uniform_filter(a*b,W=3)
     ...: 

In [149]: np.allclose(out0,out1)
Out[149]: True

In [150]: np.allclose(out0,out2)
Out[150]: True

In [151]: %timeit loopy_approach(a,b)
     ...: %timeit np.convolve(a*b,np.ones(3),'valid')
     ...: %timeit uniform_filter(a*b,W=3)
     ...: 
100 loops, best of 3: 2.27 ms per loop
100000 loops, best of 3: 7 µs per loop
100000 loops, best of 3: 10.2 µs per loop

Еще один подход с использованием шагов:

In [12]: from numpy.lib.stride_tricks import as_strided
In [13]: def using_strides(a, b, w=3):
              shape = a.shape[:-1] + (a.shape[-1] - w + 1, w)
              strides = a.strides + (a.strides[-1],)
              res = np.sum((as_strided(a, shape=shape, strides=strides) * \ 
                            as_strided(b, shape=shape, strides=strides)), axis=1)
              return res[:, np.newaxis]


In [14]: using_strides(a, b, 3)
Out[14]: 
array([[154],
       [319],
       [550],
       [847]])