koila
1.0.0
Koila resuelve
CUDA error: out of memory errorsin dolor. Arreglarlo con solo una línea de código y olvídalo.
La rama principal es una reestructura completa del proyecto (que actualmente está en su mayoría vacía debido a que no tengo suficiente tiempo para completarlo). Para ver el código de trabajo, consulte la etiqueta v0.1.1 para obtener una prueba de concepto (que no tiene soporte total sobre todas las operaciones y no es adecuada para la producción). Para usarlo, descargue la versión v0.1.1 aquí.
? Previene CUDA error: out of memory error con una sola línea de código.
⚗️ Acumula automáticamente los gradientes cuando los tamaños de lotes son demasiado grandes.
? Lazily evalúa el código Pytorch para guardar la alimentación informática.
✂️ Se divide automáticamente a lo largo de la dimensión de lotes a más números amigables con la GPU (poderes de 2) para acelerar la ejecución.
? API mínima (envolver todas las entradas será suficiente).
Alguna vez se ha encontrado con RuntimeError: CUDA error: out of memory ? Todos amamos PyTorch debido a su velocidad, eficiencia y transparencia, pero eso significa que no hace cosas adicionales. Cosas como prevenir un error muy común que ha estado molestando a muchos usuarios desde 2017.
Esta biblioteca tiene como objetivo evitar eso al ser un envoltorio de peso ligero sobre PyTorch nativo. Cuando se envuelve un tensor, la biblioteca calcula automáticamente la cantidad de memoria de GPU restante y usa el tamaño de lote derecho , ahorrando a todos desde que tienen que ajustar manualmente el tamaño de lote cada vez que se usa un modelo.
Además, la biblioteca usa automáticamente el tamaño de lote derecho para GPU. ¿Sabía que usar lotes más grandes no siempre acelera el procesamiento? También se maneja automáticamente en esta biblioteca.
Debido a que el código Koila es el código PyTorch , ya que ejecuta PyTorch debajo del capó, puede usar ambos juntos sin preocupar la compatibilidad.
¡Ah, y todo eso en 1 línea de código! ?
Koila está disponible en Pypi. Para instalar, ejecute el siguiente comando.
pip install koila El uso es completamente simple. Por ejemplo, tiene el siguiente código PyTorch (copiado del tutorial de PyTorch )
Defina la entrada, la etiqueta y el modelo:
# A batch of MNIST image
input = torch . randn ( 8 , 28 , 28 )
# A batch of labels
label = torch . randn ( 0 , 10 , [ 8 ])
class NeuralNetwork ( Module ):
def __init__ ( self ):
super ( NeuralNetwork , self ). __init__ ()
self . flatten = Flatten ()
self . linear_relu_stack = Sequential (
Linear ( 28 * 28 , 512 ),
ReLU (),
Linear ( 512 , 512 ),
ReLU (),
Linear ( 512 , 10 ),
)
def forward ( self , x ):
x = self . flatten ( x )
logits = self . linear_relu_stack ( x )
return logitsDefina la función de pérdida, calcule la salida y las pérdidas.
loss_fn = CrossEntropyLoss ()
# Calculate losses
out = nn ( t )
loss = loss_fn ( out , label )
# Backward pass
nn . zero_grad ()
loss . backward () De acuerdo. ¿Cómo adaptar el código para usar las funciones de Koila ?
Agrega esta línea de código (a partir de V0.1.1):
# Wrap the input tensor and label tensor.
# If a batch argument is provided, that dimension of the tensor would be treated as the batch.
# In this case, the first dimension (dim=0) is used as batch's dimension.
( input , label ) = lazy ( input , label , batch = 0 )Hecho. No volverás a salir sin memoria.
CUDA error: out of memory generalmente ocurre en el pase hacia adelante, porque las variables temporales deberán guardar en la memoria.
Koila es una envoltura delgada alrededor de PyTorch . Está inspirado en la evaluación estática/perezosa de Tensorflow. Al construir el gráfico primero y ejecutar el modelo solo cuando necesariamente, el modelo tiene acceso a toda la información necesariamente para determinar cuántos recursos realmente se necesitan para calcular el modelo.
En términos de uso de la memoria, solo se requieren formas de variables temporales para calcular el uso de la memoria de las variables utilizadas en el modelo . Por ejemplo, + toma dos tensores con tamaños iguales, y genera un tensor con un tamaño igual al tamaño de entrada, y log toma un tensor y genera otro tensor con la misma forma. La transmisión lo hace un poco más complicado que eso, pero las ideas generales son las mismas. Al rastrear todas estas formas, uno podría saber fácilmente cuánta memoria se usa en un pase hacia adelante. Y seleccione el tamaño de lote óptimo en consecuencia.
NO . De hecho, calcular formas y calcular el tamaño y el uso de la memoria suenan como mucho trabajo. Sin embargo, tenga en cuenta que incluso un modelo gigantesco como GPT-3, que tiene 96 capas, tiene solo unos pocos cientos de nodos en su gráfico informático. Debido a que los algoritmos de Koila se ejecutan en tiempo lineal, cualquier computadora moderna podrá manejar un gráfico como este al instante.
La mayor parte de la computación se gana en calcular tensores individuales y transferir tensores a través de dispositivos. Y tenga en cuenta que esos cheques ocurren en Vanilla PyTorch de todos modos. Así que no, no lento en absoluto.
Este proyecto se llamaba originalmente Koala , la especie más perezosa del mundo, y este proyecto trata sobre la evaluación perezosa de tensores. Sin embargo, como se toma ese nombre en Pypi, no tuve más remedio que usar otro nombre. Koila es una palabra formada por mí, pronunciada de manera similar a Voila (es una palabra francesa), por lo que suena como koala.
Si te gusta lo que ve, ¡considera darle una estrella (★)!
¿Por qué tuve el problema y construí este proyecto, a pesar de muchas bibliotecas similares en Internet?
La búsqueda en el tamaño del lote no es nueva. De hecho, el poderoso rayo popular lo tiene.
La búsqueda de tamaño por lotes de Lightning está profundamente integrada en su propio ecosistema. Debe usar su DataLoader , subclase de sus modelos y capacitar a sus modelos en consecuencia. Si bien la refactorización de las tareas de aprendizaje supervisadas para usar un rayo es relativamente fácil, es realmente doloroso hacer lo mismo con una base de código de aprendizaje de refuerzo, donde interactuar con el entorno es imprescindible.
En comparación, debido a que Koila es un envoltorio de pytorch súper ligero, funciona cuando Pytorch funciona, proporcionando así la máxima flexibilidad y cambios mínimos en el código existente.
Sin embargo, tenga en cuenta que en el caso en que está escribiendo un nuevo código, se recomienda un rayo, ya que aplica un mejor patrón de estilo de código, lo que beneficiaría a la modularidad a largo plazo.
Del mismo modo, pasar un tensor vacío para construir un gráfico computacional (también conocido como gráfico estático ) no es una idea nueva, pero es completamente explorada en la popular biblioteca TensorFlow, y una biblioteca de envoltura PyTorch similar. Estas bibliotecas sufren el hecho de que la depuración de programas en ellas es innecesariamente complicada. Por ejemplo, TensorFlow era conocido por su facilidad de implementación pero dolor en el desarrollo, hasta el punto de que los usuarios cambiaron a PyTorch . Durante la depuración, a la gente le gusta ver qué hay dentro de una variable, para ver si contiene un valor incorrecto. Sin embargo, debido a que los gráficos estáticos solo definen las relaciones, los valores no se calculan, lo que dificulta la depuración.
Koila resuelve eso al evaluar ansiosamente cuando se convierte en cuerdas, enteros o cualquier valor de Python. Esto permite una depuración perfecta mientras se mantiene la capacidad de realizar la gestión de la memoria que simplemente no está disponible para un programa PyTorch más directo, que dinámicamente (cuando es necesario) asigna y libera memoria sobre la marcha.
Tensor S y LazyTensor s). El código funciona en muchos casos, pero sigue siendo un trabajo en progreso. Esta no es (todavía) una biblioteca compatible PyTorch debido al tiempo limitado. ¡Evite usarlo en entornos de producción!
La apertura y la inclusión se toman muy en serio. El código está disponible bajo la licencia Apache. Siga el siguiente código de conducta.
