通过删除 numpy 数组来释放内存

我编写了一个带有 GUI 的疲劳分析程序。该程序获取有限元模型每个元素的单位载荷的应变信息，使用 np.genfromtxt('loadcasefilename.txt') 读取载荷工况，然后进行一些疲劳分析并将每个元素的结果保存在另一个数组中。

负载工况以文本文件形式约为 32Mb，其中有 40 个左右需要循环读取和分析。每个元素的载荷通过载荷工况数组的切片进行插值。

GUI 和疲劳分析在单独的线程中运行。当您单击疲劳分析上的“开始”时，它将开始循环疲劳分析中的载荷工况。

这让我想到了我的问题。如果我有很多元素，分析就无法完成。它多久退出取决于有多少元素，这让我认为这可能是一个内存问题。我尝试通过删除每个循环末尾的负载情况数组（删除所有作为其切片的数组之后）并运行 gc.collect() 来解决此问题，但这没有取得任何成功。

在 MatLab 中，我使用“pack”函数将工作区写入磁盘，清除它，然后在每个循环结束时重新加载它。我知道这不是一个好的做法，但它可以完成工作！我可以用 Python 做同样的事情吗？

代码如下：

for LoadCaseNo in range(len(LoadCases[0]['LoadCaseLoops'])):#range(1):#xxx
    #Get load case data
    self.statustext.emit('Opening current load case file...')
    LoadCaseFilePath=LoadCases[0]['LoadCasePaths'][LoadCaseNo][0]
    #TK: load case paths may be different
    try:
      with open(LoadCaseFilePath):
        pass
    except Exception as e:
        self.statustext.emit(str(e))


    LoadCaseLoops=LoadCases[0]['LoadCaseLoops'][LoadCaseNo,0]
    LoadCase=np.genfromtxt(LoadCaseFilePath,delimiter=',')

    LoadCaseArray=np.array(LoadCases[0]['LoadCaseLoops'])
    LoadCaseArray=LoadCaseArray/np.sum(LoadCaseArray,axis=0)
    #Loop through sections
    for SectionNo in  range(len(Sections)):#range(100):#xxx 
        SectionCount=len(Sections)
        #Get section data
        Elements=Sections[SectionNo]['elements']
        UnitStrains=Sections[SectionNo]['strains'][:,1:]
        Nodes=Sections[SectionNo]['nodes']
        rootdist=Sections[SectionNo]['rootdist']
        #Interpolate load case data at this section
        NeighbourFind=rootdist-np.reshape(LoadCase[0,1:],(1,-1))
        NeighbourFind[NeighbourFind<0]=1e100
        nearest=np.unravel_index(NeighbourFind.argmin(), NeighbourFind.shape)
        nearestcol=int(nearest[1])
        Distance0=LoadCase[0,nearestcol+1]
        Distance1=LoadCase[0,nearestcol+7]
        MxLow=LoadCase[1:,nearestcol+1]
        MxHigh=LoadCase[1:,nearestcol+7]
        MyLow=LoadCase[1:,nearestcol+2]
        MyHigh=LoadCase[1:,nearestcol+8]
        MzLow=LoadCase[1:,nearestcol+3]
        MzHigh=LoadCase[1:,nearestcol+9]
        FxLow=LoadCase[1:,nearestcol+4]
        FxHigh=LoadCase[1:,nearestcol+10]
        FyLow=LoadCase[1:,nearestcol+5]
        FyHigh=LoadCase[1:,nearestcol+11]
        FzLow=LoadCase[1:,nearestcol+6]
        FzHigh=LoadCase[1:,nearestcol+12]
        InterpFactor=(rootdist-Distance0)/(Distance1-Distance0)
        Mx=MxLow+(MxHigh-MxLow)*InterpFactor[0,0]
        My=MyLow+(MyHigh-MyLow)*InterpFactor[0,0]
        Mz=MzLow+(MzHigh-MzLow)*InterpFactor[0,0]
        Fx=-FxLow+(FxHigh-FxLow)*InterpFactor[0,0]
        Fy=-FyLow+(FyHigh-FyLow)*InterpFactor[0,0]
        Fz=FzLow+(FzHigh-FzLow)*InterpFactor[0,0]
        #Loop through section coordinates
        for ElementNo in range(len(Elements)):
            MaterialID=int(Elements[ElementNo,1])
            if Materials[MaterialID]['curvefit'][0,0]!=3:
                StrainHist=UnitStrains[ElementNo,0]*Mx+UnitStrains[ElementNo,1]*My+UnitStrains[ElementNo,2]*Fz

            elif Materials[MaterialID]['curvefit'][0,0]==3:

                StrainHist=UnitStrains[ElementNo,3]*Fx+UnitStrains[ElementNo,4]*Fy+UnitStrains[ElementNo,5]*Mz

            EndIn=len(StrainHist)
            Extrema=np.bitwise_or(np.bitwise_and(StrainHist[1:EndIn-1]<=StrainHist[0:EndIn-2] , StrainHist[1:EndIn-1]<=StrainHist[2:EndIn]),np.bitwise_and(StrainHist[1:EndIn-1]>=StrainHist[0:EndIn-2] , StrainHist[1:EndIn-1]>=StrainHist[2:EndIn]))
            Extrema=np.concatenate((np.array([True]),Extrema,np.array([True])),axis=0)
            Extrema=StrainHist[np.where(Extrema==True)]
            del StrainHist
            #Do fatigue analysis
        self.statustext.emit('Analysing load case '+str(LoadCaseNo+1)+' of '+str(len(LoadCases[0]['LoadCaseLoops']))+' - '+str(((SectionNo+1)*100)/SectionCount)+'% complete')
        del MxLow,MxHigh,MyLow,MyHigh,MzLow,MzHigh,FxLow,FxHigh,FyLow,FyHigh,FzLow,FzHigh,Mx,My,Mz,Fx,Fy,Fz,Distance0,Distance1
    gc.collect()

