blocks|key|4687771|text|如果您对周期性信号的“平滑”版本感兴趣(如您的示例)，那么FFT是正确的方法。进行傅立叶变换，减去低贡献频率：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4687772|import+numpy+as+np
import+scipy.fftpack

N+=+100
x+=+np.linspace(0,2*np.pi,N)
y+=+np.sin(x)+%2B+np.random.random(N)+*+0.2

w+=+scipy.fftpack.rfft(y)
f+=+scipy.fftpack.rfftfreq(N,+x[1]-x[0])
spectrum+=+w**2

cutoff_idx+=+spectrum+<+(spectrum.max()/5)
w2+=+w.copy()
w2[cutoff_idx]+=+0

y2+=+scipy.fftpack.irfft(w2)|code-block|syntax|javascript|4687773|​|4687774|📷|atomic|offset|length|4687775|4687776|即使你的信号不是完全周期性的，这也能很好地消除白噪声。有许多类型的过滤器可供使用(高通、低通等)，适当的过滤器取决于您正在寻找的内容。|4687777|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/5271b32a5608cb80ccd887536ffdc597.png|imageAlt^0|0|0|0|0|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|10|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|11|8|@]|9|@]|A|$]]|$1|I|3|J|5|K|7|12|8|@]|9|@$L|13|M|14|1|15]]|A|$]]|$1|N|3|H|5|6|7|16|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|17|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X|Y|-4]]]]

If you are interested in a "smooth" version of a signal that is periodic (like your example), then a FFT is the right way to go. Take the fourier transform and subtract out the low-contributing frequencies:

<pre><code>import numpy as np
import scipy.fftpack

N = 100
x = np.linspace(0,2*np.pi,N)
y = np.sin(x) + np.random.random(N) * 0.2

w = scipy.fftpack.rfft(y)
f = scipy.fftpack.rfftfreq(N, x[1]-x[0])
spectrum = w**2

cutoff_idx = spectrum &lt; (spectrum.max()/5)
w2 = w.copy()
w2[cutoff_idx] = 0

y2 = scipy.fftpack.irfft(w2)
</code></pre>

<img src="https://i.stack.imgur.com/6zmHR.png" alt="enter image description here">

Even if your signal is not completely periodic, this will do a great job of subtracting out white noise. There a many types of filters to use (high-pass, low-pass, etc...), the appropriate one is dependent on what you are looking for.

blocks|key|181788|text|将移动平均值拟合到您的数据可以平滑噪声，请参阅此this+answer了解如何做到这一点。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|181789|如果您想使用LOWESS来拟合您的数据(它类似于移动平均，但更复杂)，您可以使用statsmodels库来实现：|181790|import+numpy+as+np
import+pylab+as+plt
import+statsmodels.api+as+sm

x+=+np.linspace(0,2*np.pi,100)
y+=+np.sin(x)+%2B+np.random.random(100)+*+0.2
lowess+=+sm.nonparametric.lowess(y,+x,+frac=0.1)

plt.plot(x,+y,+'%2B')
plt.plot(lowess[:,+0],+lowess[:,+1])
plt.show()|code-block|syntax|javascript|181791|最后，如果您知道信号的函数形式，您可以将曲线拟合到您的数据，这可能是最好的做法。|181792|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/11352216/54557|1|http://en.wikipedia.org/wiki/Local_regression|2|https://pypi.python.org/pypi/statsmodels^0|O|B|0|0|6|6|1|14|B|2|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|6|7|12|8|@]|9|@$A|13|B|14|1|15]|$A|16|B|17|1|18]]|C|$]]|$1|F|3|G|5|H|7|19|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|1A|8|@]|9|@]|C|$]]|$1|M|3|-4|5|6|7|1B|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]|U|$5|P|Q|R|C|$S|V]]|W|$5|P|Q|R|C|$S|X]]]]

Fitting a moving average to your data would smooth out the noise, see this <a href="https://stackoverflow.com/a/11352216/54557">this answer</a> for how to do that.

