精华内容
下载资源
问答
  • 数据分析-数据平滑处理

    千次阅读 2019-01-22 09:11:10
    数据分析-数据平滑处理 数据平滑处理 在做数据分析时, 由于数据的噪声太多, 需要对数据进行数据平滑处理. 通常包含有降噪/拟合等操作. 降噪的功能在于去除额外的影响因素. 拟合的目的在于数学模型化,可以通过更多的...

    数据分析-数据平滑处理

    数据平滑处理

    在做数据分析时, 由于数据的噪声太多, 需要对数据进行数据平滑处理. 通常包含有降噪/拟合等操作. 降噪的功能在于去除额外的影响因素. 拟合的目的在于数学模型化,可以通过更多的数学方法识别曲线特征.

    降噪手段: 卷积运算

    # 通常卷积核的选取API
    con_core = np.hanning(8)
    con_core /= con_core.sum()
    # 卷积API
    np.convolve(samples, con_core, 'valid')
    

    数学模型化: 多项式拟合

    # 通过原函数曲线(x,y)/最高次数 得到 拟合多项式系数
    P = np.polyfit(x, y, n)
    # 通过多项式系数与x的值,求对应的多项式函数值.
    y = np.polyval(P, x)
    # 通过原函数求导函数
    Q = np.polyder(P)
    # 求多项式的根
    X = np.roots(Q)
    # 求两个多项式函数的差函数. 可以通过该方法求取两个多项式
    # 函数的交点
    Q = np.polysub(P1, P2)
    

    符号数组

    sign函数可以把样本数组变成对应的符号数组, 所有正数变为1, 负数变为-1, 0还是0.

    ary = np.sign(源数组)
    

    绘制 净额成交量(OBV)

    若相比上一天的收盘价上涨,则为正成交量; 若比上一天的收盘价下跌,则为负成交量.

    成交量可以反映市场对某支股票的人气, 成交量是一支股票上涨的能量. 一般情况下股票上涨往往需要较大的成交量,而下跌时则不然.

    案例: 绘制OBV柱状图

    import numpy as np
    import matplotlib.pyplot as mp
    import datetime as dt
    import matplotlib.dates as md
    
    
    def dmy2ymd(dmy):
        dmy = str(dmy, encoding='utf-8')
        date = dt.datetime.strptime(
            dmy, '%d-%m-%Y').date()
        s = date.strftime("%Y-%m-%d")
        return s
    
    # 加载文件
    dates, closing_prices, volumes = np.loadtxt(
        '../data/bhp.csv', delimiter=',',
        usecols=(1, 6, 7), unpack=True,
        dtype='M8[D], f8, f8',
        converters={1: dmy2ymd})
    
    # 获取相比上一天股价是否上涨
    diff_closing_prices = np.diff(closing_prices)
    # 获取相对应的符号数组
    sign_closing_prices = np.sign(diff_closing_prices)
    # 绘制每天的成交量
    obvs = volumes[1:] * sign_closing_prices
    
    # 绘制净额成交量柱状图
    mp.figure('OBV', facecolor='lightgray')
    mp.title('OBV', fontsize=18)
    mp.xlabel('Dates', fontsize=14)
    mp.ylabel('Volumes', fontsize=14)
    # 整理x轴刻度定位器
    ax = mp.gca()
    ax.xaxis.set_major_locator(
        md.WeekdayLocator(byweekday=md.MO))
    ax.xaxis.set_major_formatter(
        md.DateFormatter('%d %b %Y'))
    ax.xaxis.set_minor_locator(md.DayLocator())
    
    mp.tick_params(labelsize=10)
    mp.grid(linestyle=':', axis='y')
    dates = dates[1:].astype(md.datetime.datetime)
    
    mp.bar(dates, obvs, 1.0, color='dodgerblue',
           edgecolor='white', label='OBV')
    
    mp.gcf().autofmt_xdate()
    mp.legend()
    mp.show()
    

    数组预处理函数

    # array 源数组
    # 条件序列:  [a<60, a==60, a>60]
    # 取值序列:  [-1,   0,     1   ]
    np.piecewise(array, 条件序列, 取值序列)
    

    测试:

    a = np.array([23, 94, 65, 23, 84, 56, 23])
    d = np.piecewise(
        a,
        [(20 < a) & (a < 60), a == 60, a > 60],
        [-1, 0, 1])
    print(d)
    

    矢量化

    矢量化指的是用数组代理标量来操作数组里的每个元素.

    numpy提供了vectorize函数, 可以把处理标量的函数矢量化. 经过vectorize函数矢量化处理过后将会返回一个矢量函数, 该函数可以直接处理ndarray数组.

    案例:

    import numpy as np
    import math as m
    
    def foo(x, y):
        return m.sqrt(x**2 + y**2)
    
    x, y = 3, 4
    print(foo(x, y))
    x = np.array([3, 4, 5, 6])
    y = np.array([4, 5, 6, 7])
    # z = foo(x, y)  错误
    # 把foo函数矢量化处理
    foo_v = np.vectorize(foo)
    print(foo_v(x, y))
    

    numpy提供了frompyfunc函数, 也可以完成vectorize相同的功能

    # 使用frompyfunc方法矢量化函数
    # foo需要2个参数, 最终将会有1个返回值
    foo_f = np.frompyfunc(foo, 2, 1)
    print(foo_f(x, y))
    

    矩阵

    numpy.matrix类型用来描述矩阵. 该类继承自numpy.ndarray. 任何多维数组的操作,对矩阵同样有效. 但是作为子类矩阵又结合了自身的特点,做了必要的扩充,比如乘法计算/矩阵求逆等等.

    矩阵的创建

    # ary: 任何可以被解释为矩阵的二维容器
    # copy: 如果copy的值为True(缺省), 所得到的矩阵对象与参
    # 数中源容器各自拥有独立的数据拷贝.否则,共享同一份数据
    numpy.matrix(ary, copy=True)
    
    # ary: 任何可以被解释为矩阵的二维容器
    # 默认copy=False
    numpy.mat(ary)
    
    # str: 字符串矩阵拼块规则
    #      '1 2 3;4 5 6;7 8 9'
    np.mat(str)
    

    矩阵的乘法运算

    '''
    a * b
    矩阵的乘法:a矩阵的每一行分别乘以b矩阵的每一列
    结果矩阵的行数与a的行数一致, 结果矩阵的列数与b的列数一致
    '''
    e = np.mat('1 2 6; 3 5 7; 4 8 9')
    print(e * e)
    

    矩阵的逆矩阵

    若两个矩阵A/B满足: AB = BA = E (单位矩阵),则 A/B互为逆矩阵.

    单位矩阵: 矩阵的主对角线值为1, 其他位置值为0的矩阵.

    e = np.mat(..)
    print(e.I)  #逆矩阵
    

    案例 : 春游, 去程做大巴, 小孩票价3元, 家长票价3.2元, 一共花了118.4; 回程做火车, 小孩3.5, 家长3.6, 花了135.2; 求小孩与家长的人数.

    \left[ \begin{array}{ccc}
    x & y
    \end{array} \right]
    \times
    \left[ \begin{array}{ccc}
    3 & 3.5 \
    3.2 & 3.6 \
    \end{array} \right]

    \left[ \begin{array}{ccc}
    118.4 & 135.2
    \end{array} \right]

    斐波那契数列

    1 1 2 3 5 8 13 ...
    
         1 1  1 1  1 1  1 1
      X  1 0  1 0  1 0  1 0 
    ---------------------------------------------
    1 1  2 1  3 2  5 3
    1 0  1 1  2 1  3 2  ...
    

    numpy通用函数

    加法通用函数

    np.add(a, b)			# 两数组相加
    np.add.reduce(a)		# a数组元素的累加和
    np.add.accumulate(a)	# a数组元素累加和的过程
    np.add.outer([10,20,30], a)	#外和
    

    案例:

    a = np.arange(1, 7)
    print(a)
    print(np.add(a, a))
    print(np.add.reduce(a))
    print(np.add.accumulate(a))
    print(np.add.outer(a, [10, 20, 30]))
    

    除法通用函数

    # 真除
    a / b
    np.true_divide(a, b)
    np.divide(a, b)
    # 地板除
    np.floor_divide(a, b)
    np.ceil(a / b)	# 天花板除
    np.trunc(a / b) # 截断除
    
    import numpy as np
    
    a = np.array([20, 20, -20, -20])
    b = np.array([3, -3, 6, -6])
    print(a)
    print(b)
    # 开始测试
    print(np.true_divide(a, b))
    print(np.divide(a, b))
    
    print(np.floor_divide(a, b))
    print(np.ceil(a / b))
    print(np.trunc(a / b))
    

    三角函数通用函数

    np.sin()  np.cos()
    

    傅里叶定理

    傅里叶说过, 任何周期函数都可以由多个不同振幅/频率/相位的正弦函数叠加而成.

    合成方波

    一个方波由如下参数的正弦波叠加而成:

    y = 4\pi \times sin(x) \
    y = \frac{4}{3}\pi \times sin(3x) \
    y = \frac{4}{5}\pi \times sin(5x) \
    y = \frac{4}{7}\pi \times sin(7x) \
    … \
    y = \frac{4}{2n-1}\pi \times sin((2n-1)x) \

    案例:

    import numpy as np
    import matplotlib.pyplot as mp
    
    x = np.linspace(-2 * np.pi, 2 * np.pi, 1000)
    # 根据公式搞出来3条曲线
    y1 = 4 * np.pi * np.sin(x)
    y2 = 4 / 3 * np.pi * np.sin(3 * x)
    y3 = 4 / 5 * np.pi * np.sin(5 * x)
    
    # 使用循环控制叠加波的数量
    n = 1000
    y = np.zeros(1000)
    for i in range(1, n + 1):
        y += 4 / (2 * i - 1) * np.pi * \
            np.sin((2 * i - 1) * x)
    
    mp.figure('SIN', facecolor='lightgray')
    mp.title('SIN', fontsize=18)
    mp.xlabel('X', fontsize=14)
    mp.ylabel('Y', fontsize=14)
    mp.tick_params(labelsize=10)
    
    mp.plot(x, y1, label='y1')
    mp.plot(x, y2, label='y2')
    mp.plot(x, y3, label='y3')
    mp.plot(x, y, label='y')
    
    mp.legend()
    mp.show()
    

    位运算通用函数

    位异或

    c = a ^ b
    c = np.bitwise_xor(a, b)
    

    按位异或可以很方便的判断两个数据是否同号

    a = np.array([4, -6, 7, -3, -4, 2])
    b = np.array([-2, -8, 2, -5, 3, -4])
    
    print(a)
    print(b)
    print(a ^ b)
    print(np.bitwise_xor(a, b))
    # where找到符合条件的元素下标 (异号)
    print(np.where((a ^ b) < 0)[0])
    

    位与

    e = a & b
    e = np.bitwise_and(a, b)
    

    利用位与运算计算某个数字是否是2的幂

    '''
    1  2^0  00001    0  00000
    2  2^1  00010    1  00001
    4  2^2  00100    3  00011
    8  2^3  01000    7  00111
    '''
    print('-' * 40)
    d = np.arange(1, 20)
    print(d)
    e = np.bitwise_and(d, d - 1)
    print(e)
    

    位或 / 位反 / 移位

    # 位或操作
    np.bitwise_or(a, b)
    # 位反操作 (1变0, 0变1)
    np.bitwise_not(a)
    # 移位操作
    np.left_shift(array, 1)		#每个元素左移1位 (乘2)
    np.right_shift(array, 1)	#每个元素右移1位 (除2)
    

    numpy提供的线性代数模块(linalg)

    逆矩阵和广义逆矩阵

    如果一个方阵A与方阵B的乘积是单位矩阵,则AB互为逆矩阵.

    np.linalg.inv(A)  # 返回A方阵的逆矩阵
    

    如果A不是方阵, A的逆矩阵则称为广义逆矩阵.

    np.linalg.pinv(A) # 返回矩阵A的广义逆矩阵
    
    d = A.I # 既可以返回逆矩阵也可以返回广义逆矩阵
    

    线性方程求解与线性拟合

    # 求解线性方程组
    c = np.linalg.solve(a, b)
    # 线性拟合(求出误差最小的结果矩阵)
    c = np.linalg.lstsq(a, b)[0]
    

    \begin{cases}
    x -2y+z=0\
    2y-8z=8\
    -4x+5y+9z=-9
    \end{cases}

    展开全文
  • Untiy中的数据平滑处理

    千次阅读 2016-02-17 14:28:51
    作者:cartzhang数据平滑处理由于需要处理硬件的传给数据,硬件是其他商家的。 坑爹的是发送频率太低了,20HZ左右,也是服气了。好处有么,肯定是便宜。 这个用在VR游戏上,不做评论了。 既然这样,

    本文章由cartzhang编写,转载请注明出处。 所有权利保留。
    文章链接:http://blog.csdn.net/cartzhang/article/details/50680237
    作者:cartzhang

    数据平滑处理

    由于需要处理硬件的传给数据,硬件是其他商家的。
    坑爹的是发送频率太低了,20HZ左右,也是服气了。好处有么,肯定是便宜。
    这个用在VR游戏上,不做评论了。
    既然这样,生活还得继续!!!
    怎么办?

    插值

    第一考虑的就是插值。
    插值,内插和外推插值。插值算法,有多种,5点,7点,二次插值等,不一一列举。
    游戏的帧率在DK2上75fps,这帧率插值,需要至少有2秒数据,再加上硬件数据的抖动,个人觉得这不算是个好的方案。

    缓动函数

    在ITween中有个缓动曲线函数。
    这个不错啊!我们来细说下。

    1.先看看各种函数都长啥样?

    截图:
    曲线

    2.网址介绍

    相关网址啊:
    http://easings.net/zh-cn#

    说明网址上的各个图都是可以点开,动态的哦。

    http://robertpenner.com/easing/easing_demo.html
    这个也是可以看看每个曲线的样子。真是方便啊!!

    微软msdn上带有代码和图例的
    https://msdn.microsoft.com/zh-cn/library/ee308751.aspx

    3.在看看所有曲线种类。

    可以在ITween中找到EaseType.

        /// <summary>
        /// The type of easing to use based on Robert Penner's open source easing equations (http://www.robertpenner.com/easing_terms_of_use.html).
        /// </summary>
        public enum EaseType{
            easeInQuad,
            easeOutQuad,
            easeInOutQuad,
            easeInCubic,
            easeOutCubic,
            easeInOutCubic,
            easeInQuart,
            easeOutQuart,
            easeInOutQuart,
            easeInQuint,
            easeOutQuint,
            easeInOutQuint,
            easeInSine,
            easeOutSine,
            easeInOutSine,
            easeInExpo,
            easeOutExpo,
            easeInOutExpo,
            easeInCirc,
            easeOutCirc,
            easeInOutCirc,
            linear,
            spring,
            /* GFX47 MOD START */
            //bounce,
            easeInBounce,
            easeOutBounce,
            easeInOutBounce,
            /* GFX47 MOD END */
            easeInBack,
            easeOutBack,
            easeInOutBack,
            /* GFX47 MOD START */
            //elastic,
            easeInElastic,
            easeOutElastic,
            easeInOutElastic,
            /* GFX47 MOD END */
            punch
        }

    根据需要各区所需啊!!不一定要全部都带上。

    4. 函数代码:

    ITween中这个代码比较长,代码中更多的是算法。
    代码在ITween.cs中,就不一一贴上来。

    缓动曲线代码

    我需要的只有这些曲线,其他的不需要,就摘了出来,写成了静态函数,这样方便在需要时候直接调用。

    /**************************************************************************
    Copyright:@cartzhang
    Author: cartzhang
    Date:
    Description:
    **************************************************************************/
    using UnityEngine;
    using System.Collections;
    
    public enum EaseType:int
    {
        easeInQuad,
        //easeOutQuad,
        easeInOutQuad,
        easeInCubic,
        //easeOutCubic,
        easeInOutCubic,
        easeInQuart,
        //easeOutQuart,
        easeInOutQuart,
        easeInQuint,
        //easeOutQuint,
        easeInOutQuint,
        //easeInSine,
        //easeOutSine,
        //easeInOutSine,
        easeInExpo,
        //easeOutExpo,
        easeInOutExpo,
        //easeInCirc,
        //easeOutCirc,
        easeInOutCirc,
        //linear,
        //spring,
        ///* GFX47 MOD START */
        ////bounce,
        //easeInBounce,
        //easeOutBounce,
        //easeInOutBounce,
        ///* GFX47 MOD END */
        //easeInBack,
        //easeOutBack,
        //easeInOutBack,
        ///* GFX47 MOD START */
        ////elastic,
        //easeInElastic,
        //easeOutElastic,
        //easeInOutElastic,
        ///* GFX47 MOD END */
        //punch
    }
    
    public class DataAlgorithm
    {
    
        #region Easing Curves
    
        public static float linear(float start, float end, float value)
        {
            return Mathf.Lerp(start, end, value);
        }
    
        public static float clerp(float start, float end, float value)
        {
            float min = 0.0f;
            float max = 360.0f;
            float half = Mathf.Abs((max - min) / 2.0f);
            float retval = 0.0f;
            float diff = 0.0f;
            if ((end - start) < -half)
            {
                diff = ((max - start) + end) * value;
                retval = start + diff;
            }
            else if ((end - start) > half)
            {
                diff = -((max - end) + start) * value;
                retval = start + diff;
            }
            else retval = start + (end - start) * value;
            return retval;
        }
    
        public static float spring(float start, float end, float value)
        {
            value = Mathf.Clamp01(value);
            value = (Mathf.Sin(value * Mathf.PI * (0.2f + 2.5f * value * value * value)) * Mathf.Pow(1f - value, 2.2f) + value) * (1f + (1.2f * (1f - value)));
            return start + (end - start) * value;
        }
    
        public static float easeInQuad(float start, float end, float value)
        {
            end -= start;
            return end * value * value + start;
        }
    
        public static float easeOutQuad(float start, float end, float value)
        {
            end -= start;
            return -end * value * (value - 2) + start;
        }
    
        public static float easeInOutQuad(float start, float end, float value)
        {
            value /= .5f;
            end -= start;
            if (value < 1) return end / 2 * value * value + start;
            value--;
            return -end / 2 * (value * (value - 2) - 1) + start;
        }
    
        public static float easeInCubic(float start, float end, float value)
        {
            end -= start;
            return end * value * value * value + start;
        }
    
        public static float easeOutCubic(float start, float end, float value)
        {
            value--;
            end -= start;
            return end * (value * value * value + 1) + start;
        }
    
        public static float easeInOutCubic(float start, float end, float value)
        {
            value /= .5f;
            end -= start;
            if (value < 1) return end / 2 * value * value * value + start;
            value -= 2;
            return end / 2 * (value * value * value + 2) + start;
        }
    
        public static float easeInQuart(float start, float end, float value)
        {
            end -= start;
            return end * value * value * value * value + start;
        }
    
        public static float easeOutQuart(float start, float end, float value)
        {
            value--;
            end -= start;
            return -end * (value * value * value * value - 1) + start;
        }
    
        public static float easeInOutQuart(float start, float end, float value)
        {
            value /= .5f;
            end -= start;
            if (value < 1) return end / 2 * value * value * value * value + start;
            value -= 2;
            return -end / 2 * (value * value * value * value - 2) + start;
        }
    
        public static float easeInQuint(float start, float end, float value)
        {
            end -= start;
            return end * value * value * value * value * value + start;
        }
    
        public static float easeOutQuint(float start, float end, float value)
        {
            value--;
            end -= start;
            return end * (value * value * value * value * value + 1) + start;
        }
    
        public static float easeInOutQuint(float start, float end, float value)
        {
            value /= .5f;
            end -= start;
            if (value < 1) return end / 2 * value * value * value * value * value + start;
            value -= 2;
            return end / 2 * (value * value * value * value * value + 2) + start;
        }
    
        public static float easeInSine(float start, float end, float value)
        {
            end -= start;
            return -end * Mathf.Cos(value / 1 * (Mathf.PI / 2)) + end + start;
        }
    
        public static float easeOutSine(float start, float end, float value)
        {
            end -= start;
            return end * Mathf.Sin(value / 1 * (Mathf.PI / 2)) + start;
        }
    
        public static float easeInOutSine(float start, float end, float value)
        {
            end -= start;
            return -end / 2 * (Mathf.Cos(Mathf.PI * value / 1) - 1) + start;
        }
    
        public static float easeInExpo(float start, float end, float value)
        {
            end -= start;
            return end * Mathf.Pow(2, 10 * (value / 1 - 1)) + start;
        }
    
        public static float easeOutExpo(float start, float end, float value)
        {
            end -= start;
            return end * (-Mathf.Pow(2, -10 * value / 1) + 1) + start;
        }
    
        public static float easeInOutExpo(float start, float end, float value)
        {
            value /= .5f;
            end -= start;
            if (value < 1) return end / 2 * Mathf.Pow(2, 10 * (value - 1)) + start;
            value--;
            return end / 2 * (-Mathf.Pow(2, -10 * value) + 2) + start;
        }
    
        public static float easeInCirc(float start, float end, float value)
        {
            end -= start;
            return -end * (Mathf.Sqrt(1 - value * value) - 1) + start;
        }
    
        public static float easeOutCirc(float start, float end, float value)
        {
            value--;
            end -= start;
            return end * Mathf.Sqrt(1 - value * value) + start;
        }
    
        public static float easeInOutCirc(float start, float end, float value)
        {
            value /= .5f;
            end -= start;
            if (value < 1) return -end / 2 * (Mathf.Sqrt(1 - value * value) - 1) + start;
            value -= 2;
            return end / 2 * (Mathf.Sqrt(1 - value * value) + 1) + start;
        }
    
        /* GFX47 MOD START */
        public static float easeInBounce(float start, float end, float value)
        {
            end -= start;
            float d = 1f;
            return end - easeOutBounce(0, end, d - value) + start;
        }
        /* GFX47 MOD END */
    
        /* GFX47 MOD START */
        //public static float bounce(float start, float end, float value){
        public static float easeOutBounce(float start, float end, float value)
        {
            value /= 1f;
            end -= start;
            if (value < (1 / 2.75f))
            {
                return end * (7.5625f * value * value) + start;
            }
            else if (value < (2 / 2.75f))
            {
                value -= (1.5f / 2.75f);
                return end * (7.5625f * (value) * value + .75f) + start;
            }
            else if (value < (2.5 / 2.75))
            {
                value -= (2.25f / 2.75f);
                return end * (7.5625f * (value) * value + .9375f) + start;
            }
            else
            {
                value -= (2.625f / 2.75f);
                return end * (7.5625f * (value) * value + .984375f) + start;
            }
        }
        /* GFX47 MOD END */
    
        /* GFX47 MOD START */
        public static float easeInOutBounce(float start, float end, float value)
        {
            end -= start;
            float d = 1f;
            if (value < d / 2) return easeInBounce(0, end, value * 2) * 0.5f + start;
            else return easeOutBounce(0, end, value * 2 - d) * 0.5f + end * 0.5f + start;
        }
        /* GFX47 MOD END */
    
        public static float easeInBack(float start, float end, float value)
        {
            end -= start;
            value /= 1;
            float s = 1.70158f;
            return end * (value) * value * ((s + 1) * value - s) + start;
        }
    
        public static float easeOutBack(float start, float end, float value)
        {
            float s = 1.70158f;
            end -= start;
            value = (value / 1) - 1;
            return end * ((value) * value * ((s + 1) * value + s) + 1) + start;
        }
    
        public static float easeInOutBack(float start, float end, float value)
        {
            float s = 1.70158f;
            end -= start;
            value /= .5f;
            if ((value) < 1)
            {
                s *= (1.525f);
                return end / 2 * (value * value * (((s) + 1) * value - s)) + start;
            }
            value -= 2;
            s *= (1.525f);
            return end / 2 * ((value) * value * (((s) + 1) * value + s) + 2) + start;
        }
    
        public static float punch(float amplitude, float value)
        {
            float s = 9;
            if (value == 0)
            {
                return 0;
            }
            if (value == 1)
            {
                return 0;
            }
            float period = 1 * 0.3f;
            s = period / (2 * Mathf.PI) * Mathf.Asin(0);
            return (amplitude * Mathf.Pow(2, -10 * value) * Mathf.Sin((value * 1 - s) * (2 * Mathf.PI) / period));
        }
    
        /* GFX47 MOD START */
        public static float easeInElastic(float start, float end, float value)
        {
            end -= start;
    
            float d = 1f;
            float p = d * .3f;
            float s = 0;
            float a = 0;
    
            if (value == 0) return start;
    
            if ((value /= d) == 1) return start + end;
    
            if (a == 0f || a < Mathf.Abs(end))
            {
                a = end;
                s = p / 4;
            }
            else
            {
                s = p / (2 * Mathf.PI) * Mathf.Asin(end / a);
            }
    
            return -(a * Mathf.Pow(2, 10 * (value -= 1)) * Mathf.Sin((value * d - s) * (2 * Mathf.PI) / p)) + start;
        }
        /* GFX47 MOD END */
    
        /* GFX47 MOD START */
        //public static float elastic(float start, float end, float value){
        public static float easeOutElastic(float start, float end, float value)
        {
            /* GFX47 MOD END */
            //Thank you to rafael.marteleto for fixing this as a port over from Pedro's UnityTween
            end -= start;
    
            float d = 1f;
            float p = d * .3f;
            float s = 0;
            float a = 0;
    
            if (value == 0) return start;
    
            if ((value /= d) == 1) return start + end;
    
            if (a == 0f || a < Mathf.Abs(end))
            {
                a = end;
                s = p / 4;
            }
            else
            {
                s = p / (2 * Mathf.PI) * Mathf.Asin(end / a);
            }
    
            return (a * Mathf.Pow(2, -10 * value) * Mathf.Sin((value * d - s) * (2 * Mathf.PI) / p) + end + start);
        }
    
        /* GFX47 MOD START */
        public static float easeInOutElastic(float start, float end, float value)
        {
            end -= start;
    
            float d = 1f;
            float p = d * .3f;
            float s = 0;
            float a = 0;
    
            if (value == 0) return start;
    
            if ((value /= d / 2) == 2) return start + end;
    
            if (a == 0f || a < Mathf.Abs(end))
            {
                a = end;
                s = p / 4;
            }
            else
            {
                s = p / (2 * Mathf.PI) * Mathf.Asin(end / a);
            }
    
            if (value < 1) return -0.5f * (a * Mathf.Pow(2, 10 * (value -= 1)) * Mathf.Sin((value * d - s) * (2 * Mathf.PI) / p)) + start;
            return a * Mathf.Pow(2, -10 * (value -= 1)) * Mathf.Sin((value * d - s) * (2 * Mathf.PI) / p) * 0.5f + end + start;
        }
        /* GFX47 MOD END */
    
        #endregion
    
    }
    

    总结:

    这个使用还是非常方便的。对于数据的处理和抖动,目前来看还是比较有用的。

    这么实用有好用 的东西,当然要记录下来,仅供参考。


    若有问题,请随时联系!!
    非常感谢!!!!

    新年好

    展开全文
  • 10.数据平滑处理

    万次阅读 2017-09-19 15:32:22
    我们在上一篇文章中可以看到,我们的数据是不平滑的,这对拟合来说就有影响,而且有的噪声数据会影响拟合的函数的准确性.所以在对数据拟合前,应该进行平滑 移动平均线和窗函数

    我们在上一篇文章中可以看到,我们的数据是不平滑的,这对拟合来说就有影响,而且有的噪声数据会影响拟合的函数的准确性.所以在对数据拟合前,应该进行平滑处理

    简单移动平均线

    简单移动平均线是计算与等权重的指示函数的卷积,也可以不等权重.
    1.用ones函数创建一个元素均为1的数组,然后对整个数组除以N,得到等权重.
    2.使用权值,调用convolve函数.
    3.从convolve函数分安徽的数组中取出中间的长度为N的部分(即两者作卷积运算时完全重叠的区域.)
    4.使用matplotlib绘图

    import numpy as np
    import matplotlib.pyplot as plt
    import sys
    
    N=int(sys.argv[1])
    weights=np.ones(N)/N
    print("WEIGHTS",weights)
    
    c=np.loadtxt('/home/syd/Documents/stockdata.csv',delimiter=',',
    skiprows=(2),usecols=(2,),unpack=True)
    sam=np.convolve(weights,c)[N-1:-N+1]
    t=np.arange(N-1,len(c))
    
    plt.plot(t,c[N-1:],lw=1.0)
    plt.plot(t,sam,lw=2.0)
    plt.show()
    

    这里写图片描述

    窗函数:hanning汉宁窗

    汉宁窗是一个加权余弦窗函数.numpy.hanning(M) Return the Hanning window.

    Parameters: M : int
    Number of points in the output window. If zero or
    Returns: out : ndarray, shape(M,)
    The window, with the maximum value normalized to one (the value one
    appears only if M is odd).

    1.调用hanning函数计算权重,生成一个长度为N的窗口,输入参数N

    N=int(sys.argv[1])
    weights=np.hanning(N)
    print(weights)

    2.使用convolve,进行卷积运算.然后绘图.

    import numpy as np
    import matplotlib.pyplot as plt
    import sys
    
    N=int(sys.argv[1])
    weights=np.hanning(N)
    print("WEIGHTS",weights)
    
    c=np.loadtxt('/home/syd/Documents/stockdata.csv',delimiter=',',
    skiprows=(2),usecols=(2,),unpack=True)
    sam=np.convolve(weights/weights.sum(),c)[N-1:-N+1]
    t=np.arange(N-1,len(c))
    
    plt.plot(t,c[N-1:],lw=1.0)
    plt.plot(t,sam,lw=2.0)
    plt.show()
    

    这里写图片描述
    这里写图片描述

    展开全文
  • 本博客适用于数字高程模型的平滑处理,对于其他数据平滑处理仅做参考 平滑处理公式采用Daly1984 Daly C1994_A statistical topographic model for mapping climatological precipitation over mountainous terrain...

    本博客适用于数字高程模型的平滑处理,对于其他数据的平滑处理仅作参考
    平滑处理公式采用Daly1984
    Daly C1994_A statistical topographic model for mapping climatological precipitation over mountainous terrain.
    ele(m,n) = 0.5ele(m,n)+0.125(ele(m-1,n)+ele(m+1,n)+ele(m,n-1)+ele(m,n+1))
    即中心点的高程由自身和上下左右四个点的高程加权平均得到
    (这里就涉及边界位置处的点如何处理的问题,我的做法是给栅格额外再加一圈0值,根据0的个数改变权重,实现边界位置点的高程平滑)

    MATLAB代码如下:

    %% 此代码是用于平滑处理DEM数据
    %计算公式(Daly,1984) 
    %ele(m,n) = 0.5ele(m,n)+0.125(ele(m-1,n)+ele(m+1,n)+ele(m,n-1)+ele(m,n+1))
    %为了方便处理边界位置处的点,给栅格矩阵额外加一圈
    clc
    clear
    
    %% 读取数据
    [DEM,GeoRef] = geotiffread('Resample.tif');   %GeoRef存储tif文件的地理空间信息
    [x,y] = size(DEM);                            %存储tif文件的栅格大小
    lat = GeoRef.LatitudeLimits;                  %存储tif文件的维度范围
    lon = GeoRef.LongitudeLimits;                 %存储tif文件的经度范围
    DEM(DEM==-32768) = 0;                         %将背景值换成0,之后统一处理
    
    %% 给DEM矩阵再加外围一圈,方便之后边界位置的处理
    DEM = [zeros(x,1),DEM];    %最左侧加一列
    DEM = [DEM,zeros(x,1)];    %最右侧加一列
    DEM = [zeros(1,y+2);DEM];  %最上侧加一行
    DEM = [DEM;zeros(1,y+2)];  %最下侧加一行
    DEM_origine = DEM;         %存储此时的矩阵,方便检查,看有没有出错
    
    %% 平滑处理
    for t = 1:40               %平滑处理的重复次数,最多40次
        for i = 2:x+1
            for j = 2:y+1
                if DEM(i,j) == 0                 %0意味着背景值或者最外围一圈,跳过
                    continue
                else           
                    a = sum([DEM(i-1,j),DEM(i+1,j),DEM(i,j-1),DEM(i,j+1)]==0);   %计算目标栅格周围为0的栅格数
                    %计算中心点的高程,4/(4-a)会根据周围0的个数而变化,从而改变权重,默认不出现周围全是0的情况,a在0-3之间
                    DEM(i,j) = 0.5*DEM(i,j)+0.125*4/(4-a)*(DEM(i-1,j)+DEM(i+1,j)+DEM(i,j-1)+DEM(i,j+1));
                end
            end
        end
        if t == 8||t == 16||t == 24||t == 32||t == 40     %重复平滑处理8、16等次数后输出图像
            DEM_out = DEM;
            DEM_out(:,16) = [];
            DEM_out(:,1) = [];
            DEM_out(15,:) = [];
            DEM_out(1,:) = [];                   %删掉外围一圈
            DEM_out(DEM_out==0) = -32768;        %将0值变回之前的默认背景值
            R = georasterref('RasterSize', size(DEM_out),'Latlim', [double(min(lat))...
                double(max(lat))], 'Lonlim', [double(min(lon)) double(max(lon))]); %记录空间坐标信息
            R.ColumnsStartFrom = 'north';
            geotiffwrite(['F:\Data of China Flash Flood\DEM_smoothing_test\Resample_tif\smoothed',num2str(t),'times','.tif'],DEM_out,R);     %保存绘制的地理栅格图像
        end
    end
    disp('finish!')
    

    以上代码的参考文献有:
    MATLAB nc文件转tif (可视化范例)
    Matlab:Save as GeoTiff Format

    效果如下:
    在这里插入图片描述

    展开全文
  • MATLAB中数据平滑处理

    万次阅读 多人点赞 2017-05-05 14:31:40
    试调用smoothts函数对日收盘价数据进行平滑处理 绘制日收盘价曲线图: % 从文件examp7_1_2.xls中读取数据 >> x = xlsread('examp7_1_2.xls'); >> price = x(:,4)'; % 提取矩阵x的第4列数据...
  • numpy之数据平滑处理

    千次阅读 2019-07-10 20:14:00
    数据平滑:通常包含降噪、拟合等操作。降噪的功能在于去除额外的影响因素,拟合的目的在于数学模型化,可以通过更多的数学方法识别曲线的特征。 2.绘制两支股票的收益率 ---收益率 =(后一天的收盘价 - 前一天的...
  • 数据平滑处理——log1p()和exmp1()

    万次阅读 多人点赞 2018-09-05 14:58:53
    今天在做题的时候学到了一点有用的东西,所以这里做个记录分享一下,有关数据预处理... 平滑处理很容易被忽略掉,导致模型的结果总是达不到一定的标准,同样使用逼格更高的log1p能避免复值得问题——复值指一个自变...
  • Kinect API 自带骨骼数据平滑处理

    千次阅读 2014-06-16 21:49:47
    如何平滑处理Kinect采集的骨骼数据 | KinectAPI编程 1. What causes skeleton jitters? Though the skeleton jitters could be caused by the application performance due to both software and hardware,...
  • 效果展示 代码展示 import pandas as pd import matplotlib.pyplot as plt plt.subplot(2,2,2) pd.Series(accs_train, index=iters).ewm(span=10).mean().plot(label='EMA_train_accs') pd.Series(accs_train, ...
  • Kinect V2开发(6)骨骼数据平滑处理

    千次阅读 2017-12-09 19:24:57
    Kinect获取到的关节坐标数据包含了许多噪声。 影响噪声特性和大小的因素有很多(room lighting; a person’s body size; the person’s distance from the sensor array; the person’s pose (for example, for ...
  • 数据平滑处理算法

    千次阅读 2018-02-26 13:26:24
    简单的数据平滑处理的方法。在一本老版本的《数学手册》中找到了几个基于最小二乘法的数据平滑算法。将其写成了C 代码,测试了一下,效果还可以。这里简单的记录一下,算是给自己做个笔记。算法的原理很简单,以五点...
  • 几个简单的数据平滑处理算法

    万次阅读 多人点赞 2013-09-05 13:29:54
    因此去找了些简单的数据平滑处理的方法。 在一本老版本的《数学手册》中找到了几个基于最小二乘法的数据平滑算法。将其写成了C 代码,测试了一下,效果还可以。这里简单的记录一下,算是给自己做个笔记。
  • 曲线的平滑平滑处理

    千次阅读 2014-11-24 10:23:52
    因此去找了些简单的数据平滑处理的方法。 在一本老版本的《数学手册》中找到了几个基于最小二乘法的数据平滑算法。将其写成了C 代码,测试了一下,效果还可以。这里简单的记录一下,算是给自己做个笔记。 算法...
  • 数据平滑处理函数——log1p和exmp1

    千次阅读 2018-12-08 21:17:35
    参考: https://blog.csdn.net/qq_36523839/article/details/82422865  ... 数据平滑处理 -- log1p( ) 和 exmp1( ) 1. 数据预处理时首先可以对偏度...
  • matlab数据平滑处理

    千次阅读 2018-04-18 23:15:00
    1、smooth函数平滑处理 (1)yy=smooth(y) 利用移动平均滤波器对列向量y进行平滑处理,返回与y等长的列向量yy。移动平均滤波器的默认窗宽为5,yy中元素的计算方法如下: yy(1)=y(1) yy(2)=(y(1)+y(2...
  • 数据平滑

    千次阅读 2019-10-01 19:02:24
    数据平滑处理通常包含有降噪、拟合等操作。降噪的功能意在去除额外的影响因素,拟合的目的意在数学模型化,可以通过更多的数学方法识别曲线特征。 案例:绘制两只股票收益率曲线。收益率 =(后一天收盘价-前一天...
  • 数据的预处理——平滑处理

    千次阅读 2021-02-19 10:43:31
    在对时间序列数据(如信号数据或股票价格数据)进行统计分析时,往往需要对数据进行平滑处理,本次主要介绍smooth函数、smoothts函数和medfilt1函数的用法 1.smooth函数 smooth函数调用格式如下: 1) yy=smooth(y) ...
  • python 数据、曲线平滑处理——方法总结Savitzky-Golay 滤波器实现曲线平滑插值法对折线进行平滑曲线处理基于Numpy.convolve实现滑动平均滤波数据平滑处理——log()和exp()函数 问题描述: 在寻找曲线的波峰、波谷时...
  • 1、产生加噪正弦波信号,绘制加噪波形图,如下:2、利用移动平均法对加噪信号进行平滑处理3、利用lowess方法对加噪信号进行平滑处理4、利用rlowess方法对加噪信号进行平滑处理5、利用loess方法对加噪信号进行平滑...
  • 因此,为了防止对训练样本中未出现的新序列概率估计值为零,人们发明了好多改善估计新序列出现概率的算法,即数据平滑算法。 Laplace 法则  最简单的算法是Laplace法则,思路很简单,统计测试数据集中的元素在...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 104,674
精华内容 41,869
关键字:

数据平滑处理