构建多个Maven项目(Build multiple Maven projects)

 这只是一个Numpy解决方案，希望它足够了。 我假设你的函数是由对矩阵元素和平均值的操作组成的，即一个缩放的和。 因此，将Y看作是足够的 
 
Y = np.power(X-X0, 2)
 
 所以我们只需要处理确定窗口均值。 注意，对于1D情况，可以确定具有合适的1的矢量的矩阵乘积用于计算平均值，例如 
 
h = np.array([0, 1, 1, 0])  # same dimension as y
m1 = np.dot(h, y) / 2 
m2 = (y[1] + y[2]) / 2
print(m1 == m2)  # True
 
 2D情况类似，但有两个矩阵乘法，一个用于行，一个用于列。 例如 
 
m_2 = np.dot(np.dot(h, Y), h) / 2**2
 
 要构建一个滑动窗口，我们需要构建一个移动窗口矩阵，例如 
 
H = [[1, 1, 1, 0, 0, ..., 0],
     [0, 1, 1, 1, 0, ..., 0],
            .
            .
            .
     [0, ..., 0, 0, 1, 1, 1]] 
 
 计算所有的总和 
 
S = np.dot(np.dot(H, Y), H.T)
 
 具有(m, m)窗口的(n, n)矩阵的完整示例将是 
 
import numpy as np

n, m = 500, 10
X0 = np.ones((n, n))
X = np.random.rand(n, n)
Y = np.power(X-X0, 2)

h = np.concatenate((np.ones(m), np.zeros(n-m)))  # window at position 0
H = np.vstack((np.roll(h, k) for k in range(n+1-m)))  # slide the window 
M = np.dot(np.dot(H,Y), H.T) / m**2  # calculate the mean
print(M.shape)  # (491, 491)
 
 构建H的另一种但可能稍微有效的方法是 
 
H = np.sum(np.diag(np.ones(n-k), k)[:-m+1, :] for k in range(m))
 
 更新 
 
 使用该方法也可以计算均方偏差。 为此，我们推广了向量恒等|x-x0|^2 = (x-x0).T (x-x0) = xT x - 2 x0.T x + x0.T x0 （空格表示标量或矩阵）乘法和.T转置向量）到矩阵的情况： 
 
 我们假设W是包含块(mm)单位矩阵的(m,n)矩阵，它能够通过Y = WZ WT提取(k0,k1) th (m,m)子矩阵，其中Z是包含数据的(n,n)矩阵。 计算差异 
 
 D = Y - X0 = Y = W Z W.T - X0 
 
 很简单，其中X0和D是(m,m)矩阵。 元素平方和的平方根称为Frobenius范数 。 基于这些身份 ，我们可以将平方和写为 
 
s = sum_{i,j} D_{i,j}^2 = trace(D.T D) = trace((W Z W.T - X0).T (H Z H.T - X0))
  = trace(W Z.T W.T W Z W.T) - 2 trace(X0.T W Z W.T) + trace(X0.T X0)
  =: Y0 + Y1 + Y2
 
 术语Y0可以从上面的方法解释为HZ HT 。术语Y1可以被解释为Z上的加权平均值， Y2是常数，其仅需要确定一次。 因此，可能的实现方式是： 
 
import numpy as np

n, m = 500, 10
x0 = np.ones(m)
Z = np.random.rand(n, n)

Y0 = Z**2
h0 = np.concatenate((np.ones(m), np.zeros(n-m)))
H0 = np.vstack((np.roll(h0, k) for k in range(n+1-m)))
M0 = np.dot(np.dot(H0, Y0), H0.T)

h1 = np.concatenate((-2*x0, np.zeros(n-m)))
H1 = np.vstack((np.roll(h1, k) for k in range(n+1-m)))
M1 = np.dot(np.dot(H1, Z), H0.T)

Y2 = np.dot(x0, x0)
M = (M0 + M1) / m**2 + Y2

This is only a Numpy solution, hope it suffices. I assume that your function is made up of an operation on the matrix elements and of a mean, i.e. a scaled sum. Hence, it is sufficient to look at Y as in
 
Y = np.power(X-X0, 2)
 
So we only need to deal with determining a windowed mean. Note that for the 1D case the matrix product with an appropriate vector of ones can be determined for calculating the mean, e.g.
 
h = np.array([0, 1, 1, 0])  # same dimension as y
m1 = np.dot(h, y) / 2 
m2 = (y[1] + y[2]) / 2
print(m1 == m2)  # True
 
The 2D case is analogous, but with two matrix multiplications, one for the rows and one for the columns. E.g.
 
m_2 = np.dot(np.dot(h, Y), h) / 2**2
 
To construct a sliding window, we need to build a matrix of shifted windows, e.g.
 
H = [[1, 1, 1, 0, 0, ..., 0],
     [0, 1, 1, 1, 0, ..., 0],
            .
            .
            .
     [0, ..., 0, 0, 1, 1, 1]] 
 
to calculate all the sums
 
S = np.dot(np.dot(H, Y), H.T)
 
A full example for a (n, n) matrix with a (m, m) window would be
 
import numpy as np

n, m = 500, 10
X0 = np.ones((n, n))
X = np.random.rand(n, n)
Y = np.power(X-X0, 2)

h = np.concatenate((np.ones(m), np.zeros(n-m)))  # window at position 0
H = np.vstack((np.roll(h, k) for k in range(n+1-m)))  # slide the window 
M = np.dot(np.dot(H,Y), H.T) / m**2  # calculate the mean
print(M.shape)  # (491, 491)
 
An alternative but probably slightly less efficient way for building H is 
 
H = np.sum(np.diag(np.ones(n-k), k)[:-m+1, :] for k in range(m))
 
Update
 
Calculating the mean squared deviation is also possible with that approach. For that, we generalize the vector identity |x-x0|^2 = (x-x0).T (x-x0) = x.T x - 2 x0.T x + x0.T x0 (a space denotes a scalar or matrix multiplication and .T a transposed vector) to the matrix case: 
 
We assume W is a (m,n) matrix containing a block (m.m) identity matrix, which is able to extract the (k0,k1)-th (m,m) sub-matrix by Y = W Z W.T, where Z is the (n,n) matrix containing the data. Calculating the difference
 
 D = Y - X0 = Y = W Z W.T - X0 
 
is straightforward, where X0 and D is a (m,m) matrix. The square-root of the squared sum of the elements is called Frobenius norm. Based on those identities, we can write the squared sum as 
 
s = sum_{i,j} D_{i,j}^2 = trace(D.T D) = trace((W Z W.T - X0).T (H Z H.T - X0))
  = trace(W Z.T W.T W Z W.T) - 2 trace(X0.T W Z W.T) + trace(X0.T X0)
  =: Y0 + Y1 + Y2
 
The term Y0 can be interpreted as H Z H.T from the method from above.The term Y1 can be interpreted as a weighted mean on Z and Y2 is a constant, which only needs to be determined once. Thus, a possible implementation would be:
 
import numpy as np

n, m = 500, 10
x0 = np.ones(m)
Z = np.random.rand(n, n)

Y0 = Z**2
h0 = np.concatenate((np.ones(m), np.zeros(n-m)))
H0 = np.vstack((np.roll(h0, k) for k in range(n+1-m)))
M0 = np.dot(np.dot(H0, Y0), H0.T)

h1 = np.concatenate((-2*x0, np.zeros(n-m)))
H1 = np.vstack((np.roll(h1, k) for k in range(n+1-m)))
M1 = np.dot(np.dot(H1, Z), H0.T)

Y2 = np.dot(x0, x0)
M = (M0 + M1) / m**2 + Y2