If you'd like to use <a href="http://en.wikipedia.org/wiki/Local_regression" rel="noreferrer">LOWESS</a> to fit your data (it's similar to a moving average but more sophisticated), you can do that using the <a href="https://pypi.python.org/pypi/statsmodels" rel="noreferrer">statsmodels</a> library:

<pre><code>import numpy as np
import pylab as plt
import statsmodels.api as sm

x = np.linspace(0,2*np.pi,100)
y = np.sin(x) + np.random.random(100) * 0.2
lowess = sm.nonparametric.lowess(y, x, frac=0.1)

plt.plot(x, y, '+')
plt.plot(lowess[:, 0], lowess[:, 1])
plt.show()
</code></pre>

Finally, if you know the functional form of your signal, you could fit a curve to your data, which would probably be the best thing to do.

blocks|key|4687828|text|另一种选择是在statsmodels中使用KernelReg|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4687829|from+statsmodels.nonparametric.kernel_regression+import+KernelReg
import+numpy+as+np
import+matplotlib.pyplot+as+plt

x+=+np.linspace(0,2*np.pi,100)
y+=+np.sin(x)+%2B+np.random.random(100)+*+0.2

#+The+third+parameter+specifies+the+type+of+the+variable+x;
#+'c'+stands+for+continuous
kr+=+KernelReg(y,x,'c')
plt.plot(x,+y,+'%2B')
y_pred,+y_std+=+kr.fit(x)

plt.plot(x,+y_pred)
plt.show()|code-block|syntax|javascript|4687830|entityMap|0|LINK|mutability|MUTABLE|url|https://www.statsmodels.org/stable/|1|https://www.statsmodels.org/stable/generated/statsmodels.nonparametric.kernel_regression.KernelReg.html^0|7|B|0|L|9|1|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]|$A|W|B|X|1|Y]]|C|$]]|$1|D|3|E|5|F|7|Z|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|10|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]|Q|$5|L|M|N|C|$O|R]]]]

Another option is to use <a href="https://www.statsmodels.org/stable/generated/statsmodels.nonparametric.kernel_regression.KernelReg.html" rel="noreferrer">KernelReg</a> in <a href="https://www.statsmodels.org/stable/" rel="noreferrer">statsmodels</a>:

<pre><code>from statsmodels.nonparametric.kernel_regression import KernelReg
import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0,2*np.pi,100)
y = np.sin(x) + np.random.random(100) * 0.2

# The third parameter specifies the type of the variable x;
# 'c' stands for continuous
kr = KernelReg(y,x,'c')
plt.plot(x, y, '+')
y_pred, y_std = kr.fit(x)

plt.plot(x, y_pred)
plt.show()
</code></pre>

blocks|key|4687858|text|编辑:查看this+answer。使用np.cumsum比使用np.convolve快得多|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4687859|基于移动平均框(通过卷积)，一种快速而粗糙的方法来平滑我使用的数据：|4687860|x+=+np.linspace(0,2*np.pi,100)
y+=+np.sin(x)+%2B+np.random.random(100)+*+0.8

def+smooth(y,+box_pts):
++++box+=+np.ones(box_pts)/box_pts
++++y_smooth+=+np.convolve(y,+box,+mode='same')
++++return+y_smooth

plot(x,+y,'o')
plot(x,+smooth(y,3),+'r-',+lw=2)
plot(x,+smooth(y,19),+'g-',+lw=2)|code-block|syntax|javascript|4687861|​|4687862|📷|atomic|4687863|4687864|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/34387987/4117624|1|IMAGE|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/42718b0f4ac7bc7637dc68a6e4de0a67.png|imageAlt^0|J|9|V|B|5|4|0|0|0|0|0|0|1|1|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|D|@$9|1B|A|1C|1|1D]]|E|$]]|$1|F|3|G|5|6|7|1E|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1F|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1G|8|@]|D|@]|E|$]]|$1|O|3|P|5|Q|7|1H|8|@]|D|@$9|1I|A|1J|1|1K]]|E|$]]|$1|R|3|N|5|6|7|1L|8|@]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1M|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|Z]]|10|$5|11|W|12|E|$13|14|15|-4]]]]

