精华内容
下载资源
问答
  • 一招快速重构 Python 代码
    千次阅读
    2019-03-11 09:18:54

    转自:https://www.toutiao.com/i6666234217845752332/?tt_from=mobile_qq&utm_campaign=client_share&timestamp=1552266591&app=news_article&utm_source=mobile_qq&iid=65267103732&utm_medium=toutiao_ios&group_id=6666234217845752332

     

    代码重构处理的不好,将会是意见非常令人头疼的事情,因为有可能牵涉到许多的团队和大量的代码库修改。那么如何高效、快速地进行代码重构,就是Python程序员值得掌握的技巧。

    本分介绍的是通过Python中的@property装饰器,快速进行代码重构的一个例子,供大家参考。

    从前,Python程序员Alice要打算创建一个代表金钱的类。她的第一个实现形式大概是下面这样:

     

    # 以美元为基础货币的Money类的首个版本

    class Money:

    def __init__(self, dollars, cents):

    self.dollars = dollars

    self.cents = cents

    # 还有其他一些方法,我们暂时不必理会

    这个类后来被打包到一个Python库里,并且慢慢地被许多不同的应用使用。举个例子,另一个团队中的Python程序员Bob是这样使用Money类的:

     

    money = Money(27, 12)

    message = "I have {:d} dollars and {:d} cents."

    print(message.format(money.dollars, money.cents))

    # "I have 27 dollars and 12 cents."

    money.dollars += 2

    money.cents += 20

    print(message.format(money.dollars, money.cents))

    # "I have 29 dollars and 32 cents."

    这样使用并没有错,但是却出现了代码可维护性的问题。你发现了吗?

    几个月或是几年之后。Alice想要重构Money类的内部实现,不再记录美元和美分,而是仅仅记录美分,因为这样做可以让某些操作简单很多。下面是她很可能会作的修改:

     

    # Money类的第二个版本

    class Money:

    def __init__(self, dollars, cents):

    self.total_cents = dollars * 100 + cents

    这一修改带来一个后果:引用Money类的每一行代码都必须要调整。有时候很幸运,你就是所有这些代码的维护者,只需要自己直接重构即可。但是Alice的情况就没有这么好了;许多团队都复用了她的代码。因此,她需要协调他们的代码库与自己的修改保持一致,也许甚至要经历一段特别痛苦、漫长的正式弃用过程(deprecation process)。

    幸运的是,Alice知道一种更好的解决办法,可以避免这个令人头疼的局面出现:使用Python内建的property装饰器。@property一般应用在Python方法上,可以有效地将属性访问(attribute access)变成方法调用(method call)。举个例子,暂时将Money类抛至一边,假设有一个代表人类的Person类(class):

     

    class Person:

    def __init__(self, first, last):

    self.first = first

    self.last = last

    @property

    def full_name(self):

    return '{} {}'.format(self.first, self.last)

    代码样式不同,是因为之前用的工具出问题了。—EarlGrey

    请注意full_name方法。除了在def语句上方装饰了@property之外,该方法的声明没有什么不同的地方。但是,这却改变了Person对象的运作方式:

     

    >>> buddy = Person('Jonathan', 'Doe')

    >>> buddy.full_name

    'Jonathan Doe'

    我们发现,尽管full_name被定义为一个方法,但却可以通过变量属性的方式访问。在最后一行代码中没有操作符;我并没有调用full_name方法。我们所做的,可以说是创建了某种动态属性。

    回到本文中的Money类,Alice对它作了如下修改:

     

    # Money类的最终版本

    class Money:

    def __init__(self, dollars, cents):

    self.total_cents = dollars * 100 + cents

    # Getter and setter for dollars...

    @property

    def dollars(self):

    return self.total_cents // 100;

    @dollars.setter

    def dollars(self, new_dollars):

    self.total_cents = 100 * new_dollars + self.cents

    # And the getter and setter for cents.

    @property

    def cents(self):

    return self.total_cents % 100;

    @cents.setter

    def cents(self, new_cents):

    self.total_cents = 100 * self.dollars + new_cents

    除了使用@property装饰器定义了dollars属性的getter外,Alice还利用@dollars.setter创建了一个setter。Alice还对cents`属性作了类似处理。

    那么现在,Bob的代码要做哪些相应的修改呢?根本不用改!

     

    # 他的代码完全没有变动,但是却可以正常调用Money类。

    money = Money(27, 12)

    message = "I have {:d} dollars and {:d} cents."

    print(message.format(money.dollars, money.cents))

    # "I have 27 dollars and 12 cents."

    money.dollars += 2

    money.cents += 20

    print(message.format(money.dollars, money.cents))

    # "I have 29 dollars and 32 cents."# 代码逻辑也没有问题。

    money.cents += 112

    print(message.format(money.dollars, money.cents))

    # "I have 30 dollars and 44 cents."

    事实上,所有使用了Money类的代码都不需要进行修改。Bob不知道或根本不在乎Alice去除了类中的dollars和cents属性:他的代码还是和以前一样正常执行。唯一修改过的代码就是Money类本身。

    正是由于Python中处理装饰器的方式,你可以在类中自由使用简单的属性。如果你所写的类改变了管理状态的方法,你可以自信地通过@property装饰器对这个类(且只有这个类)进行修改。这是一个共赢的方法!相反,在Java等语言中,程序员必须主动去定义访问属性的方法(例如getDollars或setCents)。

    最后要提示大家:

    这种方法对于那些被其他程序员和团队复用的代码最为重要。假设仅仅是在你自己一个维护的应用中创建一个类似Money的类,那么如果你改变了Money的接口,你只需要重构自己的代码就可以。这种情况下,你没有必要像上面说的那样使用@property装饰器。

    原文:http://migrateup.com/python-properties-refactoring/

    译文:http://codingpy.com/article/python-properties-refactoring/

    更多相关内容
  • 该压缩包pypsr-master.zip:为Python编写的PSR(相空间重构的一个实例),用于做信号处理,混沌分析。
  • 小编整理了介绍python代码重构优化的一些方法,助你一臂之力。 编写干净的 Pythonic 代码就是尽可能使其易于理解,但又简洁。所以重构代码让代码简洁易理解是很有必要的。 本文重点是想跟大家探讨为什么这些重构是好...
  • 12改进的C-C相空间重构自然函数法确定延迟时间wolf法求李雅普诺夫指数小数据量法求李雅普诺夫指数
  • 一种改进的选择相空间重构参数的方法,12、一种改进的选择相空间重构参数的方法12、一种改进的选择相空间重构参数的方法
  • 相空间重构

    2017-10-10 21:37:10
    相空间重构 分形维数 主要用于故障诊断模式识别等领域
  • [xn, dn, xn_cols] = PhaSpaRecon(s, tau, m) 输入参数: s 混沌序列(列向量) tau 重构时延 m 重构维数 T 直接预测步数 输出参数: xn 相空间中的点序列(每一列为一个点) dn 一步预测的目标(行向量)
  • 相空间重构代码-matlab

    热门讨论 2011-02-10 18:41:15
    用matlab实现混沌理论中的相空间重构代码,很好用的工具!
  • 基于相空间重构和ARIMA-SVM模型对我国进出口总额的预测研究,李超,雷钦礼,进出口数据作为广泛经济时序数据的一种,预测通常采用时序研究方法。如经典线性模型,滑动自回归模型(ARIMA)。现实时序数据通常�
  • 相空间重构matlab实现

    千次阅读 热门讨论 2020-08-31 17:31:17
    相空间重构 对于相空间重构需要确定的嵌入维数(m)和时间延迟(τττ) 使用C-C法可同时确定m和τττ,也可使用求自相关系数当ACF的值低于1−e−11-e ^{-1}1−e−1,从而确定时间延迟。然后通过G-P算法确定m。由于...

    相空间重构

    ##更新:最近重新看了这部分的内容,发现dts=max(ds)-min(ds);有误,应该是用r最大的时候的s减去最小时候的s。改为dts = ds(end)-ds(1)。以及C2应该有个m次幂。还有每次计算r应该是子序列对应的领域半径。

    对于相空间重构需要确定的嵌入维数(m)和时间延迟( τ τ τ)
    使用C-C法可同时确定m和 τ τ τ,也可使用求自相关系数当ACF的值低于 1 − e − 1 1-e ^{-1} 1e1,从而确定时间延迟。然后通过G-P算法确定m。由于使用G-P算法所需时间较长。故本文直接使用C-C法确定两个参数。
    时间窗口 t m = ( m − 1 ) ∗ τ t_m=(m-1)*τ tm=(m1)τ
    本文所给的函数是自己编写的,故大家可用于参考,对于相空间理论部分,懒得编写了,直接百度即可。

    确定参数 t m t_m tm τ τ τ的主函数

    clc;clear
    % C-C方法的主程序
    data=xlsread('all_data7.xlsx','all_data','b1:b20000');
    [ACF,lags,bounds]=autocorr(data,100);
    tau=59;
    m=15;
    [D,MEAN,STD]=zscore(data);
    r1=0.5*STD;
    N=length(data);
    [a,b]=find(ACF<ACF(1)*(1-exp(-1)));
    beifen=data;
    %% 求统计量S
    SS=[];
    DTS=[];
    COR=[];
    T=[];
    NN=1:6000;
    for t=1:100
       sums=0;
       sumdts=0;
    %     if mod(N,t)~=0
    %         [a,b]=find(mod(NN,t)==0);
    %         data=beifen(1:b(end));
    %     end
           for i=1:t
               eval(['datat',num2str(i),'=[];'])
               for j=1:N/t
                   eval(['tran=data(',num2str(i),'+',num2str(t),'*(',num2str(j),'-1));'])
                   eval(['datat',num2str(i),'=[datat',num2str(i),';tran];'])
               end
           end
           for m=2:5
               ds=[];
               for k=1:4
                   S=[];
                   for i=1:t
                       eval(['S',num2str(i),'=[];'])
                       eval(['datat=datat',num2str(i),';'])
                       r=r1*k;
                       C1=C(m,N/t,r,t,datat);%%计算关联积分
                       C2=C(1,N/t,r,t,datat);
                       eval(['S',num2str(i),'=[S',num2str(i),',C1-C2];'])%% 计算检验统计量
                       eval(['S=[S;S',num2str(i),'];'])
                   end
                   S=sum(S)/t;
                   ds=[ds,S];
                   sums=sums+S;
               end
               dts=max(ds)-min(ds);%% 求ΔS
               sumdts=sumdts+dts;
           end
           sums=sums/16;
           sumdts=sumdts/4;
           scor=sumdts+abs(sums);
           T=[T;t];
    %     S=S/t;
       SS=[SS;sums];
       DTS=[DTS;sumdts];
       COR=[COR;scor];
    end
    % xieru=["datat1","datat2","datat3","datat4","datat5"];
    % for i=1:t
    %     eval(['tran=datat',num2str(i),';'])
    %     xlswrite('xkjcg.xlsx',tran,xieru(i));
    % end
    tt=1:100;
    plot(tt,SS,tt,DTS,tt,COR)
    legend('SS','DTS','COR')
    
    

    C子程序

     %% 相空间重构确定嵌入维数和时间延迟
    function [C]=C(m,N,r,t,data)
    
    %% 将原始数据 重构相空间
    M=N-(m-1)*t;%% M为重构相空间中相点的个数
    x=[];%x用于保存相空间重构的结果
    for i=1:M
        for j=1:m
            x(i,j)=[data(i+(j-1)*t)];
        end
    end
    sumM=0;
    for j=1:M
        for i=1:j
            dij=sum(abs(x(i,:)-x(j,:)));
            if (r-dij)<0
                th=0;
            else
                th=1;
            end
            sumM=sumM+th;
        end
    end
    C=2*sumM/(M*(M-1));
    end
    
    展开全文
  • 相空间重构求关联维数——GP算法、自相关法求时间延迟tau、最近邻算法求嵌入维数m GP算法: 若有一维时间序列为{x1,x2,…,xn},对其进行相空间重构得到高维相空间的一系列向量: xi(τ,m)=(xi,xi1,⋯ ,xi+(m−1)τ){...

    Python实现相空间重构求关联维数——GP算法、自相关法求时间延迟tau、最近邻算法求嵌入维数m

    GP算法:

    若有一维时间序列为{x1,x2,…,xn},对其进行相空间重构得到高维相空间的一系列向量:

    x i ( τ , m ) = ( x i , x i 1 , ⋯   , x i + ( m − 1 ) τ ) {x_i}(\tau ,m) = \left( {{x_i},{x_{i1}}, \cdots ,{x_{i + {{(m - 1)}_\tau }}}} \right) xi(τ,m)=(xi,xi1,,xi+(m1)τ)

    式中: τ \tau τ为时间延迟, τ \tau τ=k Δ t {\rm{\Delta }}t Δt,其中k为整数,为采样时间间隔;m为嵌入维数;i=1,2,⋯,N;N为重构后向量的个数, N = n − ( m − 1 ) τ N = n - (m - 1)\tau N=n(m1)τ
    重构相空间关联维数为:

    D 2 = lim ⁡ r → 0 ln ⁡ c r ln ⁡ r {D_2} = \mathop {\lim }\limits_{r \to 0} \frac{{\ln {c_r}}}{{\ln r}} D2=r0limlnrlncr

    c r = 1 N 2 {c_r} = \frac{1}{{{N^2}}} cr=N21 ∑ ∑ H \sum\sum H H ( r − ∣ ∣ x j − x k ∣ ∣ ) \left( {r - ||{x_j} - {x_k}||} \right) (rxjxk)

    式中:j≠k;r为m维超球半径;H为Heaviside函数。

    def GP(imf,tau):            #GP算法求关联维数
        N=2000
        if (len(imf) != N):
            print('请输入指定的数据长度!')   # N为指定数据长度
            return
        elif (isinstance(imf, np.ndarray) != True):
            print('数据格式错误!')
            return
        else:
            m_max=10                  #最大嵌入维数
            ss=50                     #r的步长
            fig=plt.figure()
            for m in range(1,m_max+1):
                i_num = N - (m - 1) * tau
                kj_m = np.zeros((i_num, m))  # m维重构相空间
                for i in range(i_num):
                    for j in range(m):
                        kj_m[i][j] = imf[i + j * tau]
                dist_min, dist_max = np.linalg.norm(kj_m[0] - kj_m[1]), np.linalg.norm(kj_m[0] - kj_m[1])
                Dist_m = np.zeros((i_num, i_num))  # 两向量之间的距离
                for i in range(i_num):
                    for k in range(i_num):
                        D= np.linalg.norm(kj_m[i] - kj_m[k])
                        if(D>dist_max):
                            dist_max=D
                        elif(D>0 and D<dist_min):
                            dist_min=D
                        Dist_m[i][k] = D
                dr=(dist_max-dist_min)/(ss-1)           #r的间距
                r_m=[]
                Cr_m=[]
                for r_index in range(ss):
                    r=dist_min+r_index*dr
                    r_m.append(r)
                    Temp=np.heaviside(r-Dist_m,1)
                    for i in range(i_num):
                        Temp[i][i]=0
                    Cr_m.append(np.sum(Temp))
                r_m=np.log(np.array((r_m)))
                Cr_m=np.log(np.array((Cr_m))/(i_num*(i_num-1)))
                plt.plot(r_m,Cr_m)
            plt.show()
    

    自相关法确定 τ \tau τ

    计算时间序列{x1,x2,…,xn}的自相关函数:

    R ( j τ ) = 1 N ∑ R(j\tau )= \frac{1}{{{N}}}\sum R(jτ)=N1 x ( i ) x ( i + j τ ) x(i)x(i + j\tau ) x(i)x(i+jτ)

    当自相关函数值下降到初始函数值的1- e − 1 {{\rm{e}}^{ - 1}} e1时。所对应的 τ \tau τ即为时间延迟参数。

    # 计算GP算法的时间延迟参数(自相关法)
    def get_tau(imf):
        N=2000
        if (len(imf) != N):
            print('请输入指定的数据长度!')  # N为指定数据长度
            return 0
        elif (isinstance(imf, np.ndarray) != True):
            print('数据格式错误!')
            return 0
        else:
            j = 1  # j为固定值
            tau_max = 20
            Rall = np.zeros(tau_max)
            for tau in range(tau_max):
                R = 0
                for i in range(N - j * tau):
                    R += imf[i] * imf[i + j * tau]
                Rall[tau] = R / (N - j * tau)
            for tau in range(tau_max):
                if Rall[tau] < (Rall[0] * 0.6321):
                    break
            return tau
    

    假近邻算法确定m

    对m维相空间每一个向量 X i ( m ) = { x i , x i + τ , ⋯   , x i + ( m − 1 ) τ } {X_{i(m)}} = \left\{ {{x_i},{x_{i + \tau }}, \cdots ,{x_{i + (m - 1)\tau }}} \right\} Xi(m)={xi,xi+τ,,xi+(m1)τ},i=1,2,…,N,N为向量总数,找出它的最近向量 X j ( m ) X_{j(m)} Xj(m),计算两者欧氏距离 R m ( i ) = ∣ ∣ X i ( m ) − X j ( m ) ∣ ∣ {R_{m }}(i) = ||{X_{i(m)}} - {X_{j(m )}}|| Rm(i)=Xi(m)Xj(m),它们在m+1维空间的距离为:

    R m + 1 ( i ) = ∣ ∣ X i ( m + 1 ) − X j ( m + 1 ) ∣ ∣ {R_{m + 1}}(i) = ||{X_{i(m + 1)}} - {X_{j(m + 1)}}|| Rm+1(i)=Xi(m+1)Xj(m+1)

    如果 R m + 1 ( i ) {R_{m + 1}}(i) Rm+1(i)>> R m ( i ) {R_{m}}(i) Rm(i),则为虚假近邻点,定义比值:

    R ( i ) = R(i)= R(i)= [ R m + 1 ( i ) ] 2 − [ R m ( i ) ] 2 [ R m ( i ) ] 2 \sqrt {\frac{{{{\left[ {{R_{m + 1}}(i)} \right]}^2} - {{\left[ {{R_m}(i)} \right]}^2}}}{{{{\left[ {{R_m}(i)} \right]}^2}}}} [Rm(i)]2[Rm+1(i)]2[Rm(i)]2

    R ( i ) > R 0 R(i)>R_0 R(i)>R0,则称 X j X_j Xj X i X_i Xi的假近邻点, R 0 R_0 R0为阈值通常取大于10.计算该m下虚假近邻点占点比例,直到虚假近邻点百分比很小或不随m增大而减少时,此时的m即为所需嵌入维数。

    #计算GP算法的嵌入维数(假近邻算法)
    def get_m(imf, tau):
        N=2000
        if (len(imf) != N):
            print('请输入指定的数据长度!')  # N为指定数据长度
            return 0, 0
        elif (isinstance(imf, np.ndarray) != True):
            print('数据格式错误!')
            return 0, 0
        else:
            m_max = 10
            P_m_all = []  # m_max-1个假近邻点百分率
            for m in range(1, m_max + 1):
                i_num = N - (m - 1) * tau
                kj_m = np.zeros((i_num, m))  # m维重构相空间
                for i in range(i_num):
                    for j in range(m):
                        kj_m[i][j] = imf[i + j * tau]
                if (m > 1):
                    index = np.argsort(Dist_m)
                    a_m = 0  # 最近邻点数
                    for i in range(i_num):
                        temp = 0
                        for h in range(i_num):
                            temp = index[i][h]
                            if (Dist_m[i][temp] > 0):
                                break
                        D = np.linalg.norm(kj_m[i] - kj_m[temp])
                        D = np.sqrt((D * D) / (Dist_m[i][temp] * Dist_m[i][temp]) - 1)
                        if (D > 10):
                            a_m += 1
                    P_m_all.append(a_m / i_num)
                i_num_m = i_num - tau
                Dist_m = np.zeros((i_num_m, i_num_m))  # 两向量之间的距离
                for i in range(i_num_m):
                    for k in range(i_num_m):
                        Dist_m[i][k] = np.linalg.norm(kj_m[i] - kj_m[k])
            P_m_all = np.array(P_m_all)
            m_all = np.arange(1, m_max)
            return m_all, P_m_all
    

    三连、三连、三连

    完整测试代码如下:

    import numpy as np
    from scipy.fftpack import fft
    from scipy import fftpack
    import matplotlib.pyplot as plt
    
    N_ft=2000         #时频域的点数
    
    # 计算GP算法的时间延迟参数(自相关法)
    def get_tau(imf):
        if (len(imf) != N_ft):
            print('请输入指定的数据长度!')  # 需要更改,比如弹出对话框
            return 0,0,0
        elif (isinstance(imf, np.ndarray) != True):
            print('数据格式错误!')
            return 0,0,0
        else:
            j = 1  # j为固定值
            tau_max = 20
            Rall = np.zeros(tau_max)
            for tau in range(tau_max):
                R = 0
                for i in range(N_ft - j * tau):
                    R += imf[i] * imf[i + j * tau]
                Rall[tau] = R / (N_ft - j * tau)
            for tau in range(tau_max):
                if Rall[tau] < (Rall[0] * 0.6321):
                    break
                tauall=np.arange(tau_max)
            return tauall,Rall,tau
    
    
    # 计算GP算法的嵌入维数(假近邻算法)
    def get_m(imf, tau):
        if (len(imf) != N_ft):
            print('请输入指定的数据长度!')  # 需要更改,比如弹出对话框
            return 0, 0
        elif (isinstance(imf, np.ndarray) != True):
            print('数据格式错误!')
            return 0, 0
        else:
            m_max = 10
            P_m_all = []  # m_max-1个假近邻点百分率
            for m in range(1, m_max + 1):
                i_num = N_ft - (m - 1) * tau
                kj_m = np.zeros((i_num, m))  # m维重构相空间
                for i in range(i_num):
                    for j in range(m):
                        kj_m[i][j] = imf[i + j * tau]
                if (m > 1):
                    index = np.argsort(Dist_m)
                    a_m = 0  # 最近邻点数
                    for i in range(i_num):
                        temp = 0
                        for h in range(i_num):
                            temp = index[i][h]
                            if (Dist_m[i][temp] > 0):
                                break
                        D = np.linalg.norm(kj_m[i] - kj_m[temp])
                        D = np.sqrt((D * D) / (Dist_m[i][temp] * Dist_m[i][temp]) - 1)
                        if (D > 10):
                            a_m += 1
                    P_m_all.append(a_m / i_num)
                i_num_m = i_num - tau
                Dist_m = np.zeros((i_num_m, i_num_m))  # 两向量之间的距离
                for i in range(i_num_m):
                    for k in range(i_num_m):
                        Dist_m[i][k] = np.linalg.norm(kj_m[i] - kj_m[k])
            P_m_all = np.array(P_m_all)
            m_all = np.arange(1, m_max)
            return m_all, P_m_all
    
    
    # GP算法求关联维数(时频域特征)
    def GP(imf, tau):
        if (len(imf) != N_ft):
            print('请输入指定的数据长度!')  # 需要更改,比如弹出对话框
            return
        elif (isinstance(imf, np.ndarray) != True):
            print('数据格式错误!')
            return
        else:
            m_max = 10  # 最大嵌入维数
            ss = 50  # r的步长
            fig = plt.figure(1)
            for m in range(1, m_max + 1):
                i_num = N_ft - (m - 1) * tau
                kj_m = np.zeros((i_num, m))  # m维重构相空间
                for i in range(i_num):
                    for j in range(m):
                        kj_m[i][j] = imf[i + j * tau]
                dist_min, dist_max = np.linalg.norm(kj_m[0] - kj_m[1]), np.linalg.norm(kj_m[0] - kj_m[1])
                Dist_m = np.zeros((i_num, i_num))  # 两向量之间的距离
                for i in range(i_num):
                    for k in range(i_num):
                        D = np.linalg.norm(kj_m[i] - kj_m[k])
                        if (D > dist_max):
                            dist_max = D
                        elif (D > 0 and D < dist_min):
                            dist_min = D
                        Dist_m[i][k] = D
                dr = (dist_max - dist_min) / (ss - 1)  # r的间距
                r_m = []
                Cr_m = []
                for r_index in range(ss):
                    r = dist_min + r_index * dr
                    r_m.append(r)
                    Temp = np.heaviside(r - Dist_m, 1)
                    for i in range(i_num):
                        Temp[i][i] = 0
                    Cr_m.append(np.sum(Temp))
                r_m = np.log(np.array((r_m)))
                Cr_m = np.log(np.array((Cr_m)) / (i_num * (i_num - 1)))
                plt.plot(r_m, Cr_m)
            plt.xlabel('ln(r)')
            plt.ylabel('ln(C)')
            plt.show()
    
    if __name__=='__main__':
        # 检验关联维数程序
        t = []
        f1 = 25
        f2 = 30
        for i in range(N_ft):
            t.append(i * 0.001)
        t = np.array(t)
        # yu = np.ones(M * N)
        AEall = np.sin(t * 2 * np.pi * f1) + np.sin(t * 2 * np.pi * f2)  #在这里直接改信号
    
    
        tauall, Rall, tau = get_tau(AEall)
        m, P = get_m(AEall, tau)
        GP(AEall, 1)
        print(tau)
        fig2 = plt.figure(2)
        yu = np.ones(len(tauall)) * Rall[0] * 0.6321
        plt.plot(tauall, Rall)
        plt.plot(tauall, yu)
        plt.xlabel('tau')
        plt.ylabel('R')
        plt.show()
        fig3 = plt.figure(3)
        plt.plot(m, P)
        plt.xlabel('m')
        plt.ylabel('P')
        plt.show()
    
    展开全文
  • 该文章详细的描述了相空间重构延迟时间与嵌入维数的选择
  • 相空间重构听起来高大上,但是一旦确定了嵌入维数和延迟时间,之后的操作就十分简单了。 下边给个代码示例一下“之后的操作”,至于嵌入维数和延迟时间的确定,还是需要查查论文的,后期看情况再写。 python程序如下...

    闲话几句

    相空间重构听起来高大上,但是一旦确定了嵌入维数和延迟时间,之后的操作就十分简单了。

    下边给个代码示例一下“之后的操作”,至于嵌入维数和延迟时间的确定,还是需要查查论文的,后期看情况再写。

    python程序

    def embed_vectors_1d(self, lag, embed):
        """Embeds vectors from a one dimensional time series in m-dimensional
        space.
    
        Parameters
        ----------
        X : 1d array
            Training or testing set.
        lag : int
            Lag value as calculated from the first minimum of the mutual info.
        embed : int
            Embedding dimension. How many lag values to take.
        predict : int
            Distance to forecast (see example).
    
        Returns
        -------
        features : 2d array
            Contains all of the embedded vectors. Shape (num_vectors,embed).
    
        Example
        -------
        >>> X = [0,1,2,3,4,5,6,7,8,9,10]
        em = 3
        lag = 2
        predict=3
    
        >>> embed_vectors_1d
        features = [[0,2,4], [1,3,5], [2,4,6], [3,5,7]]
        """
    
        tsize = self.X.shape[0]
        t_iter = tsize-(lag*(embed-1))
    
        features = np.zeros((t_iter,embed))
    
        for ii in range(t_iter):
    
            end_val = ii+lag*(embed-1)+1
    
            part = self.X[ii : end_val]
    
            features[ii,:] = part[::lag]
    
        return features
    

    这个程序是从skccm里边摘抄出来的,程序中用了for循环,这个在效率上不太高。

    朴素的解释

    相空间重构是要解决什么问题呢?最近看的两篇网文1 2很好的解释了这个问题,先把图片粘贴到这里,有人想看的话我再加上文字解释。

    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述

    see also

    1. skccm:https://github.com/NickC1/skccm(GitHub可能无法打开)

    1. Visualization of EDM Prediction with a Chaotic Time Series ↩︎

    2. Explaining simplex projection ↩︎

    展开全文
  • 相空间重构模型

    千次阅读 2020-11-29 17:43:05
    提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档 文章目录前言一、像空间...示例:相空间重构是一种:由已知的时间序列,来恢复并刻画原动力系统的方法。 二、使用步骤 1.引入库 代码如下(示例)
  • 本人测试,Cao法求嵌入维数,绝对有效,下载下来试试,Matlab实现
  • 相空间重构_重构学习的九个步骤

    千次阅读 2020-12-02 09:42:36
    相空间重构 最近有人在Twitter上问我,如果不理解代码的工作原理,如何重构。 我回答说,这是“通过重构学习”。 然后我尝试用Google搜索它,却一无所获。 我很惊讶。 对我来说,重构似乎是研究源代码的最有效,最...
  • 如何选择相空间重构的延迟时间,怎样确定相空间的嵌入维数
  • 时间序列模型之相空间重构

    万次阅读 2018-06-03 10:54:04
    一般的时间序列主要是在时间域中进行模型的研究,而对于混沌时间序列,无论是混沌不变量的计算,混沌模型的建立和预测都是在所谓的相空间中进行,因此相空间重构就是混沌时间序列处理中非常重要的一个步骤。...
  • python重构Do you want simpler Python code? You always start a project with the best intentions, a clean codebase, and a nice structure. But over time, there are changes to your apps, and things can ...
  • 多变量时间序列相空间重构和多变量最大李雅普诺夫指数计算的两篇文献
  • 如何保护Python代码

    千次阅读 2020-01-02 13:17:03
    我正在用Python开发一款软件,该软件将分发给我的雇主的客户。 我的雇主希望通过限时许可文件来限制软件的使用。 如果我们分发.py文件甚至.pyc文件,则很容易(反编译和)删除检查许可证
  • 1、背景 Python是谷歌主要使用的动态语言,本风格指导列举了使用Python编程时应该做和不该做的事项(dos & don'ts) ...pylint是一个用于在Python代码中发现bug和代码风格问题的工具,,pylint查找那些
  • 这是一位大佬翻译的Google Python代码风格指南,很全面。可以作为公司的code review 标准,也可以作为自己编写代码的风格指南。希望对你有帮助。 Translator: shendeguize@github Link: ...
  • 另外一种是将数据映射到低维特征空间,然后由低维特征空间重新映射回原空间,尝试用低维特征重构原始数据,看重构误差的大小。 2.8 基于神经网络的方法: 代表方法有自动编码器( autoencoder,AE) ,长短期记忆神经...
  • 文末有干货“Python高校”,马上关注 真爱,请置顶或星标 这是一位大佬翻译的Google Python代码风格指南,很全面。可以作为公司的code review 标准,也可以作为自己...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,292
精华内容 2,516
关键字:

相空间重构python代码