如何强制两个数组在pyplot中使用？

Question

I'm trying to plot a simple moving averages function but the resulting array is a few numbers short of the full sample size. How do I plot such a line alongside a more standard line that extends for the full sample size? The code below results in this error message:

ValueError: x and y must have same first dimension, but have shapes (96,) and (100,)

This is using standard matplotlib.pyplot . I've tried just deleting X values using remove and del as well as switching all arrays to numpy arrays (since that's the output format of my moving averages function) then tried adding an if condition to the append in the while loop but neither has worked.

import random
import matplotlib
import matplotlib.pyplot as plt
import numpy as np

def movingaverage(values, window):
    weights = np.repeat(1.0, window) / window
    smas = np.convolve(values, weights, 'valid')
    return smas

sampleSize = 100
min = -10
max = 10
window = 5

vX = np.array([])
vY = np.array([])

x = 0
val = 0
while x < sampleSize:
    val += (random.randint(min, max))
    vY = np.append(vY, val)
    vX = np.append(vX, x)
    x += 1

plt.plot(vX, vY)
plt.plot(vX, movingaverage(vY, window))
plt.show()

Expected results would be two lines on the same graph - one a simple moving average of the other.

Answer 1

Here is how you would pad a numpy array out to the desired length with 'nan's (replace 'nan' with other values, or replace 'constant' with another mode depending on desired results) https://docs.scipy.org/doc/numpy/reference/generated/numpy.pad.html

import numpy as np
bob = np.asarray([1,2,3])
alice = np.pad(bob,(0,100-len(bob)),'constant',constant_values=('nan','nan'))

So in your code it would look something like this:

import random
import matplotlib
import matplotlib.pyplot as plt
import numpy as np

def movingaverage(values,window):
    weights = np.repeat(1.0,window)/window
    smas = np.convolve(values,weights,'valid')
    shorted = int((100-len(smas))/2)
    print(shorted)
    smas = np.pad(smas,(shorted,shorted),'constant',constant_values=('nan','nan'))
    return smas

sampleSize = 100
min = -10
max = 10
window = 5

vX = np.array([])
vY = np.array([])

x = 0
val = 0
while x < sampleSize:
    val += (random.randint(min,max))
    vY = np.append(vY,val)
    vX = np.append(vX,x)
    x += 1
plt.plot(vX,vY)
plt.plot(vX,(movingaverage(vY,window)))
plt.show()

Answer 2

Just change this line to the following:

smas = np.convolve(values, weights,'same')

The 'valid' option, only convolves if the window completely covers the values array. What you want is 'same', which does what you are looking for.

---

Edit: This, however, also comes with its own issues as it acts like there are extra bits of data with value 0 when your window does not fully sit on top of the data. This can be ignored if chosen, as is done in this solution, but another approach is to pad the array with specific values of your choosing instead (see Mike Sperry's answer).

Answer 3

To answer your basic question, the key is to take a slice of the x-axis appropriate to the data of the moving average. Since you have a convolution of 100 data elements with a window of size 5, the result is valid for the last 96 elements. You would plot it like this:

plt.plot(vX[window - 1:], movingaverage(vY, window))

That being said, your code could stand to have some optimization done on it. For example, numpy arrays are stored in fixed size static buffers. Any time you do append or delete on them, the entire thing gets reallocated, unlike Python lists, which have amortization built in. It is always better to preallocate if you know the array size ahead of time (which you do).

Secondly, running an explicit loop is rarely necessary. You are generally better off using the under-the-hood loops implemented at the lowest level in the numpy functions instead. This is called vectorization. Random number generation, cumulative sums and incremental arrays are all fully vectorized in numpy. In a more general sense, it's usually not very effective to mix Python and numpy computational functions, including random .

Finally, you may want to consider a different convolution method. I would suggest something based on numpy.lib.stride_tricks.as_strided . This is a somewhat arcane, but very effective way to implement a sliding window with numpy arrays. I will show it here as an alternative to the convolution method you used, but feel free to ignore this part.

All in all:

import matplotlib
import matplotlib.pyplot as plt
import numpy as np

def movingaverage(values, window):
    # this step creates a view into the same buffer
    values = np.lib.stride_tricks.as_strided(values, shape=(window, values.size - window + 1), strides=values.strides * 2)
    smas = values.sum(axis=0)
    smas /= window  # in-place to avoid temp array
    return smas

sampleSize = 100
min = -10
max = 10
window = 5

v_x = np.arange(sampleSize)
v_y = np.cumsum(np.random.random_integers(min, max, sampleSize))

plt.plot(v_x, v_y)
plt.plot(v_x[window - 1:], movingaverage(v_y, window))
plt.show()

A note on names: in Python, variable and function names are conventionally name_with_underscore. CamelCase is reserved for class names. np.random.random_integers uses inclusive bounds just like random.randint , but allows you to specify the number of samples to generate. Confusingly, np.random.randint has an exclusive upper bound, more like random.randrange .