EDIT: look at <a href="https://stackoverflow.com/a/34387987/4117624">this</a> answer. Using <code>np.cumsum</code> is much faster than <code>np.convolve</code>
A quick and dirty way to smooth data I use, based on a moving average box (by convolution):
<pre><code>x = np.linspace(0,2*np.pi,100)
y = np.sin(x) + np.random.random(100) * 0.8

def smooth(y, box_pts):
 box = np.ones(box_pts)/box_pts
 y_smooth = np.convolve(y, box, mode='same')
 return y_smooth

plot(x, y,'o')
plot(x, smooth(y,3), 'r-', lw=2)
plot(x, smooth(y,19), 'g-', lw=2)
</code></pre>
<a href="https://i.stack.imgur.com/Jk4EV.png" rel="noreferrer"><img src="https://i.stack.imgur.com/Jk4EV.png" alt="enter image description here" /></a>

blocks|key|4687890|text|看看这个！对一维信号的平滑有一个明确的定义。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4687891|http://scipy-cookbook.readthedocs.io/items/SignalSmooth.html|offset|length|4687892|快捷方式：|4687893|import+numpy

def+smooth(x,window_len=11,window='hanning'):
++++"""smooth+the+data+using+a+window+with+requested+size.

++++This+method+is+based+on+the+convolution+of+a+scaled+window+with+the+signal.
++++The+signal+is+prepared+by+introducing+reflected+copies+of+the+signal+
++++(with+the+window+size)+in+both+ends+so+that+transient+parts+are+minimized
++++in+the+begining+and+end+part+of+the+output+signal.

++++input:
++++++++x:+the+input+signal+
++++++++window_len:+the+dimension+of+the+smoothing+window;+should+be+an+odd+integer
++++++++window:+the+type+of+window+from+'flat',+'hanning',+'hamming',+'bartlett',+'blackman'
++++++++++++flat+window+will+produce+a+moving+average+smoothing.

++++output:
++++++++the+smoothed+signal

++++example:

++++t=linspace(-2,2,0.1)
++++x=sin(t)%2Brandn(len(t))*0.1
++++y=smooth(x)

++++see+also:+

++++numpy.hanning,+numpy.hamming,+numpy.bartlett,+numpy.blackman,+numpy.convolve
++++scipy.signal.lfilter

++++TODO:+the+window+parameter+could+be+the+window+itself+if+an+array+instead+of+a+string
++++NOTE:+length(output)+!=+length(input),+to+correct+this:+return+y[(window_len/2-1):-(window_len/2)]+instead+of+just+y.
++++"""

++++if+x.ndim+!=+1:
++++++++raise+ValueError,+"smooth+only+accepts+1+dimension+arrays."

++++if+x.size+<+window_len:
++++++++raise+ValueError,+"Input+vector+needs+to+be+bigger+than+window+size."


++++if+window_len<3:
++++++++return+x


++++if+not+window+in+['flat',+'hanning',+'hamming',+'bartlett',+'blackman']:
++++++++raise+ValueError,+"Window+is+on+of+'flat',+'hanning',+'hamming',+'bartlett',+'blackman'"


++++s=numpy.r_[x[window_len-1:0:-1],x,x[-2:-window_len-1:-1]]
++++#print(len(s))
++++if+window+==+'flat':+#moving+average
++++++++w=numpy.ones(window_len,'d')
++++else:
++++++++w=eval('numpy.'%2Bwindow%2B'(window_len)')

++++y=numpy.convolve(w/w.sum(),s,mode='valid')
++++return+y




from+numpy+import+*
from+pylab+import+*

def+smooth_demo():

++++t=linspace(-4,4,100)
++++x=sin(t)
++++xn=x%2Brandn(len(t))*0.1
++++y=smooth(x)

