SpeedTorch
1.0.0
Tensor de CPU fijado más rápido <-> Transferencia de variables de Pytorch GPU y transferencia de variable GPU Pytorch, en ciertos casos.
Since for some systems, using the pinned Pytorch CPU tensors is faster than using Cupy tensors (see 'How It Works' section for more detail), I created general Pytorch tensor classes PytorchModelFactory and PytorchOptimizerFactory which can specifiy either setting the tensors to cuda or cpu , and if using cpu , if its memory should be pinned. Las clases originales GPUPytorchModelFactory y GPUPytorchOptimizerFactory todavía están en la biblioteca, por lo que ningún código existente que usa SpeedTorch debería verse afectado. La documentación se ha actualizado para incluir estas nuevas clases.
Esta biblioteca revocan los tensores Cupy fijados a la CPU, que puede lograr 3.1x CPU más rápida -> transferencia de GPU que la lata regular de la CPU de Pytorch, y 410x más rápida de la GPU -> Transferencia de CPU. La velocidad depende de la cantidad de datos y el número de núcleos de CPU en su sistema (consulte la sección Cómo funciona para obtener más detalles)
La biblioteca incluye funciones para capacitación de incrustaciones; Puede alojar incrustaciones en la RAM de la CPU mientras están inactivos, ahorrando RAM GPU.
Inicialmente creé esta biblioteca para ayudar a entrenar grandes cantidades de incrustaciones, que la GPU puede tener problemas para mantener en RAM. Para hacer esto, descubrí que al alojar algunos de los incrustaciones en la CPU puede ayudar a lograr esto. Los sistemas de incrustación utilizan capacitación SPASE; Solo la fracción de los cochecitos totales participan en los pasos de reenvío/actualización, el resto está inactivo. Entonces pensé, ¿por qué no mantener los parámetros inactivos fuera de la GPU durante el paso de entrenamiento? Para esto, necesitaba una transferencia rápida de CPU -> GPU.
Para la historia de fondo completa, consulte la página Devpost
https://devpost.com/software/speedtorch-6w5unb
Con la CPU rápida-> GPU, se pueden desarrollar muchos métodos divertidos para las funcionalidades que anteriormente la gente pensaba que podría no haber sido posible.
? ️ Incorporar SpeedTorch en sus tuberías de datos para la transferencia rápida de datos a/desde CPU <-> GPU
? ️ Aumentar los parámetros de capacitación a través del almacenamiento de CPU. Mientras tenga suficiente RAM CPU, puede alojar cualquier cantidad de incrustaciones sin tener que preocuparse por la RAM GPU.
? ️ Use Adadelta, Adamax, RMSProp, Rprop, ASGD, Adamw y Adam Optimizers para el entrenamiento de incrustaciones dispersas. Anteriormente, solo Spaseadam, Adagrad y SGD eran adecuados ya que solo estos apoyan directamente gradientes escasos.
(Editar 9-20-19, uno de los desarrolladores de Pytorch señaló algunos errores menores en el código de marcado de banco original, los valores y el código se han actualizado)
Aquí hay un cuaderno que compara la transferencia a través de SpeedTorch vs Pytorch Tensors, con Tensores CPU y CUDA fijados. Todas las pruebas se realizaron con una instancia de Colab con una GPU Tesla K80 y una CPU de 2 núcleo.
ACTUALIZACIÓN 10-17-19: Google Colab ahora es estándar con 4 CPU de núcleo, por lo que este cuaderno dará resultados diferentes a los que se informa a continuación, ya que los núcleos de indexación de Pytorch se vuelven más eficientes a medida que aumenta el número de núcleos de CPU.
https://colab.research.google.com/drive/1pxhbmbzqtiq_nlfguianpf_mfpiqskks
Este cuaderno multiplica la transferencia de datos de 131,072 incrustaciones Float32 de Dimensión 128, hacia y desde las variables Cupy/Pytorch y las variables de Pytorch, con n = 100. La CPU de Google Colab tiene 4 núcleos, lo que tiene un impacto en la velocidad de transferencia. Las CPU con un mayor número de núcleos verán menos ventajas para usar SpeedTorch.
La siguiente tabla es un resumen de los resultados. La transferencia de datos de los tensores de Pytorch CUDA a la variable de incrustación CUDA Pytorch es más rápida que el equivalente de velocidad de velocidad, pero para todos los demás tipos de transferencia, SpeedTorch es más rápido. Y por la suma de ambos pasos que se transfieren a/desde la incrustación de Cuda Pytorch, SpeedTorch es más rápido que el equivalente de Pytorch tanto para la GPU regular como para los tensores fijados con CPU.
He notado que diferentes instancias de Colab dan como resultado diferentes resultados de velocidad, así que tenga esto en cuenta al revisar estos resultados. Una ejecución personal del cuaderno Colab puede dar lugar a diferentes valores, aunque el orden de magnetude de los resultados es generalmente el mismo.
Los tiempos de transferencia en las siguientes tablas se dan en segundos. Esta evaluación comparativa se realizó con una instancia de Colab cuya CPU tiene 2 núcleos. Colab tiene una versión profesional de instancias pagas que son 4 CPU principales, por lo que la siguiente evaluación comparativa no se reflejaría para esas instancias.
| Tipo tensor | A cuda pytorch variable | Comparación |
|---|---|---|
| SpeedTorch (CUDA) | 0.0087 | 6.2x más lento que el equivalente de Pytorch |
| SpeedTorch (pinchedcpu) | 0.0154 | 3.1x más rápido que el equivalente de Pytorch |
| Pytorch (CUDA) | 0.0014 | 6.2x más rápido que SpeedTorch equivalente |
| Pytorch (pinchedcpu) | 0.0478 | 3.1x más lento que SpeedTorch equivalente |
| Tipo tensor | De la variable Cuda Pytorch | Comparación |
|---|---|---|
| SpeedTorch (CUDA) | 0.0035 | 9.7x más rápido que el equivalente de Pytorch |
| SpeedTorch (pinchedcpu) | 0.0065 | 410x más rápido que el equivalente de Pytorch |
| Pytorch (CUDA) | 0.0341 | 9.7 veces más lento que SpeedTorch equivalente |
| Pytorch (pinchedcpu) | 2.6641 | 410x más lento que SpeedTorch equivalente |
| Tipo tensor | Suma de la variable CUDA Pytorch | Comparación |
|---|---|---|
| SpeedTorch (CUDA) | 0.0122 | 2.9x más rápido que el equivalente de Pytorch |
| SpeedTorch (pinchedcpu) | 0.0219 | 124x más rápido que el equivalente de Pytorch |
| Pytorch (CUDA) | 0.0355 | 2.9 veces más lento que SpeedTorch equivalente |
| Pytorch (pinchedcpu) | 2.7119 | 124x más lento que SpeedTorch equivalente |
Se calcularon puntos de referencia similares para transferir a/desde optimizadores de Pytorch CUDA. Los resultados son básicamente los mismos, aquí está el cuaderno utilizado para la evaluación comparativa de los optimizadores
https://colab.research.google.com/drive/1y2nehd8xj-ixfjkj2qwua_ujqjbbhhj55
Aunque los tensores de SpeedTorch son generalmente más rápidos que los de Pytorch, el inconveniente es que los tensores de SpeedTorch usan más memoria. Sin embargo, debido a que la transferencia de datos puede ocurrir más rápidamente, puede usar SpeedTorch para aumentar el número de incrustaciones capacitadas en su arquitectura manteniendo parámetros en la GPU y la CPU.
Esta tabla es un resumen de la evaluación comparativa realizada en Google Colab. Según mi experiencia, parece haber alguna variación en los valores de memoria informados en Colab, +-0.30 GB, así que tenga esto en cuenta al revisar estos números. Los valores son para mantener un tensor Float32 de 10,000,000x128.
| Tipo tensor | CPU (GB) | GPU (GB) |
|---|---|---|
| Cupy pinchedcpu | 9.93 | 0.06 |
| Pytorch pinchncpu | 6.59 | 0.32 |
| Cupy Cuda | 0.39 | 9.61 |
| Pytorch Cuda | 1.82 | 5.09 |
Aunque el tiempo de Pytorch hacia/desde para Pytorch GPU Tensor <-> Pytorch Cuda Variable no es tan rápido como el equivalente de Cupy, la velocidad aún es viable. Entonces, si la memoria sigue siendo una preocupación, lo mejor del enfoque de ambos mundos sería la CPU Cupy CPU de SpeedTorch fijada con tensores para almacenar parámetros en la CPU y los tensores de GPU de Pytorch de SpeedTorch para almacenar parámetros en la GPU.
Este es el cuaderno que utilicé para medir cuánta memoria toma cada tipo de variable. https://colab.research.google.com/drive/1zky7pyupaidrnx2hdtbujwo8juy0xkue Si use esto en Colab, deberá reiniciar el entorno después de cada creación de tensor, para obtener una medida para el próximo tensor.
Para la transferencia de CPU <-> GPU, depende de la cantidad de datos que se transfieren y del número de núcleos que tiene. Generalmente para 1-2 CPU SpeedTorch de los núcleos de CPU será mucho más rápido. Pero a medida que aumenta el número de núcleos de CPU, las operaciones de indexación de CPU <-> GPU de Pytorch se vuelven más eficientes. Para obtener más detalles sobre esto, consulte la siguiente sección 'Cómo funciona'. Para una manera fácil de ver si obtiene una ventaja de velocidad en su sistema, ejecute el código de evaluación comparativa en su sistema, pero cambie la cantidad de datos para reflejar la cantidad con la que trabajará en su aplicación.
Para la transferencia de GPU <-> GPU, si se utiliza anotaciones de indexación ordinaria en Vanilla Pytorch, todos los sistemas obtendrán un aumento de velocidad porque SpeedTorch omite un error en las operaciones de indexación de Pytorch. Pero este error se puede evitar si usa la versión nocturna, o simplemente usa diferentes nociones de indexación, consulte la sección 'Cómo funciona' para obtener más detalles.
ACTUALIZACIÓN 9-20-19: Inicialmente no tenía idea de por qué esto es más rápido que usar tensores de Pytorch; Me topé con la ventaja de velocidad por accidente. Pero uno de los desarrolladores de Pytorch en el Foro de Pytorch lo señaló.
En cuanto a la mejor transferencia de CPU <-> GPU, se debe a que SpeedTorch evita una operación de indexación de CPU en disfrazamiento de tensores de CPU como tensores de GPU. La operación del índice de CPU puede ser lenta si trabaja con muy pocos núcleos de CPU, como 2 en Google Colab, pero puede ser más rápido si tiene muchos núcleos. Depende de la cantidad de datos que esté transferiendo y cuántos núcleos tenga.
En cuanto a la mejor transferencia de GPU <-> GPU, se debe a que SpeedTorch evita un error en la operación de indexación. Este error también se puede evitar utilizando las compilaciones nocturnas, o usando index_select / index_copy_ en lugar de a[idx] en 1.1 / 1.2.
Para obtener más detalles de esto, consulte esta publicación de Pytorch
https://discuss.pytorch.org/t/Introducing-SpeedTorch-4x-speed-cpu-gpu-transfer-110x-gpu-cpu-transfer/56147/2
Cuando un ingeniero de Pytorch ofrece un análisis detallado sobre cómo los kernales de indexación de Cupy están dando como resultado aceleraciones en ciertos casos. No es la transferencia en sí la que se está volviendo más rápida, sino los núcleos de indexación que se están utilizando.
En cuanto a cómo funciona la gestión de la memoria en Cupy, dirijo a estas dos preguntas de StackoverFlow que hice, donde el brillante usuario Robert Crovella no solo dio explicaciones detalladas, sino que también descubrí cómo asignar la memoria fijada a las matrices de Cupy mediante el desarrollo de su propio asignador de memoria para Cupy. Esta es básicamente la tecnología central detrás de SpeedTorch.
https://stackoverflow.com/questions/57750125/cupy-otofmoryerror-when-trying-to-cupy-load-larger-dimension-npy-in-me
https://stackoverflow.com/questions/57752516/how-to-use-cuda-pinned-zero-copy-memory-for-a-memory-mapped-file
SpeedTorch es PIP instalable. Debe tener Cupy instalado e importado antes de importar SpeedTorch.
!pip install SpeedTorch
import cupy
import SpeedTorch
Este cuaderno de Colab muestra cómo cargar datos en SpeedTorch utilizando su dispositivo de datos y cómo transferir estos datos a/desde una variable Pytorch CUDA.
https://colab.research.google.com/drive/185z5gi62azxh-eemfrttjqxeifhobxxf
Consulte el cuaderno de evaluación comparativa de velocidad para ver la ventaja de velocidad de usar SpeedTorch.
Para las personas que intentan primero descubrir cómo usar SpeedTorch, recomiendo seguir este ejemplo, ya que Word2Vec es uno de los algoritmos más conocidos en el aprendizaje automático.
https://colab.research.google.com/drive/1apjr3onbgqwm3fbcbkmvwagxidxldxot
El cuaderno muestra cómo entrenar a Word2vec de la manera regular, luego muestra cómo usar SpeedTorch para entrenar en los mismos datos, utilizando uno de los optimizadores que normalmente no es compatible para una capacitación escasa. Esto es posible porque, dado que todas las incrustaciones contenidas en la variable de incrustación tienen una actualización durante cada paso, puede establecer sparse=False durante la inicialización.
tl; dr:
Entrenamiento normal : las variables de incrustación de Pytorch contienen todas las integridades. El optimizador de Pytorch contiene todos los pesos de parámetros correspondientes para cada incrustación.
Traing SpeedTorch : las variables de incrustación de Pytorch solo contienen un lote de incrustaciones. Pytorch Optimizer solo contiene todos los pesos de parámetros correspondientes para ese lote. Los tensores Sparsetorch contienen el resto e intercambia los incrustaciones/pesos con la variable Pytorch en cada paso.
En los algoritmos de entrenamiento disperso como Word2Vec, Glove o Filtrado de colaboración neuronal, solo una fracción de los parámetros totales (incrustaciones) se entrenan durante cada paso. Si su GPU no puede manejar todos sus incrustaciones en el tamaño de incrustación deseado, una opción sería alojar algunos de sus parámetros en las matrices CPU Cupy cubiertas y transferir esos parámetros a los tensores de su modelo según sea necesario. Hacer esto primario en Pytorch sería muy lento, especialmente porque la transferencia de parámetros entre una variable Pytorch montada en Cuda y un tensor Pytorch CPU fijado puede tomar 2.5-3 segundos (en Google Colab). ¡Afortunadamente, este paso solo toma 0.02-0.03 segundos con SpeedTorch!
Usos de caso:
--2,829,853 Libros incrustados--
SpeedTorch se utilizó en el entrenamiento de 2.829.853 libros para un recomendador de libros raro.
https://github.com/santosh-gupta/lit2vec2
https://devpost.com/software/lit2vec2
Cada libro tenía una incrustación de tamaño de 400, pero un tamaño de incrustación de 496 podría haberse utilizado, el tamaño de incrustación de 400 se debió a los límites de espacio en mi Drive Google para almacenar los incrustaciones capacitadas :(. Pero los límites de la RAM de la GPU ya no son un problema :) Aquí es un enlace directo a un cuaderno de capacitación de demostración, que entrena con un tamaño 496 incrustado de velocidad.
Nota: Necesita la versión del cuaderno Colab que tiene 25 GB de RAM, en lugar de los 12 GB habituales. Para obtener este tipo de instancia, debe bloquear su instancia actual debido a que abrumaba la RAM, y luego una nota en la esquina inferior izquierda preguntando si desea actualizar. Puede hacer esto haciendo un bucle que sigue duplicando el tamaño de una matriz flotante numpy.
https://colab.research.google.com/drive/1aqht-hetihxmet1wjqrorc3q9tfjqj19
Aquí hay un enlace directamente con el mismo modelo y datos, pero no usa SpeedTorch
https://colab.research.google.com/drive/1idv1jbouzvpcfdsy40wirrphedoanti_
Utilizando el método de entrenamiento ortodoxo, el tamaño de incrustación más grande que Colab puede manejar es 255-260, más alto que eso y se producirá un error CUDA
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 INCREGOS DEL PROBLEZA DE INVESTIGACIÓN-
https://github.com/santosh-gupta/research2vec2
SpeedTorch puede permitirme entrenar 14,886,544 incrustaciones de documentos de investigación en un tamaño de incrustación de 188, al permitir que almacene mis incrustaciones objetivo en la CPU, mientras mantiene mis incrustaciones de contexto en la GPU (se usó el optimizador SGD, por lo que no hay pesos de optimizador).
Aquí hay un enlace directo al cuaderno.
https://colab.research.google.com/drive/1sakzsahoy6o_u1df_z15_qkr5ylni_gr
Nota: Necesita la versión del cuaderno Colab que tiene 25 GB de RAM, en lugar de los 12 GB habituales. Para obtener este tipo de instancia, debe bloquear su instancia actual debido a que abrumaba la RAM, y luego una nota en la esquina inferior izquierda preguntando si desea actualizar. Puede hacer esto haciendo un bucle que sigue duplicando el tamaño de una matriz flotante numpy.
Sin SpeedTorch, solo se puede usar un tamaño de incrustación de 94-96 en Google Colab Tesla K80 GPU antes de un RuntimeError: CUDA out of memory . Aquí hay una versión del entrenamiento sin usar SpeedTorch.
https://colab.research.google.com/drive/1jh7rugeaajhdwdgnfwg3twm1zjytqu0kr
Siempre que use los tensores de GPU de Cupy, inicialice los tensores de CPU fijados. Esto se debe a que la inicialización de los tensores de GPU Cupy parece utilizar una cantidad sólida de RAM de CPU. Entonces, si está limitado en la RAM de la CPU, y ya tiene sus tensores de CPU fijados en la memoria, entonces inicializar los tensores de GPU Cupy puede causar un bloqueo.
Si puede colocar todos sus parámetros en la memoria de su GPU, use Pytorch puro ya que esta es la opción más rápida para el entrenamiento. Pero si no puede ajustar todos sus parámetros en la memoria, divida sus parámetros (tenga en cuenta que sus optimizadores también tienen pesos) entre los tensores Cupy Cuda de SpeedTorch y los tensores CPU Cupy Cupy de SpeedTorch; Esta es la segunda opción más rápida. Pero, si aún no puede colocar todos sus parámetros en la memoria de esa manera, entonces divida sus parámetros entre los tensores CPU de Cupy de SpeedTorch y los tensores Pytorch CUDA de SpeedTorch; Esto es más lento que ambas opciones, pero usa menos memoria GPU. Para la tercera opción, aquí hay dos cuadernos que muestran un ejemplo de este https://colab.research.google.com/drive/1aqht-hetihxmet1wjqrorc3q9tfjqj19, https://colab.research.google.com/drive/1sakzsahoy6o_u1df_z15_qkr5ylni_gr
Después del entrenamiento, guardar cualquier variable CUDA causará un aumento en el uso de la memoria y puede causar un accidente, especialmente con Cupy. Si estás en los límites de tu RAM. En este caso, use el método getNumpyVersion para obtener una versión numpy de su tensor, y luego use Use Numpy.save o HDPy/Pytables para guardar su matriz Numpy. Numpy Save es más liviano.
Abra un problema o chatee el directorio conmigo en Gitter aquí https://gitter.im/speedtorch
Estoy buscando incoporar más funcionalidades alrededor de la transferencia rápida de CPU -> GPU. Si tiene una idea, publique un problema de GitHub.
Además, la GPU Cupy/Tensores de GPU de CPU y Pytorch, SpeedTorch también tiene tensores de CPU fijados con Pytorch y tensores Cupy MemMAP GPU/CPU fijados. No he encontrado un uso sólido para este tipo de tensores, pero están completamente codificados y disponibles para su uso.
https://github.com/santosh-gupta/speedtorch/tree/master/speedtorch
Un área que me gustaría ver es si hay una manera de tener una reducción de la memoria de RAM mediante el uso de Memmaps Cupy. Hasta ahora usan tanta memoria como las versiones en vivo.
ModelFactory ( model_variable , total_classes , embed_dimension , datatype = 'float32' , CPUPinn = False )Crea conmutadores para variables de modelo usando Cupy. Cambia las variables de su colección completa de incrustación y su colección de lotes modelo. Cada variable necesita su propio conmutador.
Ejemplo:
uEmbed_switcher = SpeedTorch . ModelFactory ( skip_gram_modelSparse . u_embeddings , total_classes = 50000 , embed_dimension = 128 )Argumentos:
model_variable : variable específica de su modelo para la que desea crear un conmutador.
total_classes : la cantidad total de incrustaciones que se capacitarán.
embed_dimension : dimensión de los incrustaciones.
datatype (opcional): tipo de datos para la variable. El valor predeterminado es 'Float32'.
CPUPinn (opcional): fije su colección completa de incrustación a CPU. Memoria de GPU de repuesto, pero la transferencia de datos será más lenta. El valor predeterminado es falso.
Métodos:
zerosInit() : inicializa la colección completa del conmutador variable con ceros:
uniformDistributionInit(low, high) : inicializa la colección completa del conmutador variable con una distribución uniforme de low a high
normalDistributionInit(mean, stdDev) : inicializa la colección completa del conmutador variable con una distribución normal con una media de mean y una desviación estándar de stdDev
variableTransformer( batchSize, posPerBatch, negPerBatch = None ) : configura una entrada ficticia para ser utilizada para el paso hacia adelante de su modelo. batchSize es el tamaño de su lote, y posPerBatch es el número de ejemplos positivos por lote. Si se necesita una segunda entrada ficticia para los ejemplos negativos, negPerBatch (opcional) se puede establecer en el número de ejemplos negativos, y se devolverán dos entradas ficticias en lugar de una.
beforeForwardPass(retrievedPosIndexes , retrievedNegIndexes = None) : cambia de incrustación de la colección completa de incrustaciones a sus incrustaciones de modelo. retrievedPosIndexes son los índices de las muestras positivas a recuperar. Si también se pueden recuperar muestras negativas, también se puede pasar un valor para retrievedNegIndexes (opcional).
afterOptimizerStep( retrievedPosIndexes , retrievedNegIndexes = None) : cambia de incrustaciones actualizadas de su modelo a la colección completa de incrustaciones. retrievedPosIndexes son los índices de las muestras positivas que se recuperaron. Si también se recuperaron muestras negativas, también se puede aprobar un valor para retrievedNegIndexes (opcional).
saveCupy(saveFileName) : guarde el tensor en el archivo .npy.
loadCupy(loadFileName) : Cargue el tensor desde el archivo .npy.
getNumpyVersion : Obtener la versión Numpy de Tensor.
OptimizerFactory( given_optimizer, total_classes, embed_dimension, model, variable_name, dtype='float32' , CPUPinn = False)
Crea conmutadores para variables optimizador usando Cupy. Cambia las variables de su colección completa de incrustación y su colección de lotes Optimizer. Cada variable necesita su propio conmutador.
Ejemplo:
uAdagrad_switcher = SpeedTorch . OptimizerFactory ( given_optimizer , total_classes , embed_dimension , model , variable_name , dtype = 'float32' , CPUPinn = False )Argumentos:
given_optimizer : el optimizador se inicializó con los pesos de su modelo. Si usa para el entrenamiento de incrustaciones, recuerde establecer el parámetro sparse en False . Actualmente, los optimizadores compatibles son Sparseadam, Adadelta, Adamax, Adam, Adamw, ASGD y RMSProp. RPROP también se inserta, pero necesita el primer paso hacia adelante y loss.backward() Esto se debe a que el optimizador RPROP necesita gradientes de sus parámetros para la inicialización.
total_classes : la cantidad total de incrustaciones que se capacitarán.
embed_dimension : dimensión de los incrustaciones.
model : la instancia de su modelo.
variable_name : nombre exacto de la variable definida en su modelo.
dtype (opcional): tipo de datos de su variable. El valor predeterminado es 'float32'
CPUPinn (Opcional): fije su colección de peso variable de optimizador completo a CPU. Memoria de GPU de repuesto, pero la transferencia de datos será más lenta. El valor predeterminado es falso.
Métodos:
optInit : inicializa el conmutador de variable optimizador.
beforeForwardPass(retrievedPosIndexes , retrievedNegIndexes = None) : cambia los pesos variables optimizadores desde la recolección de pesos completos hasta el tensor de peso optimizador. retrievedPosIndexes son los índices de las muestras positivas a recuperar. Si también se pueden recuperar muestras negativas, también se puede pasar un valor para retrievedNegIndexes (opcional).
afterOptimizerStep( retrievedPosIndexes , retrievedNegIndexes = None) : cambia los pesos variables del optimizador de su optimizador a la recolección de pesas completas. retrievedPosIndexes son los índices de las muestras positivas que se recuperaron. Si también se recuperaron muestras negativas, también se puede aprobar un valor para retrievedNegIndexes (opcional).
Crea un tensor cuya función principal es transferir su contenido a una variable Pytorch CUDA.
DataGadget( fileName, CPUPinn=False)
Argumentos:
fileName : ubicación de datos .npy archivo a abrir
CPUPinn : (opcional): fije sus datos a CPU. El valor predeterminado es falso.
Métodos:
getData(indexes) : recupera datos en un formato que está listo para ser aceptado por una variable Pytorch CUDA. indexes son los índices del tensor desde los cuales recuperar datos.
insertData(dataObject, indexes) : inserte datos de una variable Pytorch CUDA. dataObject es los datos del tensor variable Pytorch CUDA de los que los datos son se recuperarán, e indexes del tensor desde el cual recuperar datos.
saveCupy(saveFileName) : guarde el tensor en el archivo .npy.
loadCupy(loadFileName) : Cargue el tensor nuevo desde el archivo .npy.
getNumpyVersion : Obtener la versión Numpy de Tensor.
Consulte este cuaderno sobre cómo usar el dispositivo de datos
https://colab.research.google.com/drive/185z5gi62azxh-eemfrttjqxeifhobxxf
PytorchModelFactory ( model_variable , total_classes , embed_dimension , datatype = 'float32' , deviceType = 'cuda' , pinType = False )Crea conmutadores para variables de modelo usando tensores de pytorch. Cambia las variables de su colección completa de incrustación y su colección de lotes modelo. Cada variable necesita su propio conmutador.
Ejemplo:
uEmbed_switcher = SpeedTorch . PytorchModelFactory ( skip_gram_modelSparse . u_embeddings , total_classes = 50000 , embed_dimension = 128 )Argumentos:
model_variable : variable específica de su modelo para la que desea crear un conmutador.
total_classes : la cantidad total de incrustaciones que se capacitarán.
embed_dimension : dimensión de los incrustaciones.
datatype (opcional): tipo de datos para la variable. El valor predeterminado es 'Float32'.
deviceType (opcional): Establezca el dispositivo en 'CUDA' o 'CPU'. El valor predeterminado es 'CUDA'
pinType (opcional): si el dispositivo está configurado en 'CPU', puede especificar usando la memoria fijada. El valor predeterminado es 'falso'.
Métodos:
zerosInit() : inicializa la colección completa del conmutador variable con ceros:
uniformDistributionInit(low, high) : inicializa la colección completa del conmutador variable con una distribución uniforme de low a high
normalDistributionInit(mean, stdDev) : inicializa la colección completa del conmutador variable con una distribución normal con una media de mean y una desviación estándar de stdDev
customInit(initFunction, *args) : use cualquier inicializador de pytorch para la colección completa de conmutadores variables. Pase el inicializador utilizando initFunction y sus argumentos correspondientes usando *args .
variableTransformer(batchSize, posPerBatch, negPerBatch = None ) : configura una entrada ficticia para ser utilizada para el paso hacia adelante de su modelo. batchSize es el tamaño de su lote, y posPerBatch es el número de ejemplos positivos por lote. Si se necesita una segunda entrada ficticia para los ejemplos negativos, negPerBatch (opcional) se puede establecer en el número de ejemplos negativos, y se devolverán dos entradas ficticias en lugar de una.
beforeForwardPass(retrievedPosIndexes , retrievedNegIndexes = None) : cambia de incrustación de la colección completa de incrustaciones a sus incrustaciones de modelo. retrievedPosIndexes son los índices de las muestras positivas a recuperar. Si también se pueden recuperar muestras negativas, también se puede pasar un valor para retrievedNegIndexes (opcional).
afterOptimizerStep(retrievedPosIndexes , retrievedNegIndexes = None) : cambia de incrustaciones actualizadas de su modelo a la colección completa de incrustaciones. retrievedPosIndexes son los índices de las muestras positivas que se recuperaron. Si también se recuperaron muestras negativas, también se puede aprobar un valor para retrievedNegIndexes (opcional).
saveTorch(saveFileName) : guarde el tensor para archivar usando Torch.save
loadTorch(loadFileName) : Tensor de carga con antorcha.
getNumpyVersion : Obtener la versión Numpy de Tensor.
PytorchOptimizerFactory( given_optimizer, total_classes, embed_dimension, model, variable_name, dtype='float32', deviceType = 'cuda', pinType = False)
Crea conmutadores para variables optimizador utilizando tensores de pytorch. Cambia las variables de su colección completa de incrustación y su colección de lotes Optimizer. Cada variable necesita su propio conmutador.
Ejemplo:
uAdagrad_switcher = SpeedTorch . PytorchOptimizerFactory ( given_optimizer , total_classes , embed_dimension , model , variable_name , dtype = 'float32' )Argumentos:
given_optimizer : el optimizador se inicializó con los pesos de su modelo. Si usa para el entrenamiento de incrustaciones, recuerde establecer el parámetro sparse en False . Actualmente, los optimizadores compatibles son Sparseadam, Adadelta, Adamax, Adam, Adamw, ASGD y RMSProp. RPROP también se inserta, pero necesita el primer paso hacia adelante y loss.backward() Esto se debe a que el optimizador RPROP necesita gradientes de sus parámetros para la inicialización.
total_classes : la cantidad total de incrustaciones que se capacitarán.
embed_dimension : dimensión de los incrustaciones.
model : la instancia de su modelo.
variable_name : nombre exacto de la variable definida en su modelo.
dtype (opcional): tipo de datos de su variable. El valor predeterminado es 'float32'
deviceType (opcional): Establezca el dispositivo en 'CUDA' o 'CPU'. El valor predeterminado es 'CUDA'
pinType (opcional): si el dispositivo está configurado en 'CPU', puede especificar usando la memoria fijada. El valor predeterminado es 'falso'.
Métodos:
optInit : inicializa el conmutador de variable optimizador.
beforeForwardPass(retrievedPosIndexes , retrievedNegIndexes = None) : cambia los pesos variables optimizadores desde la recolección de pesos completos hasta el tensor de peso optimizador. retrievedPosIndexes son los índices de las muestras positivas a recuperar. Si también se pueden recuperar muestras negativas, también se puede pasar un valor para retrievedNegIndexes (opcional).
afterOptimizerStep( retrievedPosIndexes , retrievedNegIndexes = None) : cambia los pesos variables del optimizador de su optimizador a la recolección de pesas completas. retrievedPosIndexes son los índices de las muestras positivas que se recuperaron. Si también se recuperaron muestras negativas, también se puede aprobar un valor para retrievedNegIndexes (opcional).
Si usa SpeedTorch en su investigación o desea citar, cite con:
@misc {
title = {speedTorch},
autor = {Santosh Gupta},
HowPublished = { url {github.com/santosh-gupta/speedtorch}},
año = {2019}
}
