SpeedTorch
1.0.0
Mais rápido fixou o tensor da CPU <-> GPU Pytorch Variabe Transfer e GPU Tensor <-> GPU Pytorch Variable Transfer, em certos casos.
Como para alguns sistemas, o uso dos tensores de Pytorch Pytorch fixados é mais rápido do que o uso de tensores de Cupy (consulte a seção 'Como ele funciona' para obter mais detalhes), criei as classes gerais de tensoras de pytorch PytorchModelFactory e PytorchOptimizerFactory , que podem especificar os tensores para cuda ou cpu , e a Using, e que pode especificar os tensores para covarde ou CPU, e especificar, e especificar, se o que pode definir os tensores para covarde cpu . As classes originais GPUPytorchModelFactory e GPUPytorchOptimizerFactory ainda estão na biblioteca; portanto, nenhum código existente usando Speedtorch deve ser afetado. A documentação foi atualizada para incluir essas novas classes.
Esta biblioteca se renova em torno dos tensores de Cupy presos à CPU, que pode atingir 3,1x de transferência de CPU mais rápida -> GPU do que os tensores de CPU presos com pytorch regulares e 410x GPU mais rápido -> transferência de CPU. A velocidade depende da quantidade de dados e do número de núcleos da CPU em seu sistema (consulte a seção de como ele funciona para obter mais detalhes)
A biblioteca inclui funções para o treinamento de incorporação; Ele pode hospedar incorporações na CPU RAM enquanto elas estão ociosas e poupadoras de RAM da GPU.
Inicialmente, criei esta biblioteca para ajudar a treinar um grande número de incorporações, que a GPU pode ter problemas para manter na RAM. Para fazer isso, descobri que hospedando algumas das incorporações na CPU pode ajudar a conseguir isso. Os sistemas de incorporação usam treinamento da Sprase; Somente a fração do total de carross participam das etapas de encaminhamento/atualização, o restante está ocioso. Então, imaginei, por que não manter os parâmetros ociosos fora da GPU durante a etapa de treinamento? Para isso, eu precisava da transferência rápida da CPU -> GPU.
Para a história de fundo completa, consulte a página do devpost
https://devpost.com/software/speedtorch-6w5unb
Com a CPU-> GPU rápida, muitos métodos divertidos podem ser desenvolvidos para funcionalidades que anteriormente as pessoas pensavam que podem não ter sido possíveis.
? ️ Incorpore o speedtorch em seus pipelines de dados para transferência rápida de dados para/da CPU <-> GPU
? Aste Parâmetros de treinamento AUMENTO AUGUMO via armazenamento da CPU. Enquanto você tiver RAM de CPU suficiente, poderá hospedar qualquer número de incorporações sem ter que se preocupar com a RAM da GPU.
? Aste Use Adadelta, Adamax, RMSPROP, RPROP, ASGD, Adamw e Adam Optimizers para treinamento esparso de incorporação. Anteriormente, apenas SpraSeadam, Adagrad e SGD eram adequados, pois apenas estes suportam diretamente gradientes esparsos.
(Editar 9-20-19, um dos desenvolvedores de Pytorch apontou alguns insetos menores no código de marcação de bancada original, os valores e o código foram atualizados)
Aqui está um notebook comparando a transferência via tensores SpeedtorChorch vs pytorch, com os tensores de CPU e CUDA presos. Todos os testes foram feitos com uma instância do COLAB com uma GPU Tesla K80 e 2 CPU do núcleo.
ATUALIZAÇÃO 10-17-19: O Google Colab agora é padrão com 4 CPUs principais, então este notebook fornecerá resultados diferentes do que é relatado abaixo, já que os kerais de indexação de Pytorch ficam mais eficientes à medida que o número de núcleos da CPU aumenta.
https://colab.research.google.com/drive/1pxhbmbzqtiq_nlfguianpf_mfpiqskks
Este notebook vezes a transferência de dados de 131.072 incorporação de Float32 da dimensão 128, de e para os tensores de Cupy/Pytorch e variáveis pytorch, com n = 100. A CPU do Google Colab possui 4 núcleos, o que tem um impacto na velocidade de transferência. As CPUs com um número maior de núcleos terão menos advertência para usar o Speedtorch.
A tabela abaixo é um resumo dos resultados. Transferindo dados dos tensores pytorch CUDA para a variável de incorporação de Cuda pytorch é mais rápida que o equivalente a Speedtorch, mas para todos os outros tipos de transferência, o Speedtorch é mais rápido. E para a soma de ambas as etapas transferidas para/para a incorporação de Cuda pytorch, o Speedtorch é mais rápido que o equivalente a Pytorch para os tensores com GPU e CPU regulares.
Percebi que diferentes instâncias de COLAB resultam em diferentes resultados de velocidade, portanto, lembre -se disso enquanto revisa esses resultados. Uma execução pessoal do notebook Colab pode resultar em valores diferentes, embora a ordem de magnetude dos resultados seja geralmente a mesma.
Os tempos de transferência nas tabelas a seguir são apresentados em segundos. Este benchmarking foi pré -formado com uma instância do COLAB cuja CPU possui 2 núcleos. O COLAB possui uma versão Pro de instâncias pagas que são 4 CPUs principais, portanto, o seguinte benchmarking não refletiria para essas instâncias.
| Tipo de tensor | Para Cuda pytorch variável | Comparação |
|---|---|---|
| Speedtorch (CUDA) | 0,0087 | 6.2x mais lento que o equivalente a Pytorch |
| Speedtorch (PINNEDCPU) | 0,0154 | 3,1x mais rápido que o equivalente a Pytorch |
| Pytorch (CUDA) | 0,0014 | 6,2x mais rápido que o equivalente a Speedtorch |
| Pytorch (PINNEDCPU) | 0,0478 | 3.1x mais lento que o equivalente a Speedtorch |
| Tipo de tensor | Da variável Cuda pytorch | Comparação |
|---|---|---|
| Speedtorch (CUDA) | 0,0035 | 9,7x mais rápido que o equivalente a Pytorch |
| Speedtorch (PINNEDCPU) | 0,0065 | 410x mais rápido que o equivalente a Pytorch |
| Pytorch (CUDA) | 0,0341 | 9,7x mais lento que o equivalente a Speedtorch |
| Pytorch (PINNEDCPU) | 2.6641 | 410x mais lento que o equivalente a Speedtorch |
| Tipo de tensor | Soma de para/da variável cuda pytorch | Comparação |
|---|---|---|
| Speedtorch (CUDA) | 0,0122 | 2.9x mais rápido que o equivalente a Pytorch |
| Speedtorch (PINNEDCPU) | 0,0219 | 124x mais rápido que o equivalente a Pytorch |
| Pytorch (CUDA) | 0,0355 | 2.9x mais lento que o equivalente a Speedtorch |
| Pytorch (PINNEDCPU) | 2.7119 | 124x mais lento que o equivalente a Speedtorch |
Benchmarks semelhantes foram calculados para transferir para/para os otimizadores de Pytorch Cuda. Os resultados são basicamente os mesmos, aqui está o notebook usado para o benchmarking Optimizers
https://colab.research.google.com/drive/1y2nehd8xj-ixfjkj2qwua_ujqjbbhhj5
Embora os tensores do Speedtorch sejam geralmente mais rápidos que os de Pytorch, a desvantagem é que os tensores do Speedtorch usam mais memória. No entanto, como a transferência de dados pode ocorrer mais rapidamente, você pode usar o Speedtorch para aumentar o número de incorporações treinadas em sua arquitetura mantendo os parâmetros na GPU e na CPU.
Esta tabela é um resumo do benchmarking feito no Google Colab. Pela minha experiência, parece haver alguma variação nos valores de memória relatados no COLAB, +-0,30 GB, portanto, lembre-se disso ao revisar esses números. Os valores são para manter um tensor de 10.000.000.000x128 float32.
| Tipo de tensor | CPU (GB) | GPU (GB) |
|---|---|---|
| Cupy Pinnedcpu | 9.93 | 0,06 |
| Pytorch Pinnedcpu | 6.59 | 0,32 |
| Cupy Cuda | 0,39 | 9.61 |
| Pytorch Cuda | 1.82 | 5.09 |
Embora o tempo de Pytorch para/de para o tensor de pytorch GPU <-> pytorch CUDA Variable não seja tão rápido quanto o equivalente a Cupy, a velocidade ainda é viável. Portanto, se a memória ainda é uma preocupação, a melhor abordagem dos dois mundos seria a CPU da CPU da Speedtorch prejudicada os tensores para armazenar parâmetros na CPU e os tensores GPU da Pytorch da Speedtorch para armazenar parâmetros na GPU.
Este é o notebook que usei para medir a quantidade de memória que cada tipo de variável leva. https://colab.research.google.com/drive/1zky7pyupaidrnx2hdtbujwo8juy0xkue Se estiver usando isso no COLAB, você precisará reiniciar o ambiente após cada criação de tensor, para obter uma medida para a próxima dica.
Para a transferência de GPU da CPU, depende da quantidade de dados que estão sendo transferidos e do número de núcleos que você possui. Geralmente, para 1-2 núcleos de CPU, o Speedtorch será muito mais rápido. Mas, à medida que o número de núcleos da CPU aumenta, as operações de indexação da Pytorch CPU <--> GPU ficam mais eficientes. Para mais detalhes sobre isso, consulte a próxima seção 'Como ele funciona'. Para uma maneira fácil de ver se você obtém uma vantagem de velocidade no seu sistema, execute o código de benchmarking no seu sistema, mas altere a quantidade de dados para refletir o valor com o qual você estará trabalhando em seu aplicativo.
Para a transferência da GPU <-> GPU, se estiver usando notações de indexação comum no Vanilla Pytorch, todos os sistemas receberão um aumento de velocidade porque o Speedtorch ignora um bug nas operações de indexação da Pytorch. Mas esse bug pode ser evitado se estiver usando a versão noturna ou apenas usando diferentes noções de indexação, consulte a seção 'Como ele funciona' para obter mais detalhes.
ATUALIZAÇÃO 9-20-19: Inicialmente, não fazia ideia de por que isso é mais rápido do que usar tensores de pytorch; Eu tropecei na vantagem da velocidade por acidente. Mas um dos desenvolvedores de Pytorch no fórum de Pytorch apontou.
Quanto à melhor transferência da CPU <-> GPU, é porque o Speedtorch evita uma operação de indexação da CPU, massquando os tensores da CPU como tensores de GPU. A operação do índice da CPU pode ser lenta se estiver trabalhando com muito poucos núcleos de CPU, como 2 no Google Colab, mas podem ser mais rápidos se você tiver muitos núcleos. Depende de quantos dados você está transferindo e de quantos núcleos você possui.
Quanto à melhor transferência da GPU <-> GPU, é porque o Speedtorch evita um bug na operação de indexação. Esse bug também pode ser evitado usando as compilações noturnas ou usando index_select / index_copy_ em vez de a[idx] em 1.1 / 1.2.
Para mais detalhes, consulte esta postagem de Pytorch
https://discuss.pytorch.org/t/introducting-speedtorch-4x-speed-cpu-gpu-transfer-110x-gpu-cpu-transfer/56147/2
onde um engenheiro de Pytorch fornece uma análise detalhada sobre como os kernais de indexação de Cupy estão resultando em velocidade em determinados casos. Não é a transferência em si que está ficando mais rápido, mas os kernais de indexação que estão sendo usados.
Quanto à maneira como o gerenciamento de memória no Cupy funciona, dirijo para essas duas perguntas do Stackoverflow que fiz, onde o usuário brilhante Robert Crovellla não apenas deu explicações detalhadas, mas também descobri como alocar a memória fixada às matrizes Cupy, desenvolvendo seu próprio alocador de memória para Cupy. Esta é basicamente a tecnologia principal por trás do Speedtorch.
https://stackoverflow.com/questions/57750125/cupy-tofmemoryerror-when-trying-to-cupy-load-arger-dimension-npy-files-in-me
https://stackoverflow.com/questions/57752516/how-to-use-cuda-pinned-zero-copy-memory-for-mesemory-mapped-file
Speedtorch é instalável PIP. Você precisa ter o Cupy instalado e importado antes de importar o Speedtorch.
!pip install SpeedTorch
import cupy
import SpeedTorch
Este notebook COLAB mostra como carregar dados no Speedtorch usando seu gadget de dados e como transferir esses dados para/para uma variável pytorch cuda.
https://colab.research.google.com/drive/185z5gi62azxh-eemfrttjqxeifhobxxf
Consulte o caderno de benchmarking Speed para ver a vantagem de velocidade de usar o Speedtorch.
Para as pessoas que tentam descobrir como usar o Speedtorch, recomendo seguir este exemplo, pois o Word2Vec é um dos algoritmos mais conhecidos no aprendizado de máquina.
https://colab.research.google.com/drive/1apjr3onbgqwm3fbcbkmvwagxidxldxot
O notebook mostra como treinar o Word2Vec da maneira regular e depois mostra como usar o Speedtorch para treinar os mesmos dados, usando um dos otimizadores normalmente não suportados para treinamento escasso. Isso é possível porque, como todas as incorporações contidas na variável de incorporação possuem uma atualização durante cada etapa, você pode definir sparse=False durante a inicialização.
tl; dr:
Treinamento normal : as variáveis de incorporação de pytorch contêm todas as incorporações. O otimizador Pytorch contém todos os pesos de parâmetro correspondentes para cada incorporação.
Speedtorch Traing : as variáveis de incorporação de pytorch contêm apenas um lote de incorporação. O otimizador Pytorch contém apenas todos os pesos de parâmetro correspondentes para esse lote. Os tensores SparSetorch contêm o restante e troca as incorporações/pesos com a variável pytorch em cada etapa.
Em algoritmos de treinamento esparso como Word2vec, luva ou filtragem colaborativa neural, apenas uma fração dos parâmetros totais (incorporados) são treinados a cada etapa. Se a sua GPU não puder lidar com todas as suas incorporações em um tamanho de incorporação desejado, uma opção seria hospedar alguns de seus parâmetros em matrizes de cpu cpu fixadas e transferir esses parâmetros para os tensores do seu modelo, conforme necessário. Fazer isso primário em Pytorch seria muito lento, especialmente porque a transferência de parâmetros entre uma variável pytorch montada em CUDA e um tensor de CPU pytorch fixado pode levar 2,5-3 segundos (no Google Colab). Felizmente, esta etapa leva apenas 0,02-0,03 segundos com o Speedtorch!
Usos do caso:
--2.829.853 INCORMAÇÕES DE LIVROS--
O Speedtorch foi usado no treinamento de 2.829.853 livros para um recomendador de livros raros.
https://github.com/santosh-gupta/lit2vec2
https://devpost.com/software/lit2vec2
Cada livro tinha uma incorporação de tamanho de 400, mas um tamanho de incorporação de 496 poderia ter sido usado, o tamanho de incorporação de 400 foi devido a limites de espaço no meu Drive Google para armazenar as incorporações treinadas :(.
NOTA: Você precisa da versão do notebook Colab que possui 25 GB de RAM, em vez dos 12 GB usuais. Para obter esse tipo de instância, você precisa travar sua instância atual devido a sobrecarregar a RAM e, em seguida, uma nota no canto inferior esquerdo, perguntando se você gostaria de atualizar. Você pode fazer isso fazendo um loop que continua dobrando o tamanho de uma matriz de flutuação Numpy.
https://colab.research.google.com/drive/1aqht-hetihxmet1wjqrorc3q9tfjqj19
Aqui está um link diretamente com o mesmo modelo e dados, mas não usa Speedtorch
https://colab.research.google.com/drive/1idv1jbouzvpcfdsy40wirphedoanti_
Usando o método de treinamento ortodoxo, o maior tamanho de incorporação que o COLAB é capaz de manusear é 255-260, qualquer um mais alto do que isso e um erro de CUDA ocorrerá
RuntimeError: CUDA out of memory. Tried to allocate 2.74 GiB (GPU 0; 11.17 GiB total capacity; 8.22 GiB already allocated; 2.62 GiB free; 5.05 MiB cached)
--14.886.544 PESQUISA DE PESQUISA EMBALAGENS--
https://github.com/santosh-gupta/research2vec2
O Speedtorch pode me permitir treinar 14.886.544 incorporação de artigos de pesquisa com um tamanho de incorporação de 188, permitindo que eu armazene minhas incorporações de destino na CPU, mantendo meu contexto incorporados na GPU (o otimizador SGD foi usado, portanto, não há peso de otimizador).
Aqui está um link direto para o notebook.
https://colab.research.google.com/drive/1sakzsahoy6o_u1df_z15_qkr5ylni_gr
NOTA: Você precisa da versão do notebook Colab que possui 25 GB de RAM, em vez dos 12 GB usuais. Para obter esse tipo de instância, você precisa travar sua instância atual devido a sobrecarregar a RAM e, em seguida, uma nota no canto inferior esquerdo, perguntando se você gostaria de atualizar. Você pode fazer isso fazendo um loop que continua dobrando o tamanho de uma matriz de flutuação Numpy.
Sem Speedtorch, apenas um tamanho de incorporação de 94-96 pode ser usado na GPU do Google Colab Tesla K80 antes de um RuntimeError: CUDA out of memory . Aqui está uma versão do treinamento sem usar o Speedtorch.
https://colab.research.google.com/drive/1jh7rugeajhdwdgnfwg3twm1zjytqu0kr
Sempre que usando os tensores da GPU Cupy, inicialize -os antes de qualquer tensores de CPU presos. Isso ocorre porque a inicialização dos tensores de GPU da Cupy parece usar uma quantidade sólida de RAM da CPU. Portanto, se você estiver limitado na RAM da CPU e já possui seus tensores de CPU fixados na memória, inicializando os tensores da GPU do Cupy pode causar um acidente.
Se você puder se ajustar a todos os seus parâmetros na memória da GPU, use Pure Pytorch, pois essa é a opção mais rápida para o treinamento. Mas se você não puder se ajustar a todos os seus parâmetros na memória, divida seus parâmetros (lembre -se de que seus otimizadores também têm pesos) entre os tensores Cupy Cuda do Speedtorch e os tensores da CPU da cupy da Speedtorch; Esta é a segunda opções mais rápidas. Mas, se você ainda não é possível ajustar todos os seus parâmetros na memória dessa maneira, divida seus parâmetros entre os tensores da CPU fixados em Cupy do Speedtorch e os tensores pytorch cuda do Speedtorch; Isso é mais lento que as duas opções, mas usa menos memória da GPU. Para a terceira opção, aqui estão dois notebooks que mostram um exemplo deste https://colab.research.google.com/drive/1aqht-hetihxmet1wjqrorc3q9tfjqj19, https://colab.research.google.com/drive/1sakzsahoy6o_u1df_z15_qkr5ylni_gr
Após o treinamento, economizar variáveis CUDA causará um aumento no uso da memória e pode causar um acidente, especialmente com Cupy. Se você está nos limites da sua RAM. Nesse caso, use o método getNumpyVersion para obter uma versão Numpy do seu tensor e, em seguida, use use Numpy.Save ou HDPY/PyTables para salvar sua matriz Numpy. Numpy Save é mais leve.
Abra um problema ou converse comigo diretório no gitter aqui https://gitter.im/speedtorch
Estou procurando mais funcionalidades em torno da transferência rápida da CPU -> GPU. Se você tiver uma ideia, publique um problema no GitHub.
Além disso, a Cupy GPU/CPU marcada e os tensores de GPU Pytorch, o Speedtorch também possui tensores de CPU pytorch e Tensores de GPU de Cupy Memmap/CPU preso. Não encontrei um uso sólido para esses tipos de tensores, mas eles estão totalmente codificados e disponíveis para uso.
https://github.com/santosh-gupta/speedtorch/tree/master/speedtorch
Uma área que eu gostaria de ver é se houver uma maneira de ter redução de memória RAM usando o Cupy Memmaps. Até agora, eles usam tanta memória quanto as versões ao vivo.
ModelFactory ( model_variable , total_classes , embed_dimension , datatype = 'float32' , CPUPinn = False )Cria comutadores para variáveis de modelo usando o Cupy. Variáveis de alternância da sua coleção completa de incorporação e sua coleção de lote de modelos. Cada variável precisa de seu próprio comutador.
Exemplo:
uEmbed_switcher = SpeedTorch . ModelFactory ( skip_gram_modelSparse . u_embeddings , total_classes = 50000 , embed_dimension = 128 )Argumentos:
model_variable : variável específica do seu modelo para o qual você gostaria de criar um comutador.
total_classes : a quantidade total de incorporação a ser treinada.
embed_dimension : dimensão das incorporações.
datatype (Opcional): Datatype para a variável. O padrão é 'float32'.
CPUPinn (Opcional): Pin sua coleção de incorporação completa na CPU. Spares na memória da GPU, mas a transferência de dados será mais lenta. O padrão é falso.
Métodos:
zerosInit() : inicializa a coleção completa do variável switcher com zeros:
uniformDistributionInit(low, high) : inicializa a coleção completa do comutador variável com uma distribuição uniforme de low a high
normalDistributionInit(mean, stdDev) : inicializa a coleção completa do comutador variável com uma distribuição normal com uma média de mean e um desvio padrão de stdDev
variableTransformer( batchSize, posPerBatch, negPerBatch = None ) : configura uma entrada dummy a ser usada para a etapa direta do seu modelo. batchSize é o tamanho do seu lote, e posPerBatch é o número de exemplos positivos por lote. Se uma segunda entrada fictícia for necessária para os exemplos negativos, negPerBatch (opcional) poderá ser definido para o número de exemplos negativos e duas entradas fictícias serão retornadas em vez de uma.
beforeForwardPass(retrievedPosIndexes , retrievedNegIndexes = None) : Switches Incorpordings da coleção de incorporação completa para as incorporações do seu modelo. retrievedPosIndexes são os índices das amostras positivas a serem recuperadas. Se as amostras negativas também forem recuperadas, um valor para retrievedNegIndexes (opcional) também pode ser passado.
afterOptimizerStep( retrievedPosIndexes , retrievedNegIndexes = None) : comutadores atualizados incorporados do seu modelo para a coleção de incorporação completa. retrievedPosIndexes são os índices das amostras positivas que foram recuperadas. Se as amostras negativas também foram recuperadas, um valor para retrievedNegIndexes (opcional) também poderá ser passado.
saveCupy(saveFileName) : salve o tensor no arquivo .npy.
loadCupy(loadFileName) : Carregue o tensor do arquivo .npy.
getNumpyVersion : Obtenha a versão Numpy do Tensor.
OptimizerFactory( given_optimizer, total_classes, embed_dimension, model, variable_name, dtype='float32' , CPUPinn = False)
Crie comutadores para variáveis de otimizador usando Cupy. Variáveis de alternância da sua coleção completa de incorporação e sua coleção de lote de otimizador. Cada variável precisa de seu próprio comutador.
Exemplo:
uAdagrad_switcher = SpeedTorch . OptimizerFactory ( given_optimizer , total_classes , embed_dimension , model , variable_name , dtype = 'float32' , CPUPinn = False )Argumentos:
given_optimizer : O otimizador é inicializado com os pesos do seu modelo. Se estiver usando para o treinamento de incorporação, lembre -se de definir o parâmetro sparse como False . Atualmente, os otimizadores suportados são SparsEadam, Adadelta, Adamax, Adam, Adamw, ASGD e RMSPROP. O RPROP também está incluído, mas precisa do primeiro passe para a frente e a etapa loss.backward() a ser concluída para inicializar a instância do OptimizerFactory. Isso se deve ao otimizador RPROP que precisando de gradientes de seus parâmetros para inicialização.
total_classes : a quantidade total de incorporação a ser treinada.
embed_dimension : dimensão das incorporações.
model : a instância do seu modelo.
variable_name : nome exato da variável definida em seu modelo.
dtype (Opcional): Tipo de dados da sua variável. O padrão é 'float32'
CPUPinn (Opcional): Pin seu otimizador completo Coleta de peso variável na CPU. Spares na memória da GPU, mas a transferência de dados será mais lenta. O padrão é falso.
Métodos:
optInit : inicializa o comutador de variáveis do otimizador.
beforeForwardPass(retrievedPosIndexes , retrievedNegIndexes = None) : Switches Optimizer Variable Westes, desde a coleta de pesos completos até o tensor de peso do otimizador. retrievedPosIndexes são os índices das amostras positivas a serem recuperadas. Se as amostras negativas também forem recuperadas, um valor para retrievedNegIndexes (opcional) também pode ser passado.
afterOptimizerStep( retrievedPosIndexes , retrievedNegIndexes = None) : Switches Optimizer Variable Westes do seu otimizador para a coleta de pesos completos. retrievedPosIndexes são os índices das amostras positivas que foram recuperadas. Se as amostras negativas também foram recuperadas, um valor para retrievedNegIndexes (opcional) também poderá ser passado.
Cria um tensor cuja principal função é transferir seu conteúdo para uma variável pytorch cuda.
DataGadget( fileName, CPUPinn=False)
Argumentos:
fileName : localização do arquivo .npy a ser aberto
CPUPinn : (opcional): fixar seus dados na CPU. O padrão é falso.
Métodos:
getData(indexes) : recupera dados em um formato pronto para ser aceito por uma variável pytorch cuda. indexes são os índices do tensor para recuperar dados.
insertData(dataObject, indexes) : Insira dados de uma variável pytorch CUDA. dataObject é o Pytorch CUDA Variable Tensor Data, dos quais os dados serão recuperados e indexes do tensor a partir do qual recuperar dados.
saveCupy(saveFileName) : salve o tensor no arquivo .npy.
loadCupy(loadFileName) : Carregue o novo tensor do arquivo .npy.
getNumpyVersion : Obtenha a versão Numpy do Tensor.
Por favor, veja este caderno sobre como usar o gadget de dados
https://colab.research.google.com/drive/185z5gi62azxh-eemfrttjqxeifhobxxf
PytorchModelFactory ( model_variable , total_classes , embed_dimension , datatype = 'float32' , deviceType = 'cuda' , pinType = False )Cria comutadores para variáveis de modelo usando tensores pytorch. Variáveis de alternância da sua coleção completa de incorporação e sua coleção de lote de modelos. Cada variável precisa de seu próprio comutador.
Exemplo:
uEmbed_switcher = SpeedTorch . PytorchModelFactory ( skip_gram_modelSparse . u_embeddings , total_classes = 50000 , embed_dimension = 128 )Argumentos:
model_variable : variável específica do seu modelo para o qual você gostaria de criar um comutador.
total_classes : a quantidade total de incorporação a ser treinada.
embed_dimension : dimensão das incorporações.
datatype (Opcional): Datatype para a variável. O padrão é 'float32'.
deviceType (Opcional): Defina o dispositivo como 'CUDA' ou 'CPU'. O padrão é 'cuda'
pinType (Opcional): Se o dispositivo estiver definido como 'CPU', você poderá especificar usando a memória fixada. O padrão é 'falso'.
Métodos:
zerosInit() : inicializa a coleção completa do variável switcher com zeros:
uniformDistributionInit(low, high) : inicializa a coleção completa do comutador variável com uma distribuição uniforme de low a high
normalDistributionInit(mean, stdDev) : inicializa a coleção completa do comutador variável com uma distribuição normal com uma média de mean e um desvio padrão de stdDev
customInit(initFunction, *args) : use qualquer inicializador de pytorch para a coleção completa dos comutadores variáveis. Passe o inicializador usando initFunction e seus argumentos correspondentes usando *args .
variableTransformer(batchSize, posPerBatch, negPerBatch = None ) : configura uma entrada dummy a ser usada para a etapa direta do seu modelo. batchSize é o tamanho do seu lote, e posPerBatch é o número de exemplos positivos por lote. Se uma segunda entrada fictícia for necessária para os exemplos negativos, negPerBatch (opcional) poderá ser definido para o número de exemplos negativos e duas entradas fictícias serão retornadas em vez de uma.
beforeForwardPass(retrievedPosIndexes , retrievedNegIndexes = None) : Switches Incorpordings da coleção de incorporação completa para as incorporações do seu modelo. retrievedPosIndexes são os índices das amostras positivas a serem recuperadas. Se as amostras negativas também forem recuperadas, um valor para retrievedNegIndexes (opcional) também pode ser passado.
afterOptimizerStep(retrievedPosIndexes , retrievedNegIndexes = None) : comutadores atualizados incorporados do seu modelo para a coleção de incorporação completa. retrievedPosIndexes são os índices das amostras positivas que foram recuperadas. Se as amostras negativas também foram recuperadas, um valor para retrievedNegIndexes (opcional) também poderá ser passado.
saveTorch(saveFileName) : Salvar o tensor para arquivar usando torch.save
loadTorch(loadFileName) : Carregar tensor usando torch.load
getNumpyVersion : Obtenha a versão Numpy do Tensor.
PytorchOptimizerFactory( given_optimizer, total_classes, embed_dimension, model, variable_name, dtype='float32', deviceType = 'cuda', pinType = False)
Crie comutadores para variáveis de otimizador usando tensores pytorch. Variáveis de alternância da sua coleção completa de incorporação e sua coleção de lote de otimizador. Cada variável precisa de seu próprio comutador.
Exemplo:
uAdagrad_switcher = SpeedTorch . PytorchOptimizerFactory ( given_optimizer , total_classes , embed_dimension , model , variable_name , dtype = 'float32' )Argumentos:
given_optimizer : O otimizador é inicializado com os pesos do seu modelo. Se estiver usando para o treinamento de incorporação, lembre -se de definir o parâmetro sparse como False . Atualmente, os otimizadores suportados são SparsEadam, Adadelta, Adamax, Adam, Adamw, ASGD e RMSPROP. O RPROP também está incluído, mas precisa do primeiro passe para a frente e a etapa loss.backward() a ser concluída para inicializar a instância do OptimizerFactory. Isso se deve ao otimizador RPROP que precisando de gradientes de seus parâmetros para inicialização.
total_classes : a quantidade total de incorporação a ser treinada.
embed_dimension : dimensão das incorporações.
model : a instância do seu modelo.
variable_name : nome exato da variável definida em seu modelo.
dtype (Opcional): Tipo de dados da sua variável. O padrão é 'float32'
deviceType (Opcional): Defina o dispositivo como 'CUDA' ou 'CPU'. O padrão é 'cuda'
pinType (Opcional): Se o dispositivo estiver definido como 'CPU', você poderá especificar usando a memória fixada. O padrão é 'falso'.
Métodos:
optInit : inicializa o comutador de variáveis do otimizador.
beforeForwardPass(retrievedPosIndexes , retrievedNegIndexes = None) : Switches Optimizer Variable Westes, desde a coleta de pesos completos até o tensor de peso do otimizador. retrievedPosIndexes são os índices das amostras positivas a serem recuperadas. Se as amostras negativas também forem recuperadas, um valor para retrievedNegIndexes (opcional) também pode ser passado.
afterOptimizerStep( retrievedPosIndexes , retrievedNegIndexes = None) : Switches Optimizer Variable Westes do seu otimizador para a coleta de pesos completos. retrievedPosIndexes são os índices das amostras positivas que foram recuperadas. Se as amostras negativas também foram recuperadas, um valor para retrievedNegIndexes (opcional) também poderá ser passado.
Se você usar o Speedtorch em sua pesquisa ou desejar citar, cite com:
@misc {
title = {speedtorch},
autor = {Santosh Gupta},
HowPublished = { url {github.com/santosh-gupta/speedtorch}},
ano = {2019}
}