++++ws=31

++++subplot(211)
++++plot(ones(ws))

++++windows=['flat',+'hanning',+'hamming',+'bartlett',+'blackman']

++++hold(True)
++++for+w+in+windows[1:]:
++++++++eval('plot('%2Bw%2B'(ws)+)')

++++axis([0,30,0,1.1])

++++legend(windows)
++++title("The+smoothing+windows")
++++subplot(212)
++++plot(x)
++++plot(xn)
++++for+w+in+windows:
++++++++plot(smooth(xn,10,w))
++++l=['original+signal',+'signal+with+noise']
++++l.extend(windows)

++++legend(l)
++++title("Smoothing+a+noisy+signal")
++++show()


if+__name__=='__main__':
++++smooth_demo()|code-block|syntax|javascript|4687894|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|1O|0|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@]|9|@$D|V|E|W|1|X]]|A|$]]|$1|F|3|G|5|6|7|Y|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|Z|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|C]]]]

Check this out! There is a clear definition of smoothing of a 1D signal.

<a href="http://scipy-cookbook.readthedocs.io/items/SignalSmooth.html" rel="noreferrer">http://scipy-cookbook.readthedocs.io/items/SignalSmooth.html</a>

Shortcut:

<pre><code>import numpy

def smooth(x,window_len=11,window='hanning'):
 """smooth the data using a window with requested size.

 This method is based on the convolution of a scaled window with the signal.
 The signal is prepared by introducing reflected copies of the signal 
 (with the window size) in both ends so that transient parts are minimized
 in the begining and end part of the output signal.

 input:
 x: the input signal 
 window_len: the dimension of the smoothing window; should be an odd integer
 window: the type of window from 'flat', 'hanning', 'hamming', 'bartlett', 'blackman'
 flat window will produce a moving average smoothing.

 output:
 the smoothed signal

 example:

 t=linspace(-2,2,0.1)
 x=sin(t)+randn(len(t))*0.1
 y=smooth(x)

 see also: 

 numpy.hanning, numpy.hamming, numpy.bartlett, numpy.blackman, numpy.convolve
 scipy.signal.lfilter

 TODO: the window parameter could be the window itself if an array instead of a string
 NOTE: length(output) != length(input), to correct this: return y[(window_len/2-1):-(window_len/2)] instead of just y.
 """

 if x.ndim != 1:
 raise ValueError, "smooth only accepts 1 dimension arrays."

 if x.size &lt; window_len:
 raise ValueError, "Input vector needs to be bigger than window size."


 if window_len&lt;3:
 return x


 if not window in ['flat', 'hanning', 'hamming', 'bartlett', 'blackman']:
 raise ValueError, "Window is on of 'flat', 'hanning', 'hamming', 'bartlett', 'blackman'"


 s=numpy.r_[x[window_len-1:0:-1],x,x[-2:-window_len-1:-1]]
 #print(len(s))
 if window == 'flat': #moving average
 w=numpy.ones(window_len,'d')
 else:
 w=eval('numpy.'+window+'(window_len)')

 y=numpy.convolve(w/w.sum(),s,mode='valid')
 return y




from numpy import *
from pylab import *

def smooth_demo():

 t=linspace(-4,4,100)
 x=sin(t)
 xn=x+randn(len(t))*0.1
 y=smooth(x)

 ws=31

 subplot(211)
 plot(ones(ws))

 windows=['flat', 'hanning', 'hamming', 'bartlett', 'blackman']

 hold(True)
 for w in windows[1:]:
 eval('plot('+w+'(ws) )')

 axis([0,30,0,1.1])

 legend(windows)
 title("The smoothing windows")
 subplot(212)
 plot(x)
 plot(xn)
 for w in windows:
 plot(smooth(xn,10,w))
 l=['original signal', 'signal with noise']
 l.extend(windows)

 legend(l)
 title("Smoothing a noisy signal")
 show()


