es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

Llamando a una función jitted de otro archivo Python

Tengo un proyecto en Python con la siguiente estructura de documentos:

/scripts
    main.py
/classes
    myclass.py
    ...

La clase definida en myclass.py tiene un método que pretendo acelerar. He logrado esto utilizando “jitting” en algunas partes, convirtiéndolas en funciones de modo que myclass.py quede de la siguiente manera:

def myclass:
    def method1:
        ...
    def method2:
        ...
        out1 = function1(inputs)
        out2 = function2(out1,other_inputs)
    ...
@njit()
def function1(inputs)
    ...
@njit()
def function2(inputs)
    ...

Cuando llamo a las funciones “jitted” dos veces sin salir de myclass.py, se ejecutan más rápido durante la segunda llamada. Este es un resultado esperado debido a la compilación durante la primera llamada. Sin embargo, cuando llamo al método de la clase desde fuera de myclass.py por segunda vez (en mi caso, desde main.py), las funciones “jitted” se compilan de nuevo y no puedo aprovechar la aceleración en absoluto.
Para este caso de uso, la compilación por adelantado (AoT) parece ser una solución, pero la necesidad de definir explícitamente las firmas de funciones actualmente me impide utilizarla. Por lo tanto, me pregunto si hay alguna forma de conservar las versiones aceleradas de mis funciones entre diferentes archivos sin utilizar la compilación AoT.
Gracias por las respuestas.

Tags:  , , ,

Answer

  1. Avatar for davy.ai

    Parece que el problema aquí es que las funciones compiladas en tiempo de ejecución no se están almacenando en caché en varios archivos. Una forma de abordar este problema sin utilizar la compilación AoT es utilizar el almacenamiento en caché de funciones del módulo functools. Esto permite devolver resultados previamente calculados en lugar de volver a calcularlos, lo cual puede ahorrar tiempo si la misma función se llama varias veces con los mismos argumentos. A continuación se muestra un ejemplo de cómo utilizar el almacenamiento en caché de funciones con tus funciones function1 y function2 compiladas en tiempo de ejecución:

    from functools import lru_cache
    
    @lru_cache(maxsize=None)
    @njit()
    def function1(inputs):
        ...
    
    @lru_cache(maxsize=None)
    @njit()
    def function2(inputs):
        ...
    

    Esto almacenará en caché los resultados de las funciones function1 y function2, de modo que no sea necesario volver a compilarlas cada vez que se llamen con los mismos argumentos. Ten en cuenta que si los argumentos de entrada cambian, la función deberá volver a compilarse.

Comments are closed.