Python I'；我的程序运行时间太长，有点问题。I'；我不确定它是否'；是无限运行还是'；It’真的很慢

我正在编写一个代码来分析（8477960，1）列向量。我不确定我的代码中的while循环是否无限运行，或者我写东西的方式是否真的很慢

这是我在第一个while循环之前的代码部分，我无法运行到完成

import numpy as np
import pandas as pd

data = pd.read_csv(r'C:\Users\willo\Desktop\TF_60nm_2_2.txt')


def recursive_low_pass(rawsignal, startcoeff, endcoeff, filtercoeff):
    #  The current signal length

    ni = len(rawsignal)  # signal size
    rougheventlocations = np.zeros(shape=(100000, 3))

    # The algorithm parameters
    # filter coefficient
    a = filtercoeff
    raw = np.array(rawsignal).astype(np.float)

    # thresholds
    s = startcoeff
    e = endcoeff  # for event start and end thresholds

    # The recursive algorithm
    # loop init

    ml = np.zeros(ni)
    vl = np.zeros(ni)
    s = np.zeros(ni)

    ml[0] = np.mean(raw) # local mean init
    vl[0] = np.var(raw) # local variance init
    i = 0  # sample counter
    numberofevents = 0  # number of detected events

    # main loop
    while i < (ni - 1):
        i = i + 1
        # local mean low pass filtering
        ml[i] = a * ml[i - 1] + (1 - a) * raw[i]
        # local variance low pass filtering
        vl[i] = a * vl[i - 1] + (1 - a) * np.power([raw[i] - ml[i]],2)
        # local threshold to detect event start
        sl = ml[i] - s * np.sqrt(vl[i])

将numpy导入为np
作为pd进口熊猫
data=pd.read\u csv（r'C:\Users\willo\Desktop\TF\u 60nm\u 2\u 2.txt'）
def递归低通（RAW信号、startcoeff、ENDCOFF、filtercoeff）：
#当前信号长度
ni=len（原始信号）#信号大小
粗糙事件位置=np.0（形状=（100000,3））
#算法参数
#过滤系数
a=过滤器关闭
raw=np.array（rawsignal）.astype（np.float）
#阈值
s=启动效率
e=事件开始和结束阈值的端系数
#递归算法
#循环初始化
ml=np.零（ni）
vl=np.零（ni）
s=np.零（ni）
ml[0]=np.平均值（原始）#局部平均初始值
vl[0]=np.var（原始）#局部方差初始
i=0#样本计数器
numberofevents=0#检测到的事件数
#主回路
而i<（ni-1）：
i=i+1
#局部平均低通滤波
ml[i]=a*ml[i-1]+（1-a）*原始[i]
#局部方差低通滤波
vl[i]=a*vl[i-1]+（1-a）*np.功率（[raw[i]-ml[i]]，2）
#检测事件启动的本地阈值
sl=ml[i]-s*np.sqrt（vl[i]）

---

我没有收到任何错误消息，但我让程序运行了10分钟以上，没有任何结果，因此我假设我做了一些错误的事情。

您应该尝试将此过程矢量化，而不是访问/处理索引（否则为什么要使用numpy）

另一件事是，您似乎在做不必要的工作（除非我们没有看到整个功能）

该行：

sl = ml[i] - s * np.sqrt(vl[i])

指定循环内（或其他任何地方）未使用的变量

sl

。此赋值执行全零的s的整向量乘法。如果确实需要sl变量，则应在循环外使用最后遇到的值ml[i]和vl[i]计算sl变量，该值可存储在临时变量中，而不是在每个循环上计算

如果

ni

是数百万，这种不必要的向量乘法（数百万个零）将非常昂贵

首先，您可能并不想用

s=np.zero（ni）

覆盖

s=startCoff

的值

为了对这些计算进行矢量化，您需要使用带有一些自定义函数的np.acumulate

非numpy等效项如下（改用itertools）：

在每种情况下，ml/vl向量都用索引0处的基值初始化，其余的用零填充

accumulate（zip）（…

函数调用遍历数组，并使用

r

中的当前和以及

d

中的成对元素调用lambda函数。对于

ml

计算，这对应于

r=（ml[i-1]，u）

和

d=（0，raw[i]）

因为累计输出的日期类型与作为输入提供的日期类型相同（即压缩元组），所以实际结果只是mlSums/vlSums列表中元组的第一个值

---

处理列表中的8477960项花费了9.7秒。

您是否尝试在while循环中添加一些输出，以查看是否有进展，如果有，速度有多快？首先尝试

data.iloc[：100]

以测试数据帧中只有100个条目的解决方案如何？是否可以使用调试器？

from itertools import accumulate

ml     = [np.mean(raw)]+[0]*(ni-1)
mlSums = accumulate(zip(ml,raw),lambda r,d:(a*r[0] + (1-a)*d[1],0))
ml     = [v for v,_ in mlSums]

vl     = [np.var(raw)]+[0]*(ni-1)
vlSums = accumulate(zip(vl,raw,ml),lambda r,d:(a*r[0] + (1-a)*(d[1]-d[2])**2,0,0))
vl     = [v for v,_,_ in vlSums]