if __name__=='__main__':
 smooth_demo()
</code></pre>

blocks|key|181948|text|如果要绘制时间序列图，并且已使用mtplotlib绘制图形，则使用中值方法对图形进行平滑处理。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|181949|smotDeriv+=+timeseries.rolling(window=20,+min_periods=5,+center=True).median()|code-block|syntax|javascript|181950|其中timeseries是您传递的数据集，您可以更改windowsize以实现更平滑。|offset|length|style|CODE|181951|​|181952|📷|atomic|181953|181954|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/6558fe3c38dee19bc501df1b46c34be8.png|imageAlt^0|0|0|2|A|Q|A|0|0|0|1|0|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|12|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|13|8|@$I|14|J|15|K|L]|$I|16|J|17|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|18|8|@]|9|@]|A|$]]|$1|O|3|P|5|Q|7|19|8|@]|9|@$I|1A|J|1B|1|1C]]|A|$]]|$1|R|3|N|5|6|7|1D|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z|10|-4]]]]

If you are plotting time series graph and if you have used mtplotlib for drawing graphs then use 
median method to smooth-en the graph

<pre><code>smotDeriv = timeseries.rolling(window=20, min_periods=5, center=True).median()
</code></pre>

where <code>timeseries</code> is your set of data passed you can alter <code>windowsize</code> for more smoothining. 

<a href="https://i.stack.imgur.com/zkwWD.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/zkwWD.png" alt=""></a>

blocks|key|4688009|text|对于我的一个项目，我需要为时间序列建模创建时间间隔，并且为了使过程更有效，我创建了tsmoothie：一个python库，用于以矢量化的方式对时间序列进行平滑和异常值检测。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4688010|它提供了不同的平滑算法以及计算间隔的可能性。|4688011|这里我使用的是ConvolutionSmoother，但你也可以用其他方法测试它。|style|CODE|4688012|import+numpy+as+np
import+matplotlib.pyplot+as+plt
from+tsmoothie.smoother+import+*

x+=+np.linspace(0,2*np.pi,100)
y+=+np.sin(x)+%2B+np.random.random(100)+*+0.2

#+operate+smoothing
smoother+=+ConvolutionSmoother(window_len=5,+window_type='ones')
smoother.smooth(y)

#+generate+intervals
low,+up+=+smoother.get_intervals('sigma_interval',+n_sigma=2)

#+plot+the+smoothed+timeseries+with+intervals
plt.figure(figsize=(11,6))
plt.plot(smoother.smooth_data[0],+linewidth=3,+color='blue')
plt.plot(smoother.data[0],+'.k')
plt.fill_between(range(len(smoother.data[0])),+low[0],+up[0],+alpha=0.3)|code-block|syntax|javascript|4688013|​|4688014|📷|atomic|4688015|4688016|我还指出，tsmoothie可以以向量化的方式执行多个时间序列的平滑。|4688017|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/cerlymarco/tsmoothie|1|IMAGE|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/a1758c3742a0230a6fecf4146f398436.png|imageAlt^0|15|9|0|0|0|7|J|0|0|0|0|1|1|0|0|0^^$0|@$1|2|3|4|5|6|7|1A|8|@]|9|@$A|1B|B|1C|1|1D]]|C|$]]|$1|D|3|E|5|6|7|1E|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|1F|8|@$A|1G|B|1H|H|I]]|9|@]|C|$]]|$1|J|3|K|5|L|7|1I|8|@]|9|@]|C|$M|N]]|$1|O|3|P|5|6|7|1J|8|@]|9|@]|C|$]]|$1|Q|3|R|5|S|7|1K|8|@]|9|@$A|1L|B|1M|1|1N]]|C|$]]|$1|T|3|P|5|6|7|1O|8|@]|9|@]|C|$]]|$1|U|3|V|5|6|7|1P|8|@]|9|@]|C|$]]|$1|W|3|-4|5|6|7|1Q|8|@]|9|@]|C|$]]]|X|$Y|$5|Z|10|11|C|$12|13]]|14|$5|15|10|16|C|$17|18|19|-4]]]]

