koila
1.0.0
Koila resolve
CUDA error: out of memory errorsem problemas. Corrija -o com apenas uma linha de código e esqueça.
A ramificação principal é uma reestrutura completa do projeto (atualmente está principalmente vazia porque não tenho tempo suficiente para concluí-lo). Para ver o código de trabalho, consulte a tag v0.1.1 para uma prova de conceito (que não possui suporte total em todas as operações e não é adequado para produção). Para usá -lo, faça o download da versão v0.1.1 aqui.
? Impede CUDA error: out of memory error com uma única linha de código.
⚗️ Acumula automaticamente os gradientes quando os tamanhos de lote são muito grandes.
? A preguiça avalia o código Pytorch para salvar o poder de computação.
✂️ Dividir automaticamente ao longo da dimensão do lote para mais números amigáveis da GPU (poderes de 2) para acelerar a execução.
? API mínima (envolver todas as entradas será suficiente).
Já encontrou RuntimeError: CUDA error: out of memory ? Todos nós amamos PyTorch por causa de sua velocidade, eficiência e transparência, mas isso significa que não faz coisas extras. Coisas como impedir um erro muito comum que incomoda muitos usuários desde 2017.
Esta biblioteca visa impedir isso por ser um invólucro leve sobre PyTorch nativo. Quando um tensor é embrulhado, a biblioteca calcula automaticamente a quantidade de memória GPU restante e usa o tamanho certo em lote , economizando todos de ter que ajustar manualmente o tamanho do lote sempre que um modelo é usado.
Além disso, a biblioteca usa automaticamente o tamanho certo em lote para a GPU. Você sabia que o uso de lotes maiores nem sempre acelera o processamento? Também é tratado automaticamente nesta biblioteca.
Como o código Koila é o código PyTorch , pois executa PyTorch sob o capô, você pode usar os dois juntos sem se preocupar com a compatibilidade.
Ah, e tudo isso em 1 linha de código! ?
Koila está disponível no Pypi. Para instalar, execute o seguinte comando.
pip install koila O uso é morto simples. Por exemplo, você tem o seguinte código PyTorch (copiado do tutorial de PyTorch )
Defina a entrada, etiqueta e 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 a função de perda, calcule a saída e as perdas.
loss_fn = CrossEntropyLoss ()
# Calculate losses
out = nn ( t )
loss = loss_fn ( out , label )
# Backward pass
nn . zero_grad ()
loss . backward () OK. Como adaptar o código para usar os recursos de Koila ?
Você adiciona esta linha de código (a partir da 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 )Feito. Você não ficará sem memória novamente.
CUDA error: out of memory geralmente ocorre no passe para a frente, porque as variáveis temporárias precisarão ser salvas na memória.
Koila é um invólucro fino em torno de PyTorch . É inspirado na avaliação estática/preguiçosa da Tensorflow. Ao criar o gráfico primeiro e executar o modelo apenas quando necessariamente, o modelo tem acesso a todas as informações necessariamente para determinar quantos recursos são realmente precisam calcular o modelo.
Em termos de uso da memória, apenas formas de variáveis temporárias são necessárias para calcular o uso da memória dessas variáveis usadas no modelo . Por exemplo, + toma dois tensores com tamanhos iguais e produz um tensor com um tamanho igual ao tamanho da entrada, e log recebe um tensor e produz outro tensor com a mesma forma. A transmissão o torna um pouco mais complicado do que isso, mas as idéias gerais são as mesmas. Ao rastrear todas essas formas, pode -se dizer facilmente quanta memória é usada em um passe para a frente. E selecione o tamanho ideal do lote de acordo.
NÃO . De fato, calcular formas e calcular o tamanho e o uso da memória parecem muito trabalho. No entanto, lembre-se de que mesmo um modelo gigantesco como o GPT-3, que possui 96 camadas, possui apenas algumas centenas de nós em seu gráfico de computação. Como os algoritmos de Koila são executados em tempo linear, qualquer computador moderno poderá lidar com um gráfico como este instantaneamente.
A maior parte da computação é gasta na computação de tensores individuais e na transferência de tensores para os dispositivos. E lembre -se de que essas verificações acontecem na baunilha PyTorch de qualquer maneira. Portanto, não, não lento.
Este projeto foi originalmente chamado Koala , a espécie mais preguiçosa do mundo, e este projeto é sobre avaliação preguiçosa dos tensores. No entanto, como esse nome é levado ao Pypi, eu não tinha escolha a não ser usar outro nome. Koila é uma palavra composta por mim, pronunciada de maneira semelhante a voila (é uma palavra francesa), então soa como coala.
Se você gosta do que vê, considere dar a isso uma estrela (★)!
Por que sofri o problema e construí este projeto, apesar de muitas bibliotecas semelhantes na internet?
A pesquisa de tamanho em lote não é nova. De fato, o poderoso raio popular tem.
A pesquisa de tamanho do lote da Lightning é profundamente integrada em seu próprio ecossistema. Você precisa usar o DataLoader , a subclasse de seus modelos e treinar seus modelos de acordo. Embora as tarefas de aprendizado supervisionado para refatorar seja relativamente fáceis, é realmente doloroso fazer o mesmo com uma base de código de aprendizado de reforço, onde a interação com o ambiente é uma obrigação.
Em comparação, como Koila é um invólucro pytorch super leve, ele funciona quando o Pytorch funciona, fornecendo a máxima flexibilidade e alterações mínimas no código existente.
No entanto, observe que, no caso em que você está escrevendo um novo código, o Lightning é recomendado, pois aplica um melhor padrão de estilo de código, que beneficiaria a modularidade a longo prazo.
Da mesma forma, passar um tensor vazio para criar um gráfico computacional (também conhecido como gráfico estático ) não é uma ideia nova, mas completamente explorada na popular biblioteca Tensorflow e uma biblioteca de wrapper PyTorch semelhante Keops. Essas bibliotecas sofrem com o fato de que os programas de depuração são desnecessariamente complicados. Por exemplo, TensorFlow era conhecido por sua facilidade de implantação, mas dor no desenvolvimento, a ponto de os usuários mudaram para PyTorch . Durante a depuração, as pessoas gostam de ver o que está dentro de uma variável, para ver se ela contém um valor incorreto. No entanto, como os gráficos estáticos definem apenas as relações, os valores não são calculados, dificultando a depuração.
Koila resolve isso avaliando ansiosamente ao ser convertido em cordas, números inteiros ou valores python. Isso permite a depuração perfeita, mantendo a capacidade de executar o gerenciamento de memória que simplesmente não está disponível para um programa PyTorch mais direto, que dinamicamente (quando necessário) aloca e libera memória em tempo real.
Tensor e LazyTensor ). O código funciona em muitos casos, mas ainda é um trabalho em andamento. Ainda não é (ainda) uma biblioteca compatível PyTorch devido a tempo limitado. Evite usá -lo em ambientes de produção!
Abertura e inclusão são levadas muito a sério. O código está disponível na licença Apache. Siga o seguinte código de conduta.
