Question

我在缓存中存储了3个矩阵，用于计算过程。总的来说，它们有50.000行和500列。

每次我需要执行该计算时，我会复制这3个矩阵，操纵它们，执行计算并从缓存中删除它们。

计算由Web服务调用触发，计算结果提供Web服务输出。 Web服务由Django应用程序管理，而矩阵和计算由基于Numpy的应用程序管理。

我的问题与表现有关。每当Django获得Web服务调用时，它都会触发基于Numpy的应用程序，该应用程序访问缓存以复制矩阵。问题是访问缓存并复制矩阵需要5秒钟。在我看来，复制矩阵几乎应该是即时的，所以我认为问题与访问缓存有关。

我使用了缓存解决方案，因为这是我发现保持矩阵永久性且与用户会话无关的唯一方法。

一般来说，我有两种方法可以解决问题： 1）改进当前的解决方案，使缓存访问和矩阵复制成为瞬时过程; 2）转向一个独特的解决方案，但我不知道它可能是什么。

关于如何解决问题的任何想法？

我希望下面的代码有用。使进程变慢的指令是最后一个（cache.get（＆＃34; account＆＃34; + id）

@api_view(['POST'])
def recommend(request):
    params = request.data
    try:        
        rec = Recomendation(params)
        logger.info(rec.time)
        response = rec.recomend()
        return Response(response,status=status.HTTP_200_OK)
    except Exception as e:
        return Response(e,status=status.HTTP_500_INTERNAL_SERVER_ERROR)

class Recomendation():
    def __init__(self,data):
        start_time = time.time()
        self.account = tryAccount(data["AccountID"]) #return the matrix
        if self.account:
            self.store = self.account.getStore(data["StoreID"]) #Selects a store

            try:
                #Purchase parameters
                self.sellingHour = data["Time"]
                self.temperature = data["Temperature"]
                self.registeredItems = data["ItemsList"]
                self.weekDay = data["WeekDay"]
                self.weekDayWeight = data["WeekDayWeight"]
                self.monthWeek = data["MonthWeek"]
                self.monthWeekWeight = data["MonthWeekWeight"]
                self.BaseSup = data["TimeSuperiorPlateau"]
                self.BaseInf = data["TimeInferiorPlateau"]
                self.Height = data["TimeMinWeight"]
                self.environmentFilterOn = data["EnvironmentFilterOn"]
                self.sellingTemperature = data["Temperature"]
                self.tempBaseSup = data["TempSuperiorPlateau"]
                self.tempBaseInf = data["TempInferiorPlateau"]
                self.tempHeight = data["TempMinWeight"]
                self.rainy = data["Rainy"]
                self.rainyWeight = data["RainyWeight"]
                self.itensToRecommend = data["ItemsToRecommend"]
            except Exception as e:
                print(e)

            #Do code here
            self.utilityMatrix = np.asarray(self.store.utilityMatrix)
            self.productMatrix = np.asarray(self.store.productMatrix)
            self.contextMatrix = np.asarray(self.store.contextMatrix)

        else: 
        print(“error”)

    endtime = time.time()
        self.time = endtime - start_time

#another scope
def tryAccount(id):
    return cache.get("account"+id)

Answer 1

如何序列化numpy数组而不是将它们存储在缓存中？ Here就是你这样做的。

当然，基于内存的解决方案会更好，但是对于那么大的东西，从磁盘读取应该是快速的。

np.load(filename)会给你回复你的矩阵。

更新

我刚刚意识到Python可以解决你的问题。当Python在某处导入文件/库时，它只会执行一次，然后在某处缓存加载。所以你要制作一个看起来像这样的文件

print("loading matrices")
m1, m2, m3 = numpy.loads('./filename1.npy'), \
    numpy.loads('./filename2.npy'), numpy.loads('./filename3.npy')
print("matrices loaded")

def operation_one(inputs):
    m1_c, m2_c, m3_c = m1.copy(), m2.copy(), m3.copy()
    # Do the rest of your fist operation

然后，只要您需要使用此操作，只需导入该文件即可。我相信无论您导入该文件多少次，它都只会从磁盘加载一次矩阵。并且您可以确保operation_one不会修改原始矩阵。

将基于Numpy的应用程序与Django API连接

1 个答案:

更新