Привет у меня есть проблемы с быстрым умножением матрицы, сложением, function_overwrite и суммированием с уменьшением оси и работой в numpy.memmaps поверх процессора без оперативной памяти (я думаю). Только при использовании Numberxpr я могу избежать создания массива из точки.

For example:

a=np.require(np.memmap('a.npy',mode='w+',order='C',dtype=np.float64,shape=(10,1)),requirements=['O']) 
b=np.memmap('b.npy',mode='w+',order='C',dtype=np.float64,shape=(1,5))
c=np.memmap('c.npy',mode='w+',order='C',dtype=np.float64,shape=(1,5))
#func -> some method, like i.e. sin()
#in numexpr it will be simple
ne.evaluate('sum(func(b*a+c),axis=1)')
#in numpy with einsum it will have to be with creating additional out-of-dot handling array
d=np.require(np.memmap('d.npy',mode='w+',order='C',dtype=np.float64,shape=(10,5)),requirements=['O']) 

np.einsum('ij,kj->ki',b,a,out=d)
d+=c
func(d,out=d)
np.einsum('ij->i',d,out=c)

Можно ли даже сделать это быстрее, используя процессор без оперативной памяти, чем это делает цифра? Как насчет Cython + FORTRAN Lapack или Blass? Любые советы или рекомендации приветствуются! Спасибо за любую помощь!

РЕДАКЦИОННАЯ ИНФОРМАЦИЯ: Кстати, я работаю на ноутбуке с процессором Intel Core2Duo t9300, оперативной памятью 2,7 ГБ (только из 4 ГБ видно из-за проблемы с биосом), 250 ГБ SSD, старым графическим процессором Intel. Из-за низкого уровня оперативной памяти, которая используется в основном Firefox с некоторыми дополнениями, для кодирования не так много осталось, поэтому я избегаю его использования xD.

И я чувствую, что я на продвинутом уровне (шаг 1/1000) в программировании, когда на данный момент я не знаю, как работает код на аппаратном уровне - я только догадываюсь об этом (поэтому некоторые ошибки в моем представлении могут выглядеть как xD).

РЕДАКТИРОВАТЬ: Я сделал некоторый код на Cython для вычисления синусоидальных волн с помощью Numberxpr и Cython Prange для цикла.

Данные пульсации (для om, eps, Spectra, Amplitude) хранятся в OM numpy.memmap, а данные времени (t, z) в TI numpy.memmap. ОМ имеет форму (4,1,2500), а ТИ - форму (2,1,5e + 5,1) - мне просто нужно, чтобы она была в этой форме.

cdef inline void sine_wave_numexpr(OM,TI,int num_of_threads):

    cdef long m,n=10
    cdef Py_ssize_t s=TI.shape[2]/n
    cdef str ex_sine_wave=r'sum(A*sin(om*ti+eps),axis=1)'
    cdef dict dct={'A':OM[3],'om':OM[0],'eps':OM[2]}
    for m in range(n):
        sl=slice(s*m,s*(m+1))
        dct['ti']=TI[0,0,sl]
        evaluate(ex_sine_wave,
                    global_dict=dct,
                    out=TI[1,0,sl,0])
cdef inline void sine_wave_cython(double[:,:,::1]OM,double[:,:,:,::1]TI,int num_of_threads):
    cdef int i,j
    cdef Py_ssize_t n,m
    cdef double t,A,om,eps
    n=OM.shape[2]
    m=TI.shape[2]
    for i in prange(m,nogil=True,num_threads=num_of_threads):
        t=TI[0,0,i,0]
        for j in prange(n,num_threads=num_of_threads):
            A=OM[3,0,j]
            om=OM[0,0,j]
            eps=OM[2,0,j]
            TI[1,0,i,0]+=A*sin(om*t+eps)

cpdef inline void wave_elevation(double dom,OM,TI,int num_of_threads, str method='cython'):
    cdef int ni
    cdef double i,j
    cdef Py_ssize_t shape=OM.shape[2]
    numexpr_threads(num_of_threads)
    OM[2,0]=2.*np.random.standard_normal(shape)
    evaluate('sqrt(dom*2*S)',out=OM[3],
            local_dict={'dom':dom,'S':OM[1]})
    if method=='cython':
        sine_wave_cython(OM,TI,num_of_threads)
    elif method=='numexpr':
        sine_wave_numexpr(OM,TI,num_of_threads)
    TI.shape=TI.shape[:3]

Я только начинаю с Cython, поэтому он не может быть хорошо оптимизирован. На данный момент код с prange занимает то же время, что и с Numberxpr (использование ОЗУ составляет 100 МБ для всего кода с этой частью, ЦП составляет 50%, SSD низкое - время расчета составляет 1-2 минуты). Я пытался с просмотром памяти, но это создало несколько локальных копий и использовало ОЗУ с течением времени. Мне понадобится продвинутый уровень, шаг 3/1000, чтобы понять, как работать с представлениями памяти.