python: forma de hacer una rápida multiplicación y reducción de matrices mientras trabaja en memmaps y CPU

Hola, tengo problemas para hacer la multiplicación rápida de matrices, la adición, la función sobrescribir y la sum con reducción de eje y trabajar en numpy.memmaps sobre CPU sin RAM (creo). Solo cuando uso numexpr es posible que evite crear una matriz desde un punto.

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 ie 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) 

¿Es incluso posible hacerlo más rápido usando la CPU sin RAM que numexpr hacerlo? ¿Qué hay de Cython + FORTRAN lapack o blass? Cualquier consejo o truco son bienvenidos! ¡Gracias por cualquier ayuda!

INFORMACIÓN EDITADA: Por cierto, estoy trabajando en una computadora portátil con CPU Intel Core2Duo t9300, 2.7 GB de RAM (solo se ve desde 4 GB, debido a algún problema de BIOS), SSD de 250 GB, antigua GPU de Intel. Debido al bajo nivel de RAM que se usa principalmente en Firefox con algunos complementos, no queda mucho para la encoding, por eso estoy evitando su uso xD.

Y siento que estoy en el nivel avanzado (paso 1/1000) en la progtwigción cuando por ahora no sé cómo funciona el código en el hardware, supongo que solo (por lo que algunos errores al pensar en el mío pueden aparecer xD).

EDITAR: Hice algo de código en cython para calcular las ondas sinusoidales con numexpr y cython prange for-loop.

Los datos de pulsación (para om, eps, Spectra, Amplitude) se almacenan en OM numpy.memmap y los datos de tiempo (t, z) en TI numpy.memmap. OM tiene una forma similar a (4,1,2500) y TI tiene una forma similar a (2,1,5e + 5,1). Solo la necesito en esa forma.

 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] 

Estoy empezando con Cython, por lo que puede que no esté bien optimizado. Por ahora, el código con prange está tomando el mismo tiempo que con numexpr (el uso de RAM es de 100 MB para todo el código con esta parte incluida, la CPU es del 50%, la SSD es baja, el tiempo de cálculo es de 1 a 2 minutos). Lo intenté con vistas de memoria, pero eso creó algunas copias locales y usé RAM con el tiempo disminuyendo. Necesitaré un nivel avanzado de nivel 3/1000 para comprender cómo trabajar con vistas de memoria.