For a project of mine, I needed to create intervals for time-series modeling, and to make the procedure more efficient I created <a href="https://github.com/cerlymarco/tsmoothie" rel="nofollow noreferrer">tsmoothie</a>: A python library for time-series smoothing and outlier detection in a vectorized way.
It provides different smoothing algorithms together with the possibility to computes intervals.
Here I use a <code>ConvolutionSmoother</code> but you can also test it others.
<pre><code>import numpy as np
import matplotlib.pyplot as plt
from tsmoothie.smoother import *

x = np.linspace(0,2*np.pi,100)
y = np.sin(x) + np.random.random(100) * 0.2

# operate smoothing
smoother = ConvolutionSmoother(window_len=5, window_type='ones')
smoother.smooth(y)

# generate intervals
low, up = smoother.get_intervals('sigma_interval', n_sigma=2)

# plot the smoothed timeseries with intervals
plt.figure(figsize=(11,6))
plt.plot(smoother.smooth_data[0], linewidth=3, color='blue')
plt.plot(smoother.data[0], '.k')
plt.fill_between(range(len(smoother.data[0])), low[0], up[0], alpha=0.3)
</code></pre>
<a href="https://i.stack.imgur.com/Nhau7.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/Nhau7.png" alt="enter image description here" /></a>
I point out also that tsmoothie can carry out the smoothing of multiple timeseries in a vectorized way

blocks|key|182103|text|使用移动平均，一种快速的方法(也适用于非双射函数)是|type|unstyled|depth|inlineStyleRanges|entityRanges|data|182104|def+smoothen(x,+winsize=5):
++++return+np.array(pd.Series(x).rolling(winsize).mean())[winsize-1:]|code-block|syntax|javascript|182105|此代码基于https://towardsdatascience.com/data-smoothing-for-data-science-visualization-the-goldilocks-trio-part-1-867765050615。在那里，还讨论了更高级的解决方案。|offset|length|182106|entityMap|0|LINK|mutability|MUTABLE|url|https://towardsdatascience.com/data-smoothing-for-data-science-visualization-the-goldilocks-trio-part-1-867765050615^0|0|0|5|38|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

Using a moving average, a quick way (that also works for non-bijective functions) is
<pre><code>def smoothen(x, winsize=5):
 return np.array(pd.Series(x).rolling(winsize).mean())[winsize-1:]
</code></pre>
This code is based on <a href="https://towardsdatascience.com/data-smoothing-for-data-science-visualization-the-goldilocks-trio-part-1-867765050615" rel="nofollow noreferrer">https://towardsdatascience.com/data-smoothing-for-data-science-visualization-the-goldilocks-trio-part-1-867765050615</a>. There, also more advanced solutions are discussed.

Lets assume we have a dataset which might be given approximately by

<pre><code>import numpy as np
x = np.linspace(0,2*np.pi,100)
y = np.sin(x) + np.random.random(100) * 0.2
</code></pre>

Therefore we have a variation of 20% of the dataset. My first idea was to use the UnivariateSpline function of scipy, but the problem is that this does not consider the small noise in a good way. If you consider the frequencies, the background is much smaller than the signal, so a spline only of the cutoff might be an idea, but that would involve a back and forth fourier transformation, which might result in bad behaviour.
Another way would be a moving average, but this would also need the right choice of the delay.

Any hints/ books or links how to tackle this problem?

<img src="https://i.stack.imgur.com/bcaCP.png" alt="example">

How to smooth a curve in the right way?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

让我们假设我们有一个数据集，该数据集可能近似为import numpy as npx = np.linspace(0,2*np.pi,100)y = np.sin(x) + np.random.random(100) * 0.2因此，我们有20%的数据集的变化。我的第一个想法是使用scipy的UnivariateSpl...

问如何以正确的方式平滑曲线？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何以正确的方式平滑曲线？EN