SpeedTorch
1.0.0
Tenseur CPU à épingle plus rapide <-> GPU Pytorch Variabe Transfert et GPU Tensor <-> GPU Pytorch Variable Transfert, dans certains cas.
Étant PytorchModelFactory que pour certains systèmes, l'utilisation des tenseurs de processeurs Pytorch épinglés est plus rapide que d'utiliser des tenseurs de cupy PytorchOptimizerFactory voir la section `` Comment ça marche '' pour plus de détails), j'ai créé des classes de tenseurs de pytorch générales qui peuvent spécifier la mise en place des Tenseurs pour cuda ou cpu , et si l'utilisation cpu , si elle doit être consacrée. Les classes d'origine GPUPytorchModelFactory et GPUPytorchOptimizerFactory sont toujours dans la bibliothèque, donc aucun code existant utilisant SpeedTorch ne doit être affecté. La documentation a été mise à jour pour inclure ces nouvelles classes.
Cette bibliothèque révèle autour des tenseurs de cupy épinglés au processeur, ce qui peut atteindre 3,1x CPU plus rapide -> transfert de GPU que les tenseurs de processeurs épinglés à Pytorch ordinaires peuvent, et 410x GPU plus rapide -> transfert de processeur. La vitesse dépend de la quantité de données et du nombre de cœurs de processeur sur votre système (voir comment il fonctionne pour plus de détails)
La bibliothèque comprend des fonctions de formation intégrée; Il peut héberger des intégres sur RAM CPU alors qu'ils sont inactifs, épargnants GPU RAM.
J'ai initialement créé cette bibliothèque pour aider à former un grand nombre d'incorporation, que le GPU peut avoir du mal à tenir dans RAM. Pour ce faire, j'ai constaté qu'en hébergeant certaines intégres sur le processeur peut aider à y parvenir. Les systèmes d'intégration utilisent la formation Sprase; Seule la fraction du total des lanceurs participez aux étapes de la mise en avant / de mise à jour, les autres sont inactifs. Alors je me suis dit, pourquoi ne pas garder les paramètres inactifs hors du GPU pendant l'étape d'entraînement? Pour cela, j'avais besoin de transfert de processeur rapide -> GPU.
Pour la trame de fond complète, veuillez consulter la page DevPost
https://devpost.com/software/speedtorch-6w5unb
Avec le processeur rapide, le GPU, de nombreuses méthodes amusantes peuvent être développées pour les fonctionnalités qui, auparavant, les gens pensaient que les gens n'auraient peut-être pas été possibles.
? ️ Incorporer SpeedTorch dans vos pipelines de données pour un transfert de données rapide vers / depuis CPU <-> GPU
? ️ Augmenter les paramètres de formation via le stockage du processeur. Tant que vous avez suffisamment de RAM CPU, vous pouvez héberger n'importe quel nombre d'incorporation sans avoir à vous soucier de la RAM GPU.
? ️ Utilisez Adadelta, Amaxax, RMSProp, RPROP, ASGD, ADAMW et ADAM Optimizers pour la formation de l'intégration clairsemée. Auparavant, seuls Spraseadam, Adagrad et SGD étaient adaptés car seuls ceux-ci prennent directement les gradients clairsemés.
(Edit 9-20-19, l'un des développeurs de Pytorch a souligné certains bogues mineurs dans le code de marquage d'origine, les valeurs et le code ont été mis à jour)
Voici un ordinateur portable comparant le transfert via les tenseurs Pytorch SpeedTorch vs, avec des tenseurs CPU et CUDA épinglés. Tous les tests ont été effectués avec une instance Colab avec un GPU Tesla K80 et 2 CPU de base.
Mise à jour 10-17-19: Google Colab est désormais standard avec 4 CPU de base, donc ce cahier donnera des résultats différents de ce qui est rapporté ci-dessous, car les kernaux d'indexation de Pytorch deviennent plus efficaces à mesure que le nombre de noyaux de processeur augmente.
https://colab.research.google.com/drive/1pxhbmbzqtiq_nlfuianpf_mfpiqskks
Ce carnet fois le transfert de données de 131 072 incorporation de float32 de dimension 128, vers et depuis les tenseurs cupy / pytorch et les variables pytorch, avec n = 100. Le processeur de Google Colab a 4 cœurs, ce qui a un impact sur la vitesse de transfert. Les processeurs avec un nombre plus élevé de noyaux verront moins un adversaire à utiliser SpeedTorch.
Le tableau ci-dessous est un résumé des résultats. Le transfert de données des tenseurs CUDA Pytorch vers la variable d'intégration de Cuda Pytorch est plus rapide que l'équivalent SpeedTorch, mais pour tous les autres types de transfert, SpeedTorch est plus rapide. Et pour la somme des deux étapes transférées vers / depuis l'intégration de Cuda Pytorch, SpeedTorch est plus rapide que l'équivalent pytorch pour les tenseurs GPU et CPU ordinaires.
J'ai remarqué que différents cas de Colab aboutissent à différents résultats de vitesse, alors gardez cela à l'esprit lors de l'examen de ces résultats. Une série personnelle du cahier Colab peut entraîner différentes valeurs, bien que l'ordre de magnétude des résultats soit généralement le même.
Les temps de transfert dans les tableaux suivants sont donnés en quelques secondes. Cette analyse comparative a été préformée avec une instance de colab dont le processeur a 2 cœurs. Colab a une version professionnelle des instances payantes qui sont 4 processeurs de base, donc le benchmarking suivant ne refléterait pas pour ces instances.
| Type de tenseur | À Cuda Pytorch Variable | Comparaison |
|---|---|---|
| SpeedTorch (Cuda) | 0,0087 | 6.2x plus lent que Pytorch équivalent |
| SpeedTorch (PinnedCPU) | 0,0154 | 3.1x plus vite que l'équivalent pytorch |
| Pytorch (cuda) | 0,0014 | 6.2x plus rapide que l'équivalent SpeedTorch |
| Pytorch (épinglé) | 0,0478 | 3.1x plus lent que SpeedTorch équivalent |
| Type de tenseur | De la variable Cuda Pytorch | Comparaison |
|---|---|---|
| SpeedTorch (Cuda) | 0,0035 | 9,7x plus vite que l'équivalent pytorch |
| SpeedTorch (PinnedCPU) | 0,0065 | 410x plus vite que l'équivalent pytorch |
| Pytorch (cuda) | 0,0341 | 9,7x plus lent que SpeedTorch équivalent |
| Pytorch (épinglé) | 2.6641 | 410x plus lent que SpeedTorch équivalent |
| Type de tenseur | Somme de / de Cuda Pytorch Variable | Comparaison |
|---|---|---|
| SpeedTorch (Cuda) | 0,0122 | 2,9x plus vite que l'équivalent pytorch |
| SpeedTorch (PinnedCPU) | 0,0219 | 124x plus vite que l'équivalent pytorch |
| Pytorch (cuda) | 0,0355 | 2,9x plus lent que SpeedTorch équivalent |
| Pytorch (épinglé) | 2.7119 | 124x plus lent que SpeedTorch équivalent |
Des références similaires ont été calculées pour le transfert vers / depuis les optimisateurs de Pytorch Cuda. Les résultats sont fondamentalement les mêmes, voici le cahier utilisé pour les optimiseurs l'analyse comparative
https://colab.research.google.com/drive/1y2nehd8xj-ixfjkj2qwua_ujqjbbhhj5
Bien que les tenseurs de SpeedTorch soient généralement plus rapides que celui de Pytorch, l'inconvénient est que les tenseurs de SpeedTorch utilisent plus de mémoire. Cependant, comme les données de transfert peuvent se produire plus rapidement, vous pouvez utiliser SpeedTorch pour augmenter le nombre d'incorporation formé dans votre architecture en tenant des paramètres dans le GPU et le CPU.
Ce tableau est un résumé de l'analyse comparative réalisée dans Google Colab. D'après mon expérience, il semble y avoir une certaine variation dans les valeurs de mémoire signalées dans Colab, + -0,30 Go, alors gardez cela à l'esprit lors de l'examen de ces chiffres. Les valeurs sont destinées à contenir un tenseur de 10 000 000 x 128 float32.
| Type de tenseur | CPU (GB) | GPU (GB) |
|---|---|---|
| Cupy Pinnedcpu | 9.93 | 0,06 |
| Pytorch épinglé | 6.59 | 0,32 |
| Cupy cuda | 0,39 | 9.61 |
| Pytorch cuda | 1.82 | 5.09 |
Bien que le temps de Pytorch vers / depuis pour Pytorch GPU Tensor <-> Pytorch Cuda variable n'est pas aussi rapide que l'équivalent en cupy, la vitesse est toujours réalisable. Donc, si la mémoire est toujours une préoccupation, une approche du meilleur des deux mondes serait de les tenseurs de Cupy de Cupy de SpeedTorch pour stocker les paramètres sur le processeur et les tenseurs GPU Pytorch de SpeedTorch pour stocker les paramètres sur le GPU.
C'est le cahier que j'ai utilisé pour mesurer la quantité de mémoire chaque type de variable prend. https://colab.research.google.com/drive/1zky7pyupaidrnx2hdtbujwo8juy0xkue Si vous utilisez ceci dans Colab, vous devrez redémarrer l'environnement après chaque création du tenseur, pour obtenir une mesure pour le prochain tenseur.
Pour le transfert de GPU CPU <->, cela dépend de la quantité de données transférée et du nombre de cœurs que vous avez. Généralement pour 1 à 2 cœurs de processeur, SpeedTorch sera beaucoup plus rapide. Mais au fur et à mesure que le nombre de noyaux de processeur augmente, les opérations d'indexation du CPU <-> GPU de Pytorch deviennent plus efficaces. Pour plus de détails à ce sujet, veuillez consulter la prochaine section «Comment ça marche». Pour un moyen facile de voir si vous obtenez un avantage de vitesse dans votre système, veuillez exécuter le code d'analyse comparative de votre système, mais modifiez la quantité de données pour refléter le montant avec lequel vous travaillerez dans votre application.
Pour le transfert GPU <-> GPU, si vous utilisez des notations d'indexation ordinaires dans Vanilla Pytorch, tous les systèmes obtiendront une augmentation de la vitesse car SpeedTorch contourne un bogue dans les opérations d'indexation de Pytorch. Mais ce bogue peut être évité si vous utilisez la version nocturne, ou simplement en utilisant différentes notions d'indexation, veuillez consulter la section «Comment cela fonctionne» pour plus de détails.
MISE À JOUR 9-20-19: Je ne savais initialement pas pourquoi cela est plus rapide que d'utiliser des tenseurs de pytorch; Je suis tombé sur l'avantage de vitesse par accident. Mais l'un des développeurs de Pytorch sur le forum Pytorch l'a souligné.
En ce qui concerne le meilleur transfert de CPU <-> GPU, c'est parce que SpeedTorch évite une opération d'indexation du CPU en masquant les tenseurs de processeur en tant que tenseurs de GPU. L'opération d'index CPU peut être lente si vous travaillez avec très peu de cœurs CPU, tels que 2 dans Google Colab, mais peut être plus rapide si vous avez de nombreux cœurs. Cela dépend de la quantité de données que vous transférez et du nombre de cœurs dont vous disposez.
Quant au meilleur transfert GPU <-> GPU, c'est parce que SpeedTorch évite un bug dans l'opération d'indexation. Ce bogue peut également être évité en utilisant les builds nocturnes, ou en utilisant index_select / index_copy_ au lieu d' a[idx] en 1.1 / 1.2.
Pour plus de détails, veuillez consulter ce post pytorch
https://discuss.pytorch.org/t/introducing-speedtorch-4x-peed-cpu-gpu-transfer-110x-gpu-cpu-transfer/56147/2
où un ingénieur Pytorch donne une analyse détaillée sur la façon dont les kernaux d'indexation cupy entraînent des vitesse dans certains cas. Ce n'est pas le transfert lui-même qui devient plus rapide, mais les kernaux d'indexation qui sont utilisés.
Quant à la façon dont la gestion de la mémoire en Cupy fonctionne, je suis direct vers ces deux questions StackOverflow que j'ai posées, où l'intermédiaire brillant Robert Crovella a non seulement donné des explications détaillées, mais a également compris comment allouer de la mémoire épinglée aux tableaux de Cupy en développant son propre allocateur de mémoire à Cupy. Il s'agit essentiellement de la technologie de base derrière SpeedTorch.
https://stackoverflow.com/questions/57750125/cupy-outofmemoryerror-when-trying-to-cupy-load-loger-dimensionn-npy-files-in-me
https://stackoverflow.com/questions/57752516/how-to-use-cuda-pinned-zero-copy-memory-for-a-memory-mapt-file
SpeedTorch est instalable PIP. Vous devez faire installer et importer Cupy avant d'importer SpeedTorch.
!pip install SpeedTorch
import cupy
import SpeedTorch
Ce carnet Colab montre comment charger des données dans SpeedTorch à l'aide de son gadget de données et comment transférer ces données vers / depuis une variable Pytorch CUDA.
https://colab.research.google.com/drive/185z5gi62azxh-teemfrttjqxeifhobxxf
Veuillez consulter le carnet d'analyse comparative de vitesse pour voir l'avantage de vitesse de l'utilisation de SpeedTorch.
Pour les gens qui essaient d'abord de comprendre comment utiliser SpeedTorch, je recommande de suivre cet exemple, car Word2Vec est l'un des algorithmes les plus connus de l'apprentissage automatique.
https://colab.research.google.com/drive/1apjr3onbgqwm3fbcbkmvwagxidxldxot
Le cahier montre comment former Word2Vec de la manière régulière, puis montre comment utiliser SpeedTorch pour s'entraîner sur les mêmes données, en utilisant l'un des optimisateurs normalement non pris en charge pour une formation clairsemée. Cela est possible car comme tous les intégres contenus dans la variable d'incorporation ont une mise à jour à chaque étape, vous pouvez définir sparse=False pendant l'initialisation.
tl; dr:
Formation normale : les variables d'intégration des pytorch contiennent toutes les intérêts. Pytorch Optimizer contient tous les poids des paramètres correspondants pour chaque intégration.
SpeedTorch Ting : Les variables d'intégration de pytorch ne contiennent qu'un lot d'incorporation. Pytorch Optimizer ne contient que tous les poids des paramètres correspondants pour ce lot. Les tenseurs SPARSETORCH contiennent le reste et échangent les intérêts / poids avec la variable Pytorch à chaque étape.
Dans les algorithmes de formation clairsemés comme Word2Vec, Glove ou Neural Collaborative Filtring, seule une fraction des paramètres totaux (intégres) est formé à chaque étape. Si votre GPU ne peut pas gérer toutes vos intérêts à une taille d'intégration souhaitée, une option serait d'accueillir certains de vos paramètres sur des réseaux de CPU à épingle et de transférer ces paramètres à vos tenseurs de modèle selon les besoins. Faire cette primaire à Pytorch serait très lent, surtout parce que le transfert de paramètres entre une variable Pytorch montée CUDA et un tenseur Pytorch CPU épinglé peut prendre 2,5 à 3 secondes (sur Google Colab). Heureusement, cette étape ne prend que 0,02-0,03 seconde avec SpeedTorch!
Utilisation du cas:
--2 829 853 Book Embeddings--
SpeedTorch a été utilisé dans la formation de 2 829 853 livres pour un recommandateur de livres rares.
https://github.com/santosh-gupta/lit2vec2
https://devpost.com/software/lit2vec2
Chaque livre avait une incorporation de taille de 400, mais une taille d'intégration de 496 aurait pu être utilisée, la taille d'intégration de 400 était due à des limites d'espace sur mon Google Drive pour stocker les incorporations formées :(. Mais les limites de la RAM GPU ne sont plus un problème :) Voici un lien direct avec un livre de formation de démon
Remarque: vous avez besoin de la version du cahier Colab qui a 25 Go de RAM, au lieu des 12 Go habituels. Pour obtenir ce type d'instance, vous devez écraser votre instance actuelle en raison de la submergence du RAM, puis une note dans le coin inférieur gauche vous demandant si vous souhaitez mettre à niveau. Vous pouvez le faire en faisant une boucle qui continue de doubler la taille d'une matrice flottante Numpy.
https://colab.research.google.com/drive/1aqht-HetiHxmet1wjqrorc3q9tfjqj19
Voici un lien directement avec le même modèle et les mêmes données, mais n'utilise pas SpeedTorch
https://colab.research.google.com/drive/1idv1jbouzvpcfdsy40wirrphedoanti_
En utilisant la méthode de formation orthodoxe, la plus grande taille d'intégration que Colab est capable de gérer est de 255-260, plus haut que cela et une erreur CUDA se produira
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 Documents de recherche intégrés -
https://github.com/santosh-gupta/research2vec2
SpeedTorch peut me permettre de m'entraîner 14 886 544 intérêts de papier de recherche à une taille d'incorporation de 188, en permettant à mon stockage de mes incorporations cibles sur le CPU, tout en gardant mes incorporations de contexte sur le GPU (l'optimiseur SGD a été utilisé, donc il n'y a pas de poids d'optimiseur).
Voici un lien direct vers le cahier.
https://colab.research.google.com/drive/1sakzsahoy6o_u1df_z15_qkr5ylni_gr
Remarque: vous avez besoin de la version du cahier Colab qui a 25 Go de RAM, au lieu des 12 Go habituels. Pour obtenir ce type d'instance, vous devez écraser votre instance actuelle en raison de la submergence du RAM, puis une note dans le coin inférieur gauche vous demandant si vous souhaitez mettre à niveau. Vous pouvez le faire en faisant une boucle qui continue de doubler la taille d'une matrice flottante Numpy.
Sans SpeedTorch, seule une taille d'incorporation de 94-96 peut être utilisée sur Google Colab Tesla K80 GPU avant une erreur RuntimeError: CUDA out of memory . Voici une version de la formation sans utiliser SpeedTorch.
https://colab.research.google.com/drive/1jh7rugeajhdwdgnfwg3twm1zjytqu0kr
Chaque fois que vous utilisez les tenseurs GPU Cupy, initialisez-les avant les tenseurs de processeur épinglés. En effet Donc, si vous êtes limité sur le RAM CPU, et que vous avez déjà vos tenseurs de processeurs épinglés en mémoire, l'initialisation des tenseurs GPU Cupy peut provoquer un accident.
Si vous êtes en mesure d'adapter tous vos paramètres dans votre mémoire GPU, utilisez Pure Pytorch car il s'agit de l'option la plus rapide pour la formation. Mais si vous ne pouvez pas s'adapter à tous vos paramètres en mémoire, divisez vos paramètres (gardez à l'esprit que vos optimisateurs ont également des poids) entre les tenseurs cuda cupy de SpeedTorch et les tenseurs de processeur à épingle à cupy de SpeedTorch; Il s'agit de la 2e option la plus rapide. Mais, si vous n'êtes toujours pas en mesure d'adapter tous vos paramètres dans la mémoire de cette façon, divisez vos paramètres entre les tenseurs de processeurs épinglés à cupy de SpeedTorch et les tenseurs Pytorch Cuda de SpeedTorch; Ceci est plus lent que les deux options, mais utilise moins de mémoire GPU. Pour la 3ème option, voici deux ordinateurs portables qui montrent un exemple de ce https://colab.research.google.com/drive/1aqht-Hetihxmet1wjqrorc3q9tfjqj19, https://colab.research.google.com/drive/1sakzsahoy6o_u1df_z15_qkr5ylni_gr
Après l'entraînement, la sauvegarde des variables CUDA entraînera une augmentation de l'utilisation de la mémoire et peut provoquer un accident, en particulier avec Cupy. Si vous êtes aux limites de votre bélier. Dans ce cas, utilisez la méthode getNumpyVersion pour obtenir une version Numpy de votre tenseur, puis utilisez Utilisez Numpy.save ou HDPY / Pytables pour enregistrer votre tableau Numpy. Numpy Save est plus léger.
Ouvrir un problème, soit discuter avec moi répertoire sur gitter ici https://gitter.im/speedtorch
Je cherche à incoporer plus de fonctionnalités autour du transfert de processeur rapide -> GPU. Si vous avez une idée, veuillez publier un problème de github.
De plus, les tendeurs GPU GPU / CPU et Pytorch GPU, Pytorch, SpeedTorch possède également des tenseurs de processeur épinglés à Pytorch et des tenseurs de processeur GPU Memmap / CPU Cupy Memmap. Je n'ai pas trouvé une utilisation solide pour ces types de tenseurs, mais ils sont entièrement codés et disponibles pour une utilisation.
https://github.com/santosh-gupta/speedtorch/tree/master/speedtorch
Un domaine que je voudrais regarder est s'il existe un moyen d'avoir une réduction de la mémoire de RAM en utilisant des memmaps cupy. Jusqu'à présent, ils utilisent autant de mémoire que les versions en direct.
ModelFactory ( model_variable , total_classes , embed_dimension , datatype = 'float32' , CPUPinn = False )Crée des commutateurs pour les variables de modèle à l'aide de Cupy. Communique des variables de votre collection d'intégration complète et de votre collection de lots de modèles. Chaque variable a besoin de son propre commutateur.
Exemple:
uEmbed_switcher = SpeedTorch . ModelFactory ( skip_gram_modelSparse . u_embeddings , total_classes = 50000 , embed_dimension = 128 )Arguments:
model_variable : variable spécifique à partir de votre modèle pour lequel vous souhaitez créer un commutateur.
total_classes : La quantité totale d'incorporation à former.
embed_dimension : dimension des intégres.
datatype (facultatif): type de données pour la variable. La valeur par défaut est «float32».
CPUPinn (facultatif): épinglez votre collection d'intégration complète au processeur. Spares GPU Memory, mais le transfert de données sera plus lent. La valeur par défaut est fausse.
Méthodes:
zerosInit() : initialise la collection complète de Switcher variable avec zéros:
uniformDistributionInit(low, high) : initialise la collection complète du commutateur variable avec une distribution uniforme de low à high
normalDistributionInit(mean, stdDev) : initialise la collection complète de Switcher variable avec une distribution normale avec une moyenne de mean et un écart-type de stdDev
variableTransformer( batchSize, posPerBatch, negPerBatch = None ) : configure une entrée factice à utiliser pour l'étape avant de votre modèle. batchSize est la taille de votre lot, et posPerBatch est le nombre d'exemples positifs par lot. Si une deuxième entrée factice est nécessaire pour les exemples négatifs, negPerBatch (facultatif) peut être défini sur le nombre d'exemples négatifs et deux entrées factices seront renvoyées à la place.
beforeForwardPass(retrievedPosIndexes , retrievedNegIndexes = None) : passe des incorporations de la collection intégrale d'incorporation à vos incorporations de modèle. retrievedPosIndexes sont les indices des échantillons positifs à récupérer. Si des échantillons négatifs doivent également être récupérés, une valeur pour retrievedNegIndexes (facultative) peut également être adoptée.
afterOptimizerStep( retrievedPosIndexes , retrievedNegIndexes = None) : Communique les intégres mis à jour de votre modèle à la collection intégrale d'intégration. retrievedPosIndexes sont les indices des échantillons positifs qui ont été récupérés. Si des échantillons négatifs ont également été récupérés, une valeur pour retrievedNegIndexes (facultative) peut également être adoptée.
saveCupy(saveFileName) : Enregistrez le Tensor vers le fichier .npy.
loadCupy(loadFileName) : Chargez le tenseur du fichier .npy.
getNumpyVersion : Obtenez la version Numpy de Tensor.
OptimizerFactory( given_optimizer, total_classes, embed_dimension, model, variable_name, dtype='float32' , CPUPinn = False)
Crée des commutateurs pour les variables d'optimiseur à l'aide de Cupy. Communique des variables de votre collection d'intégration complète et de votre collection de lots Optimizer. Chaque variable a besoin de son propre commutateur.
Exemple:
uAdagrad_switcher = SpeedTorch . OptimizerFactory ( given_optimizer , total_classes , embed_dimension , model , variable_name , dtype = 'float32' , CPUPinn = False )Arguments:
given_optimizer : L'optimiseur a initialisé avec les poids de votre modèle. Si vous utilisez pour une formation intégrée, n'oubliez pas de définir le paramètre sparse sur False . Actuellement, les optimisateurs pris en charge sont Sparseadam, Adadelta, Adamax, Adam, Adamw, ASGD et RMSProp. RPROP est également inclus, mais a besoin de la première passe avant et une étape loss.backward() à terminer pour initialiser l'instance OptimizerFactory. Cela est dû à l'optimiseur RPROP nécessitant des gradients de ses paramètres pour l'initialisation.
total_classes : La quantité totale d'incorporation à former.
embed_dimension : dimension des intégres.
model : l'instance de votre modèle.
variable_name : nom exact de la variable définie dans votre modèle.
dtype (Facultatif): Type de données de votre variable. La valeur par défaut est 'float32'
CPUPinn (facultatif): épinglez votre collection de poids variable d'optimiseur complète vers le processeur. Spares GPU Memory, mais le transfert de données sera plus lent. La valeur par défaut est fausse.
Méthodes:
optInit : initialise le commutateur de variable Optimizer.
beforeForwardPass(retrievedPosIndexes , retrievedNegIndexes = None) : change les poids variables de l'optimiseur de la collection de poids complets au tenseur de poids optimiseur. retrievedPosIndexes sont les indices des échantillons positifs à récupérer. Si des échantillons négatifs doivent également être récupérés, une valeur pour retrievedNegIndexes (facultative) peut également être adoptée.
afterOptimizerStep( retrievedPosIndexes , retrievedNegIndexes = None) : change les poids variables de l'optimiseur de votre optimiseur à la collection de poids complets. retrievedPosIndexes sont les indices des échantillons positifs qui ont été récupérés. Si des échantillons négatifs ont également été récupérés, une valeur pour retrievedNegIndexes (facultative) peut également être adoptée.
Crée un tenseur dont la fonction principale est de transférer son contenu à une variable Pytorch Cuda.
DataGadget( fileName, CPUPinn=False)
Arguments:
fileName : emplacement des données.
CPUPinn : (facultatif): épinglez vos données sur CPU. La valeur par défaut est fausse.
Méthodes:
getData(indexes) : récupère les données dans un format prêt à être accepté par une variable Pytorch CUDA. indexes sont les index du tenseur à partir de laquelle récupérer les données.
insertData(dataObject, indexes) : Insérez les données d'une variable Pytorch CUDA. dataObject est la variable Pytorch CUDA Données de tenseur à partir desquelles les données seront récupaires et indexes du tenseur à partir desquels récupérer les données.
saveCupy(saveFileName) : Enregistrez le Tensor vers le fichier .npy.
loadCupy(loadFileName) : Chargez le nouveau tenseur à partir du fichier .npy.
getNumpyVersion : Obtenez la version Numpy de Tensor.
Veuillez consulter ce cahier sur la façon d'utiliser le gadget de données
https://colab.research.google.com/drive/185z5gi62azxh-teemfrttjqxeifhobxxf
PytorchModelFactory ( model_variable , total_classes , embed_dimension , datatype = 'float32' , deviceType = 'cuda' , pinType = False )Crée des commutateurs pour les variables de modèle à l'aide des tenseurs de pytorch. Communique des variables de votre collection d'intégration complète et de votre collection de lots de modèles. Chaque variable a besoin de son propre commutateur.
Exemple:
uEmbed_switcher = SpeedTorch . PytorchModelFactory ( skip_gram_modelSparse . u_embeddings , total_classes = 50000 , embed_dimension = 128 )Arguments:
model_variable : variable spécifique à partir de votre modèle pour lequel vous souhaitez créer un commutateur.
total_classes : La quantité totale d'incorporation à former.
embed_dimension : dimension des intégres.
datatype (facultatif): type de données pour la variable. La valeur par défaut est «float32».
deviceType (Facultatif): Définissez le périphérique sur «CUDA» ou «CPU». La valeur par défaut est 'CUDA'
pinType (Facultatif): Si le périphérique est défini sur «CPU», vous pouvez spécifier à l'aide de la mémoire épinglée. La valeur par défaut est «faux».
Méthodes:
zerosInit() : initialise la collection complète de Switcher variable avec zéros:
uniformDistributionInit(low, high) : initialise la collection complète du commutateur variable avec une distribution uniforme de low à high
normalDistributionInit(mean, stdDev) : initialise la collection complète de Switcher variable avec une distribution normale avec une moyenne de mean et un écart-type de stdDev
customInit(initFunction, *args) : utilisez n'importe quel initialiseur Pytorch pour la collection complète des commutateurs variables. Passez l'initialiseur en utilisant initFunction et ses arguments correspondants à l'aide de *args .
variableTransformer(batchSize, posPerBatch, negPerBatch = None ) : configure une entrée factice à utiliser pour l'étape avant de votre modèle. batchSize est la taille de votre lot, et posPerBatch est le nombre d'exemples positifs par lot. Si une deuxième entrée factice est nécessaire pour les exemples négatifs, negPerBatch (facultatif) peut être défini sur le nombre d'exemples négatifs et deux entrées factices seront renvoyées à la place.
beforeForwardPass(retrievedPosIndexes , retrievedNegIndexes = None) : passe des incorporations de la collection intégrale d'incorporation à vos incorporations de modèle. retrievedPosIndexes sont les indices des échantillons positifs à récupérer. Si des échantillons négatifs doivent également être récupérés, une valeur pour retrievedNegIndexes (facultative) peut également être adoptée.
afterOptimizerStep(retrievedPosIndexes , retrievedNegIndexes = None) : Communique les intégres mis à jour de votre modèle à la collection intégrale d'intégration. retrievedPosIndexes sont les indices des échantillons positifs qui ont été récupérés. Si des échantillons négatifs ont également été récupérés, une valeur pour retrievedNegIndexes (facultative) peut également être adoptée.
saveTorch(saveFileName) : Enregistrer le tenseur dans le fichier à l'aide de Torch.save
loadTorch(loadFileName) : Chargez le tenseur à l'aide de la torche.
getNumpyVersion : Obtenez la version Numpy de Tensor.
PytorchOptimizerFactory( given_optimizer, total_classes, embed_dimension, model, variable_name, dtype='float32', deviceType = 'cuda', pinType = False)
Crée des commutateurs pour les variables d'optimiseur à l'aide de tenseurs de pytorch. Communique des variables de votre collection d'intégration complète et de votre collection de lots Optimizer. Chaque variable a besoin de son propre commutateur.
Exemple:
uAdagrad_switcher = SpeedTorch . PytorchOptimizerFactory ( given_optimizer , total_classes , embed_dimension , model , variable_name , dtype = 'float32' )Arguments:
given_optimizer : L'optimiseur a initialisé avec les poids de votre modèle. Si vous utilisez pour une formation intégrée, n'oubliez pas de définir le paramètre sparse sur False . Actuellement, les optimisateurs pris en charge sont Sparseadam, Adadelta, Adamax, Adam, Adamw, ASGD et RMSProp. RPROP est également inclus, mais a besoin de la première passe avant et une étape loss.backward() à terminer pour initialiser l'instance OptimizerFactory. Cela est dû à l'optimiseur RPROP nécessitant des gradients de ses paramètres pour l'initialisation.
total_classes : La quantité totale d'incorporation à former.
embed_dimension : dimension des intégres.
model : l'instance de votre modèle.
variable_name : nom exact de la variable définie dans votre modèle.
dtype (Facultatif): Type de données de votre variable. La valeur par défaut est 'float32'
deviceType (Facultatif): Définissez le périphérique sur «CUDA» ou «CPU». La valeur par défaut est 'CUDA'
pinType (Facultatif): Si le périphérique est défini sur «CPU», vous pouvez spécifier à l'aide de la mémoire épinglée. La valeur par défaut est «faux».
Méthodes:
optInit : initialise le commutateur de variable Optimizer.
beforeForwardPass(retrievedPosIndexes , retrievedNegIndexes = None) : change les poids variables de l'optimiseur de la collection de poids complets au tenseur de poids optimiseur. retrievedPosIndexes sont les indices des échantillons positifs à récupérer. Si des échantillons négatifs doivent également être récupérés, une valeur pour retrievedNegIndexes (facultative) peut également être adoptée.
afterOptimizerStep( retrievedPosIndexes , retrievedNegIndexes = None) : change les poids variables de l'optimiseur de votre optimiseur à la collection de poids complets. retrievedPosIndexes sont les indices des échantillons positifs qui ont été récupérés. Si des échantillons négatifs ont également été récupérés, une valeur pour retrievedNegIndexes (facultative) peut également être adoptée.
Si vous utilisez SpeedTorch dans vos recherches ou si vous souhaitez citer, veuillez citer avec:
@Misc {
title = {SpeedTorch},
auteur = {Santosh Gupta},
howpublished = { url {github.com/santosh-gupta/speedtorch}},
année = {2019}
}