显然某个地方存在保留周期或其他泄漏，但是如果没有看到您的代码，就不可能说更多。但由于您似乎对解决方法比解决方案更感兴趣......

在 MatLab 中，我使用“pack”函数将工作区写入磁盘，清除它，然后在每个循环结束时重新加载它。我知道这不是一个好的做法，但它可以完成工作！我可以用 Python 做同样的事情吗？

不，Python 没有任何等效项pack。 （当然，如果你确切地知道你想要保留哪一组值，你总是可以np.savetxt or pickle.dump或者以其他方式藏起来，然后exec or spawn一个新的解释器实例，然后np.loadtxt or pickle.load或以其他方式恢复这些值。但是，如果您确切地知道要保留哪一组值，那么您可能一开始就不会遇到此问题，除非您实际上在 NumPy 中遇到了未知的内存泄漏，而这种情况不太可能发生。）

但它有一些东西可能是better。启动一个子进程来分析每个元素（或每批元素，如果它们足够小以至于进程产生的开销很重要），将结果发送回文件或通过队列，然后退出。

例如，如果您这样做：

def analyze(thingy):
    a = build_giant_array(thingy)
    result = process_giant_array(a)
    return result

total = 0
for thingy in thingies:
    total += analyze(thingy)

你可以把它改成这样：

def wrap_analyze(thingy, q):
    q.put(analyze(thingy))

total = 0
for thingy in thingies:
    q = multiprocessing.Queue()
    p = multiprocessing.Process(target=wrap_analyze, args=(thingy, q))
    p.start()
    p.join()
    total += q.get()

（这假设每个thingy and result既小又可腌制。如果它是一个巨大的 NumPy 数组，请查看 NumPy 的共享内存包装器，这些包装器旨在使您需要时变得更容易进程之间直接共享内存 https://docs.python.org/2/library/multiprocessing.html#sharing-state-between-processes而不是通过它。）

但您可能想看看什么multiprocessing.Pool https://docs.python.org/2/library/multiprocessing.html#module-multiprocessing.pool可以为您自动执行此操作（并且更容易扩展代码，例如并行使用所有核心）。请注意，它有一个maxtasksperchild参数，您可以使用该参数每隔 10 个事物回收一次池进程，这样它们就不会耗尽内存。

但回到实际尝试简单地解决问题：

我尝试通过删除每个循环末尾的负载情况数组（删除所有作为其切片的数组之后）并运行 gc.collect() 来解决此问题，但这没有取得任何成功。

这些都不会产生任何影响。如果您只是每次通过循环将所有局部变量重新分配给新值，并且不在其他任何地方保留对它们的引用，那么它们无论如何都会被释放，所以您永远不会拥有超过一次（短暂）2次。和gc.collect()仅当存在引用循环时才有帮助。因此，一方面，这些没有效果是个好消息——这意味着您的代码中没有任何明显愚蠢的内容。另一方面，这是个坏消息——这意味着无论出现什么问题，都并不明显是愚蠢的。

通常人们会看到这一点，因为他们在没有意识到的情况下不断增长一些数据结构。例如，也许你vstack将所有新行移到旧版本上giant_array而不是到一个空数组，然后删除旧版本......但这并不重要，因为每次循环时，giant_array不是 5*N，而是 5*N，然后是 10*N，然后是 15*N，依此类推。 （这只是一个愚蠢的例子I不久前...同样，在对代码一无所知的情况下很难给出更具体的示例。）