Python程序使用了太多内存

函数

coinT（）

使用ADF测试和赫斯特指数测试两个时间序列是否平稳。时间序列存储在1511x6 CSV文件中，但对于测试，函数

stock（）

仅返回第5列的向量。总共有50个文件。该程序似乎占用了太多内存，因为它会使PC在运行约30秒后崩溃。它可以在15个文件上正常工作，但在较大的文件集（>50）上崩溃

谁能帮我找出是什么占用了这么多内存？我尝试过将计算拆分成多个函数并删除对象，但没有多大帮助

import numpy as np
import pandas as pd
import statsmodels.tsa.stattools as ts
import csv
import timeit
from numpy import log, polyfit, sqrt, std, subtract
from pandas.stats.api import ols
import os

src = 'C:/Users/PC/Desktop/Magistr/Ibpython/testing/'
filenames = next(os.walk(src))[2] #load all stock file names into array
cointegratedPairs = []

def hurst(ts):
"""Returns the Hurst Exponent of the time series vector ts
    H<0.5 - The time series is mean reverting
    H=0.5 - The time series is a Geometric Brownian Motion
    H>0.5 - The time series is trending"""

    # Create the range of lag values
    lags = range(2, 100)

    # Calculate the array of the variances of the lagged differences
    tau = [sqrt(std(subtract(ts[lag:], ts[:-lag]))) for lag in lags]

    # Use a linear fit to estimate the Hurst Exponent
    poly = polyfit(log(lags), log(tau), 1)

    del lags
    del tau

    # Return the Hurst exponent from the polyfit output
    return poly[0]*2.0

#Convert file into an array
def stock(filename):
    #read file into array and get it's length
    delimiter = ","
    with open(src + filename,'r') as dest_f:
        data_iter = csv.reader(dest_f, 
                            delimiter = delimiter, 
                            quotechar = '"')
        data = [data for data in data_iter]
    data_array = np.asarray(data)[:,5]
    return data_array

   del data
   del data_array

#Check if two time series are cointegrated
def coinTest(itemX, itemY):
    indVar = map(float, stock(itemX)[0:1000]) #2009.05.22 - 2013.05.14
    depVar = map(float, stock(itemY)[0:1000]) #2009.05.22 - 2013.05.14

    #Calculate optimal hedge ratio "beta"
    df = pd.DataFrame()
    df[itemX] = indVar
    df[itemY] = depVar

    res = ols(y=df[itemY], x=df[itemX])
    beta_hr = res.beta.x
    alpha = res.beta.intercept
    df["res"] = df[itemY] - beta_hr*df[itemX] - alpha

    #Calculate the CADF test on the residuals
    cadf = ts.adfuller(df["res"])

    #Reject the null hypothesis at 1% confidence level
    if cadf[4]['1%'] > cadf[0]:

    #Hurst exponent test if residuals are mean reverting
        if hurst(df["res"]) < 0.4:
            cointegratedPairs.append((itemY,itemX))
    del indVar
    del depVar  
    del df[itemX]
    del df[itemY]
    del df["res"]   
    del cadf  

#Main function
def coinT():
    limit = 0
    TotalPairs = 0

    for itemX in filenames:
        for itemY in filenames[limit:]:
            TotalPairs +=1
            if itemX == itemY:
                next
            else:
                coinTest(itemX, itemY) 

        limit +=1  

将numpy导入为np
作为pd进口熊猫
将statsmodels.tsa.stattools作为ts导入
导入csv
导入时间信息
从numpy导入日志、polyfit、sqrt、std、减法
从pandas.stats.api导入ols
导入操作系统
src='C:/Users/PC/Desktop/Magistr/Ibpython/testing/'
filenames=next（os.walk（src））[2]#将所有库存文件名加载到数组中
协整dPairs=[]
德夫赫斯特（ts）：
“”“返回时间序列向量ts的赫斯特指数
H0.5-时间序列趋势为“
#创建滞后值的范围
滞后=范围（2100）
#计算滞后差异的方差数组
tau=[sqrt（std（减去（ts[lag:]，ts[：-lag]））表示滞后中的滞后]
#使用线性拟合来估计赫斯特指数
多边形=多边形拟合（对数（滞后），对数（τ），1）
德尔拉格
德尔陶
#从多边形拟合输出返回赫斯特指数
返回多边形[0]*2.0
#将文件转换为数组
def库存（文件名）：
#将文件读入数组并获取其长度
分隔符=“，”
以open（src+filename，'r'）作为dest\u f:
数据读取器=csv.reader（目的地，
分隔符=分隔符，
quotechar=“”）
数据=[数据表中数据的数据]
data_array=np.asarray（data）[：，5]
返回数据数组
del数据
del数据数组
#检查两个时间序列是否是协整的
def coinTest（项目X、项目Y）：
indVar=map（浮动，股票（项目X）[0:1000]）#2009.05.22-2013.05.14
depVar=map（浮动，股票（分项）[0:1000]）#2009.05.22-2013.05.14
#计算最佳套期保值比率“β”
df=pd.DataFrame（）
df[itemX]=indVar
df[itemY]=depVar
res=ols（y=df[itemY]，x=df[itemX]）
beta_hr=res.beta.x
α=分辨率β截距
df[“res”]=df[itemY]-beta\u hr*df[itemX]-alpha
#计算残差的CADF检验
cadf=ts.adfuller（df[“res”]）
#以1%的置信水平拒绝无效假设
如果cadf[4]['1%']>cadf[0]：
#Hurst指数检验残差是否为均值回复
如果赫斯特（df[“res”]）<0.4：
协整的pairs.append（（itemY，itemX））
德林德瓦
德德瓦酒店
del df[itemX]
del df[项目]
del df[“res”]
德尔卡夫
#主要功能
def coinT（）：
极限=0
TotalPairs=0
对于文件名中的itemX：
对于文件名中的项目[限制：]：
TotalPairs+=1
如果itemX==itemY：
下一个
其他：
共同测试（项目X、项目Y）
极限+=1

这不是内存泄漏，只是内存使用率高。我有8Gb的RAM，它真的需要大量计算吗？每次运行coinT（）后，它不应该清除内存吗在一对上进行测试，因为它是在一个单独的函数中完成的？这是我最初的想法。在快速浏览代码之后，很难说应该优化什么。您应该运行该测试，它将告诉您每行哪个部分占用最多内存。我猜这是adfuller autolag选项中的一个问题，它保留了所有辅助回归内存中的模型（糟糕的设计）。您需要设置较小的最大滞后或删除自动滞后选项。