SpeedTorch
1.0.0
Schnellere CPU-Tensor <--> GPU-Pytorch-Variabentransfer und GPU-Tensor <--> GPU-Pytorch-Variablenübertragung in bestimmten Fällen.
Da für einige Systeme die Verwendung der festgespannten Pytorch -CPU -Tensoren schneller ist als die Verwendung von cuda cpu (siehe Abschnitt "How It Works" für Details), habe ich allgemeine cpu -Tensor -Klassen PytorchModelFactory und PytorchOptimizerFactory erstellt. Die ursprünglichen GPUPytorchModelFactory und GPUPytorchOptimizerFactory -Klassen befinden sich noch in der Bibliothek. Daher sollte kein vorhandener Code mit SpeedTorch betroffen sein. Die Dokumentation wurde aktualisiert, um diese neuen Klassen einzuschließen.
Diese Bibliothek dreht sich um Cupy -Tensoren, die an CPU festgehalten werden, wodurch 3,1 -fach eine schnellere CPU -> GPU -Übertragung erzielt werden können als normale Pytorch -CPU -Tensoren können und 410x schneller GPU -> CPU -Transfer. Die Geschwindigkeit hängt von der Datenmenge und der Anzahl der CPU -Kerne in Ihrem System ab (siehe Abschnitt "Wie funktioniert es für weitere Informationen))
Die Bibliothek enthält Funktionen für das Einbettungsschulungsausbildung. Es kann Einbettung auf CPU -RAM veranstalten, während sie untätig sind und GPU -RAM ersparen.
Ich habe diese Bibliothek zunächst erstellt, um eine große Anzahl von Einbettungen zu trainieren, die die GPU möglicherweise Probleme im RAM hat. Dazu stellte ich fest, dass ein Teil der Einbettungen der CPU dazu beitragen kann, dies zu erreichen. Einbettungssysteme verwenden Sprease -Training; Nur ein Teil der gesamten Prameter beteiligen sich an den Stürmer-/Aktualisierungsschritten, der Rest ist im Leerlauf. Also dachte ich mir, warum nicht die Leerlaufparameter während des Trainingsschritts von der GPU fernhalten? Dafür brauchte ich eine schnelle CPU -> GPU -Übertragung.
Die vollständige Hintergrundgeschichte finden Sie auf der DevPost -Seite
https://devpost.com/software/speedtorch-6w5Unb
Mit schneller CPU-> GPU können viele lustige Methoden für Funktionen entwickelt werden, die die Leute für möglicherweise nicht möglich gehalten haben.
? Umpf integrieren Sie SpeedTorch in Ihre Datenpipelines für die schnelle Datenübertragung zu/von CPU <-> GPU
? Euen Schulungsparameter über CPU -Speicher. Solange Sie über genügend CPU -RAM verfügen, können Sie eine beliebige Anzahl von Einbettungen hosten, ohne sich um den GPU -RAM zu sorgen müssen.
Verwenden Sie Adadelta, Adamax, RMSProp, RPROP, ASGD, ADAMW und Adam Optimizer für spärliche Einbettungstraining. Zuvor waren nur Spraseadam, Adagrad und SGD geeignet, da nur diese direkt spärlichen Gradienten unterstützen.
(Bearbeiten Sie 9-20-19, einer der Pytorch-Entwickler wies auf einige kleinere Fehler im ursprünglichen Bank-Markierungscode hin, die Werte und der Code wurden aktualisiert)
Hier ist ein Notizbuch, in dem die Übertragung über SpeedTorch vs Pytorch -Tensoren vergleicht werden, wobei sowohl die CPU- als auch die Cuda -Tensoren festgehalten werden. Alle Tests wurden mit einer Colab -Instanz mit einer Tesla K80 -GPU und 2 Kern -CPU durchgeführt.
UPDATE 10-17-19: Google Colab ist jetzt mit 4 Kern-CPUs Standard. Daher wird dieses Notebook unterschiedliche Ergebnisse liefert als unten gemeldet, da die Indexierungskern von Pytorch mit zunehmender Anzahl von CPU-Kernen effizienter werden.
https://colab.research.google.com/drive/1pxhbmbzqtiq_nlfguianpf_mfpiqskks
In diesem Notebook werden die Datenübertragung von 131.072 Float32 -Einbettungen von Dimension 128 zu und von den Cupy/Pytorch -Tensoren und Pytorch -Variablen mit n = 100. Die CPU von Google Colab verfügt über 4 Kerne, was sich auf die Übertragungsgeschwindigkeit auswirkt. CPUs mit einer höheren Anzahl von Kernen werden weniger eine Beratung für die Verwendung von SpeedTorch sehen.
Die folgende Tabelle ist eine Zusammenfassung der Ergebnisse. Das Übertragen von Daten von Pytorch -Cuda -Tensoren an die Cuda Pytorch -Einbettungsvariable ist schneller als das SpeedTorch -Äquivalent, aber für alle anderen Transfertypen ist SpeedTorch schneller. Und für die Summe beider Schritte, die auf/von der Cuda Pytorch -Einbettung übertragen werden, ist SpeedTorch schneller als das Pytorch -Äquivalent für die reguläre GPU- und CPU -Tensoren.
Ich habe festgestellt, dass unterschiedliche Fälle von Colab zu unterschiedlichen Geschwindigkeitsergebnissen führen. Denken Sie also daran, während Sie diese Ergebnisse überprüfen. Ein persönlicher Lauf des Colab -Notizbuchs kann zu unterschiedlichen Werten führen, obwohl die Reihenfolge der Magnetude der Ergebnisse im Allgemeinen gleich ist.
Die Übertragungszeiten in den folgenden Tabellen sind in Sekunden angegeben. Dieses Benchmarking wurde mit einem Colab -Instanz vorgebildet, dessen CPU 2 Kerne hat. Colab verfügt über eine Pro -Version von kostenpflichtigen Instanzen, die 4 Kern -CPUs sind. Daher würde das folgende Benchmarking diese Instanzen nicht widerspiegeln.
| Tensortyp | Cuda Pytorch Variable | Vergleich |
|---|---|---|
| SpeedTorch (CUDA) | 0,0087 | 6.2x langsamer als Pytorch -Äquivalent |
| SpeedTorch (PinnedCPU) | 0,0154 | 3.1x schneller als Pytorch -Äquivalent |
| Pytorch (CUDA) | 0,0014 | 6.2x schneller als SpeedTorch -Äquivalent |
| Pytorch (pintedCpu) | 0,0478 | 3.1x langsamer als SpeedTorch -Äquivalent |
| Tensortyp | Aus Cuda Pytorch -Variable | Vergleich |
|---|---|---|
| SpeedTorch (CUDA) | 0,0035 | 9,7x schneller als Pytorch -Äquivalent |
| SpeedTorch (PinnedCPU) | 0,0065 | 410x schneller als Pytorch -Äquivalent |
| Pytorch (CUDA) | 0,0341 | 9,7x langsamer als SpeedTorch -Äquivalent |
| Pytorch (pintedCpu) | 2.6641 | 410x langsamer als SpeedTorch -Äquivalent |
| Tensortyp | Summe von bis/von Cuda Pytorch Variable | Vergleich |
|---|---|---|
| SpeedTorch (CUDA) | 0,0122 | 2,9x schneller als Pytorch -Äquivalent |
| SpeedTorch (PinnedCPU) | 0,0219 | 124x schneller als Pytorch -Äquivalent |
| Pytorch (CUDA) | 0,0355 | 2,9x langsamer als SpeedTorch -Äquivalent |
| Pytorch (pintedCpu) | 2.7119 | 124x langsamer als SpeedTorch -Äquivalent |
Ähnliche Benchmarks wurden für die Übertragung zu/von Pytorch -Cuda -Optimierern berechnet. Die Ergebnisse sind im Grunde genommen gleich. Hier ist das Notizbuch, das für das Benchmarking der Optimierer verwendet wird
https://colab.research.google.com/drive/1Y2NEHD8XJ-IXFJKJ2QWUA_UJQJBBHHJ5
Obwohl die Tensoren von SpeedTorch im Allgemeinen schneller sind als die von Pytorch, ist der Nachteil der Tensoren von SpeedTorch mehr Speicher. Da das Übertragen von Daten jedoch schneller erfolgen kann, können Sie SpeedTorch verwenden, um die Anzahl der in Ihrer Architektur geschultes Einbettungsdings zu erweitern, indem sie Parameter sowohl in der GPU als auch in der CPU halten.
Diese Tabelle ist eine Zusammenfassung des Benchmarking in Google Colab. Aus meiner Erfahrung scheint es eine gewisse Variation der gemeldeten Speicherwerte in Colab, +-0,30 GB, zu geben. Denken Sie also daran, dass diese Zahlen überprüft werden. Die Werte sind für das Halten eines 10.000.000 x 128 Float32 -Tensors.
| Tensortyp | 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 |
Obwohl die Zeit von Pytorch für/von für Pytorch GPU-Tensor <--> Pytorch CUDA-Variable nicht so schnell ist wie das Cupy-Äquivalent, ist die Geschwindigkeit immer noch funktionsfähig. Wenn also das Gedächtnis immer noch ein Problem darstellt, wäre ein Best of beiden Welten, um die Cupy -CPU von SpeedTorch zu erledigen, um Parameter auf der CPU zu speichern, und Speedtorchs Pytorch -GPU -Tensoren, um Parameter auf der GPU zu speichern.
Dies ist das Notizbuch, das ich verwendet habe, um zu messen, wie viel Speicher jeder variable Typ dauert. https://colab.research.google.com/drive/1zky7pyupaidrnx2hdtbujwo8juy0xkue Wenn Sie dies in Colab verwenden, müssen Sie die Umgebung nach jeder Tensor -Kreation neu starten.
Für die CPU <--> GPU-Übertragung hängt sie von der Datenmenge und der Anzahl der Kerne ab, die Sie haben. Im Allgemeinen ist SpeedTorch für 1-2 CPU-Kerne viel schneller. Aber wenn die Anzahl der CPU-Kerne steigt, wird Pytorchs CPU <--> -GPU-Indexierungsvorgänge effizienter. Weitere Informationen dazu finden Sie im Abschnitt "Wie funktioniert es". Eine einfache Möglichkeit, um festzustellen, ob Sie einen Geschwindigkeitsvorteil in Ihrem System erhalten, führen Sie bitte den Benchmarking -Code in Ihrem System aus. Ändern Sie jedoch die Datenmenge, um den Betrag widerzuspiegeln, mit dem Sie in Ihrer Anwendung arbeiten.
Bei der GPU <--> GPU-Übertragung erhalten alle Systeme bei Verwendung normaler Indexierungsnotationen in Vanille-Pytorch eine Geschwindigkeitssteigerung, da SpeedTorch einen Fehler in Pytorch-Indexierungsvorgängen umgeht. Dieser Fehler kann jedoch vermieden werden, wenn die nächtliche Version verwendet oder nur verschiedene Indexierungsbegriffe verwendet werden. Weitere Informationen finden Sie im Abschnitt "Wie es funktioniert".
Update 9-20-19: Ich hatte zunächst keine Ahnung, warum dies schneller ist als die Verwendung von Pytorch-Tensoren. Ich stolperte versehentlich auf den Geschwindigkeitsvorteil. Aber einer der Pytorch -Entwickler im Pytorch -Forum wies darauf hin.
Was den besseren CPU <--> -GPU-Transfer betrifft, vermeidet SpeedTorch einen CPU-Indexierungsbetrieb, indem CPU-Tensoren als GPU-Tensoren getötet werden. Der CPU -Indexbetrieb kann langsam sein, wenn Sie mit sehr wenigen CPU -Kernen wie 2 in Google Colab weiterarbeiten, aber schneller sein können, wenn Sie viele Kerne haben. Es hängt davon ab, wie viele Daten Sie übertragen und wie viele Kerne Sie haben.
Was die bessere GPU <--> GPU-Übertragung betrifft, vermeidet SpeedTorch einen Fehler in der Indexierungsoperation. Dieser Fehler kann auch durch die Verwendung der nächtlichen Builds oder mithilfe von index_select / index_copy_ anstelle a[idx] -Straftation in 1.1 / 1.2 vermieden werden.
Weitere Informationen dazu finden Sie in diesem Pytorch -Beitrag
https://discuss.pytorch.org/t/introducingspeedtorch-4x-speed-cpu-gpu-transfer-110x-gpu-cpu-transfer/56147/2
Wenn ein Pytorch -Ingenieur eine detaillierte Analyse darüber angibt, wie die Cupy -Indexierungskerns in bestimmten Fällen zu Geschwindigkeits -Ups führen. Es ist nicht die Übertragung selbst, die schneller wird, sondern die indizierenden Kernals, die verwendet werden.
Wie die Speicherverwaltung in Cupy funktioniert, leite ich diese beiden Stackoverflow -Fragen, die ich gestellt habe, wo der brillante Benutzer Robert Crovella nicht nur detaillierte Erklärungen gab, sondern auch herausgefunden hat, wie man Cupy -Arrays festgelegt hat, indem er seinen eigenen Speicher Allocator für Cupy entwickelte. Dies ist im Grunde die Kerntechnologie hinter SpeedTorch.
https://stackoverflow.com/questions/57750125/cupy-outofMemoryError-when-trying-to-cupy-load-larger-npy-files-in-me
https://stackoverflow.com/questions/57752516/how-to-use-s-cuda-pinned-zero-copy-memory-for-memory-mapyde-file
SpeedTorch ist pip installierbar. Sie müssen Cupy installieren und importieren lassen, bevor Sie SpeedTorch importieren.
!pip install SpeedTorch
import cupy
import SpeedTorch
Dieses Colab -Notizbuch zeigt, wie Daten mithilfe seines Datengerichts Daten in SpeedTorch geladen werden und wie diese Daten in eine Pytorch -CUDA -Variable übertragen werden können.
https://colab.research.google.com/drive/185z5gi62azxh-eemfrttjqxeifHOBXXF
Bitte beachten Sie das Speed Benchmarking -Notebook, um den Geschwindigkeitsvorteil der Verwendung von SpeedTorch zu sehen.
Für Personen, die zuerst versuchen, herauszufinden, wie Sie SpeedTorch verwenden, empfehle ich, dieses Beispiel zu folgen, da Word2VEC einer der häufig bekannten Algorithmen im maschinellen Lernen ist.
https://colab.research.google.com/drive/1apjr3onbgqwm3fbcbkmvwagxidxldxot
Das Notizbuch zeigt, wie Sie Word2Vec auf regelmäßige Weise trainieren, und zeigt dann, wie SpeedTorch verwendet wird, um auf denselben Daten zu trainieren, wobei einer der Optimierer verwendet wird, die normalerweise nicht für spärliches Training unterstützt werden. Dies ist möglich, da alle in der Einbettungsvariablen enthaltenen Einbettungsdings in jedem Schritt ein Update aufweisen, können Sie während der Initialisierung sparse=False festlegen.
tl; dr:
Normales Training : Pytorch -Einbettungsvariablen enthalten alle Einbettungen. Der Pytorch -Optimierer enthalten alle entsprechenden Parametergewichte für jede Einbettung.
SpeedTorch Traing : Pytorch -Einbettungsvariablen enthalten nur eine Charge von Einbettungen. Der Pytorch -Optimierer enthält nur alle entsprechenden Parametergewichte für diese Charge. Sparsetorch -Tensoren enthalten den Rest und tauscht die Einbettung/Gewichte mit der Pytorch -Variablen bei jedem Schritt aus.
In spärlichen Trainingsalgorithmen wie Word2VEC, Handschuh oder neuronaler kollaborativer Filterung werden nur ein Bruchteil der Gesamtparameter (Einbettdngs) in jedem Schritt trainiert. Wenn Ihre GPU nicht alle Ihre Einbettungsdings mit einer gewünschten Einbettungsgröße verarbeiten kann, besteht eine Option darin, einige Ihrer Parameter in festgestellten CPU -Cupy -Arrays zu hosten und diese Parameter bei Bedarf auf Ihre Modell -Tensoren zu übertragen. Dies in Pytorch zu tun, wäre sehr langsam, insbesondere weil die Übertragung von Parametern zwischen einer CUDA-montierten Pytorch-Variablen und einem festgestellten CPU-Pytorch-Tensor 2,5-3 Sekunden (bei Google Colab) dauern kann. Glücklicherweise dauert dieser Schritt mit SpeedTorch nur 0,02-0,03 Sekunden!
Fall verwendet:
-2,829.853 Bucheinbettungen-
SpeedTorch wurde in der Ausbildung von 2.829.853 Büchern für einen seltenen Buchempfänger verwendet.
https://github.com/santosh-gupta/lit2VEC2
https://devpost.com/software/lit2vec2
Each book had an embedding of size of 400, but an embedding size of 496 could have been used, the 400 embedding size was due to limits of space on my Google Drive to store the trained embeddings :(. But the limits of the GPU RAM is no longer an issue :) Here is a direct link to a demo training notebook, which trains with a 496 embedding size using SpeedTorch
Hinweis: Sie benötigen die Version des Colab -Notizbuchs mit 25 GB RAM anstelle der üblichen 12 GB. Um diese Art von Instanz zu erhalten, müssen Sie Ihre aktuelle Instanz aufgrund des überwältigenden RAM und dann in der unteren linken Ecke, die gefragt werden, ob Sie ein Upgrade wünschen, zum Absturz bringen. Sie können dies tun, indem Sie eine Schleife erstellen, die immer wieder die Größe einer numpy Float -Matrix verdoppelt.
https://colab.research.google.com/drive/1aqht-hetihxmet1wjqrorc3q9tfjqj19
Hier ist ein direkter Verknüpfung mit demselben Modell und Daten, verwendet jedoch nicht SpeedTorch
https://colab.research.google.com/drive/1idv1jbouzvpcfdSy40Wirrphedoanti_
Unter Verwendung der orthodoxen Trainingsmethode ist die größte Einbettungsgröße, die Colab behandeln kann
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 Forschungsarbeiten Einbettungen--
https://github.com/santosh-gupta/research2VEC2
Speedtorch kann es mir ermöglichen, 14.886.544 Forschungsarbeiten zu schulen, indem ich 188 eine Einbettungsgröße von 188 ausbettet, indem ich mein Ziel -Einbettungen auf der CPU speichern kann, während mein Kontext einbettet, die die GPU -Einbettungen an der GPU halten (SGD -Optimierer wurde verwendet, sodass keine Optimierer -Gewichte vorhanden sind).
Hier ist ein direkter Link zum Notizbuch.
https://colab.research.google.com/drive/1sakzsahoy6o_u1df_z15_qkr5ylni_gr
Hinweis: Sie benötigen die Version des Colab -Notizbuchs mit 25 GB RAM anstelle der üblichen 12 GB. Um diese Art von Instanz zu erhalten, müssen Sie Ihre aktuelle Instanz aufgrund des überwältigenden RAM und dann in der unteren linken Ecke, die gefragt werden, ob Sie ein Upgrade wünschen, zum Absturz bringen. Sie können dies tun, indem Sie eine Schleife erstellen, die immer wieder die Größe einer numpy Float -Matrix verdoppelt.
Ohne SpeedTorch kann bei Google Colab Tesla K80 GPU vor einem RuntimeError: CUDA out of memory nur eine Einbettungsgröße von 94-96 verwendet werden. Hier ist eine Version des Trainings, ohne SpeedTorch zu verwenden.
https://colab.research.google.com/drive/1JH7RUREAJHDWDGNFWG3TWM1ZJYTQU0KR
Wenn die Cupy -GPU -Tensoren verwendet werden, initialisieren Sie diese vor einem festgestellten CPU -Tensoren. Dies liegt daran, dass die Initialisierung der Cupy -GPU -Tensoren eine feste Menge CPU -RAM zu verwenden scheint. Wenn Sie also auf CPU -RAM begrenzt sind und bereits Ihre festgestellten CPU -Tensoren im Speicher haben, kann die Initialisierung der Cupy -GPU -Tensoren zu einem Absturz führen.
Wenn Sie in der Lage sind, alle Ihre Parameter in Ihren GPU -Speicher einzubauen, verwenden Sie Pure Pytorch, da dies die schnellste Option für das Training ist. Wenn Sie jedoch nicht alle Ihre Parameter in den Speicher einfügen können, teilen Sie Ihre Parameter auf (denken Sie daran, dass Ihre Optimierer auch Gewichte haben) zwischen Speedtorchs Cupy Cuda -Tensoren und Speedtorchs Cupy CPU -Tensoren. Dies sind die zweit schnellsten Optionen. Wenn Sie jedoch nicht in der Lage sind, alle Ihre Parameter auf diese Weise in den Speicher zu bringen, teilen Sie Ihre Parameter zwischen Speedtorchs Cupy CPU -Tensoren und Speedtorchs Pytorch -Cuda -Tensoren auf. Dies ist langsamer als beide Optionen, verwendet jedoch weniger GPU -Speicher. Für die 3. Option finden Sie hier zwei Notizbücher, die ein Beispiel für dieses https://colab.research.google.com/drive/1aqht-hetihxMet1wjqrorc3q9tfjqj19, https://colab.research.google.com/drive/1sakzsahoy6o_u1df_z15_qkr5ylni_gr
Nach dem Training führt das Speichern von CUDA -Variablen zu einer Zunahme des Speicherverbrauchs und kann zu einem Absturz führen, insbesondere bei Cupy. Wenn Sie an den Grenzen Ihres Widders sind. Verwenden Sie in diesem Fall die getNumpyVersion -Methode, um eine Numpy -Version Ihres Tensors zu erhalten, und verwenden Sie dann Numpy.Save oder HDPY/Pytables, um Ihr Numpy -Array zu speichern. Numpy Save ist leichter.
Öffnen Sie entweder ein Problem oder chatten Sie mit mir auf dem Gitter hier https://gitter.im/speedtorch
Ich suche in der schnellen CPU -> GPU -Übertragung mehr Funktionalitäten. Wenn Sie eine Idee haben, veröffentlichen Sie bitte ein Github -Problem.
Zusätzlich hat Speedtorch die Cupy GPU/Pytorch -GPU -Tensoren von CPU und Pytorch auch Pytorch CPU -Tensoren und Cupy Memmap -GPU/festgesteckte CPU -Tensoren. Ich habe keinen soliden Gebrauch für diese Art von Tensoren gefunden, aber sie sind vollständig codiert und für die Verwendung verfügbar.
https://github.com/santosh-gupta/speedtorch/tree/master/speedtorch
Ein Bereich, den ich gerne betrachten möchte, ist, wenn es eine Möglichkeit gibt, RAM -Speicherreduzierung durch Cupy -Memmaps zu haben. Bisher verwenden sie genauso viel Gedächtnis wie die Live -Versionen.
ModelFactory ( model_variable , total_classes , embed_dimension , datatype = 'float32' , CPUPinn = False )Erstellt Switcher für Modellvariablen mit Cupy. Schaltet Variablen aus Ihrer vollständigen Einbettungssammlung und Ihrer Modell -Batch -Sammlung aus. Jede Variable benötigt einen eigenen Switcher.
Beispiel:
uEmbed_switcher = SpeedTorch . ModelFactory ( skip_gram_modelSparse . u_embeddings , total_classes = 50000 , embed_dimension = 128 )Argumente:
model_variable : spezifische Variable aus Ihrem Modell, für die Sie einen Switcher erstellen möchten.
total_classes : Die Gesamtmenge der zu trainierenden Einbettungen.
embed_dimension : Dimension der Einbettungen.
datatype (optional): Datentyp für die Variable. Standard ist 'float32'.
CPUPinn (optional): Stecken Sie Ihre vollständige Einbettungssammlung in CPU. Spares GPU -Speicher, aber die Datenübertragung ist langsamer. Standard ist falsch.
Methoden:
zerosInit() : Initialisiert die variable Switcher Full Collection mit Nullen:
uniformDistributionInit(low, high) : Initialisiert die variable Switcher Vollkollektion mit einer gleichmäßigen Verteilung von low bis high
normalDistributionInit(mean, stdDev) : Initialisiert die variable Switcher -Sammlung mit einer Normalverteilung mit einem Mittelwert des mean und einer Standardabweichung von stdDev
variableTransformer( batchSize, posPerBatch, negPerBatch = None ) : Legt einen Dummy -Eingang ein, der für den Vorwärtsschritt Ihres Modells verwendet werden soll. batchSize hat die Größe Ihrer Charge, und posPerBatch ist die Anzahl der positiven Beispiele pro Stapel. Wenn für die negativen Beispiele ein zweiter Dummy -Eingang benötigt wird, kann negPerBatch (optional) auf die Anzahl der negativen Beispiele eingestellt werden, und zwei Dummy -Eingänge werden anstelle eines zurückgegeben.
beforeForwardPass(retrievedPosIndexes , retrievedNegIndexes = None) : Schalter Einbettung von der vollständigen Einbettungssammlung bis zu Ihrem Modell -Einbettungsdings. retrievedPosIndexes sind die Indizes der positiven Proben, die abgerufen werden sollen. Wenn ebenfalls negative Proben abgerufen werden sollen, kann auch ein Wert für retrievedNegIndexes (optionale) übergeben werden.
afterOptimizerStep( retrievedPosIndexes , retrievedNegIndexes = None) : Switches Aktualisierte Einbettungen von Ihrem Modell bis zur vollständigen Einbettungssammlung. retrievedPosIndexes sind die Indizes der positiven Proben, die abgerufen wurden. Wenn auch negative Proben abgerufen wurden, kann auch ein Wert für retrievedNegIndexes (optionale) Wert übergeben werden.
saveCupy(saveFileName) : Save Tensor in .npy -Datei speichern.
loadCupy(loadFileName) : Tensor aus .npy laden.
getNumpyVersion : Holen Sie sich die Numpy -Version von Tensor.
OptimizerFactory( given_optimizer, total_classes, embed_dimension, model, variable_name, dtype='float32' , CPUPinn = False)
Erstellt Switcher für Optimierervariablen mit Cupy. Schaltet Variablen aus Ihrer vollständigen Einbettungssammlung und Ihrer Optimierer -Stapelsammlung aus. Jede Variable benötigt einen eigenen Switcher.
Beispiel:
uAdagrad_switcher = SpeedTorch . OptimizerFactory ( given_optimizer , total_classes , embed_dimension , model , variable_name , dtype = 'float32' , CPUPinn = False )Argumente:
given_optimizer : Der mit Ihren Modellgewichten initialisierte Optimierer. Wenn Sie für das Ausbettungstraining verwendet werden, sollten Sie den sparse Parameter auf False festlegen. Derzeit sind unterstützte Optimierer Sparseadam, Adadelta, Adamax, Adam, Adamw, ASGD und RMSProp. RPROP ist ebenfalls eingebaut, benötigt jedoch den ersten Vorwärtspass und loss.backward() . Dies ist auf den RPROP -Optimierer zurückzuführen, der Gradienten seiner Parameter für die Initialisierung benötigt.
total_classes : Die Gesamtmenge der zu trainierenden Einbettungen.
embed_dimension : Dimension der Einbettungen.
model : Die Instanz Ihres Modells.
variable_name : Genauer Name der in Ihrem Modell definierten Variablen.
dtype (optional): Datentyp Ihrer Variablen. Standard ist 'Float32'
CPUPinn (optional): Stecken Sie Ihre vollständige Optimierer -Variable -Gewicht -Sammlung auf CPU. Spares GPU -Speicher, aber die Datenübertragung ist langsamer. Standard ist falsch.
Methoden:
optInit : Initialisiert den Optimierer -Variablen -Switcher.
beforeForwardPass(retrievedPosIndexes , retrievedNegIndexes = None) : Schaltet die Optimierer -Variablengewichte von der vollständigen Gewichtssammlung zum Optimierer -Gewicht Tensor. retrievedPosIndexes sind die Indizes der positiven Proben, die abgerufen werden sollen. Wenn ebenfalls negative Proben abgerufen werden sollen, kann auch ein Wert für retrievedNegIndexes (optionale) übergeben werden.
afterOptimizerStep( retrievedPosIndexes , retrievedNegIndexes = None) : Schaltet die Optimierer -Variablengewichte von Ihrem Optimierer auf die vollständige Gewichtssammlung um. retrievedPosIndexes sind die Indizes der positiven Proben, die abgerufen wurden. Wenn auch negative Proben abgerufen wurden, kann auch ein Wert für retrievedNegIndexes (optionale) Wert übergeben werden.
Erstellt einen Tensor, dessen Hauptfunktion darin besteht, seinen Inhalt auf eine Pytorch -CUDA -Variable zu übertragen.
DataGadget( fileName, CPUPinn=False)
Argumente:
fileName : Speicherort der zu öffnenden Dateidateien.
CPUPinn : (Optional): Stecken Sie Ihre Daten in CPU. Standard ist falsch.
Methoden:
getData(indexes) : Ruft Daten in einem Format ab, das von einer Pytorch -CUDA -Variablen akzeptiert werden kann. indexes sind die Indizes des Tensors, aus dem Daten abgerufen werden können.
insertData(dataObject, indexes) : Daten aus einer Pytorch -CUDA -Variable einfügen. dataObject ist die Pytorch -CUDA -Variablen -Tensor -Daten, aus denen die Daten ausgeschrieben werden sollen, und indexes des Tensors, aus dem Daten abgerufen werden können.
saveCupy(saveFileName) : Save Tensor in .npy -Datei speichern.
loadCupy(loadFileName) : Laden Sie einen neuen Tensor aus .NPY -Datei.
getNumpyVersion : Holen Sie sich die Numpy -Version von Tensor.
Bitte beachten Sie dieses Notizbuch zur Verwendung des Datengerichts
https://colab.research.google.com/drive/185z5gi62azxh-eemfrttjqxeifHOBXXF
PytorchModelFactory ( model_variable , total_classes , embed_dimension , datatype = 'float32' , deviceType = 'cuda' , pinType = False )Erstellt Schalter für Modellvariablen mithilfe von Pytorch -Tensoren. Schaltet Variablen aus Ihrer vollständigen Einbettungssammlung und Ihrer Modell -Batch -Sammlung aus. Jede Variable benötigt einen eigenen Switcher.
Beispiel:
uEmbed_switcher = SpeedTorch . PytorchModelFactory ( skip_gram_modelSparse . u_embeddings , total_classes = 50000 , embed_dimension = 128 )Argumente:
model_variable : spezifische Variable aus Ihrem Modell, für die Sie einen Switcher erstellen möchten.
total_classes : Die Gesamtmenge der zu trainierenden Einbettungen.
embed_dimension : Dimension der Einbettungen.
datatype (optional): Datentyp für die Variable. Standard ist 'float32'.
deviceType (optional): Setzen Sie das Gerät entweder auf 'CUDA' oder 'CPU'. Standard ist 'Cuda'
pinType (optional): Wenn das Gerät auf 'CPU' eingestellt ist, können Sie mit dem Pined -Speicher angeben. Standard ist "falsch".
Methoden:
zerosInit() : Initialisiert die variable Switcher Full Collection mit Nullen:
uniformDistributionInit(low, high) : Initialisiert die variable Switcher Vollkollektion mit einer gleichmäßigen Verteilung von low bis high
normalDistributionInit(mean, stdDev) : Initialisiert die variable Switcher -Sammlung mit einer Normalverteilung mit einem Mittelwert des mean und einer Standardabweichung von stdDev
customInit(initFunction, *args) : Verwenden Sie einen beliebigen Pytorch -Initialisierer für die variable Switchers Vollständige Sammlung. Übergeben Sie den Initialisierer mit initFunction und seinen entsprechenden Argumenten mit *args .
variableTransformer(batchSize, posPerBatch, negPerBatch = None ) : Legt einen Dummy -Eingang ein, der für den Vorwärtsschritt Ihres Modells verwendet werden soll. batchSize hat die Größe Ihrer Charge, und posPerBatch ist die Anzahl der positiven Beispiele pro Stapel. Wenn für die negativen Beispiele ein zweiter Dummy -Eingang benötigt wird, kann negPerBatch (optional) auf die Anzahl der negativen Beispiele eingestellt werden, und zwei Dummy -Eingänge werden anstelle eines zurückgegeben.
beforeForwardPass(retrievedPosIndexes , retrievedNegIndexes = None) : Schalter Einbettung von der vollständigen Einbettungssammlung bis zu Ihrem Modell -Einbettungsdings. retrievedPosIndexes sind die Indizes der positiven Proben, die abgerufen werden sollen. Wenn ebenfalls negative Proben abgerufen werden sollen, kann auch ein Wert für retrievedNegIndexes (optionale) übergeben werden.
afterOptimizerStep(retrievedPosIndexes , retrievedNegIndexes = None) : Switches Aktualisierte Einbettungen von Ihrem Modell bis zur vollständigen Einbettungssammlung. retrievedPosIndexes sind die Indizes der positiven Proben, die abgerufen wurden. Wenn auch negative Proben abgerufen wurden, kann auch ein Wert für retrievedNegIndexes (optionale) Wert übergeben werden.
saveTorch(saveFileName) : Save Tensor in Datei mit TORCH.SAVE speichern
loadTorch(loadFileName) : Tensor mit Taschenlast laden.load
getNumpyVersion : Holen Sie sich die Numpy -Version von Tensor.
PytorchOptimizerFactory( given_optimizer, total_classes, embed_dimension, model, variable_name, dtype='float32', deviceType = 'cuda', pinType = False)
Erstellt Switcher für Optimierervariablen mithilfe von Pytorch -Tensoren. Schaltet Variablen aus Ihrer vollständigen Einbettungssammlung und Ihrer Optimierer -Stapelsammlung aus. Jede Variable benötigt einen eigenen Switcher.
Beispiel:
uAdagrad_switcher = SpeedTorch . PytorchOptimizerFactory ( given_optimizer , total_classes , embed_dimension , model , variable_name , dtype = 'float32' )Argumente:
given_optimizer : Der mit Ihren Modellgewichten initialisierte Optimierer. Wenn Sie für das Ausbettungstraining verwendet werden, sollten Sie den sparse Parameter auf False festlegen. Derzeit sind unterstützte Optimierer Sparseadam, Adadelta, Adamax, Adam, Adamw, ASGD und RMSProp. RPROP ist ebenfalls eingebaut, benötigt jedoch den ersten Vorwärtspass und loss.backward() . Dies ist auf den RPROP -Optimierer zurückzuführen, der Gradienten seiner Parameter für die Initialisierung benötigt.
total_classes : Die Gesamtmenge der zu trainierenden Einbettungen.
embed_dimension : Dimension der Einbettungen.
model : Die Instanz Ihres Modells.
variable_name : Genauer Name der in Ihrem Modell definierten Variablen.
dtype (optional): Datentyp Ihrer Variablen. Standard ist 'Float32'
deviceType (optional): Setzen Sie das Gerät entweder auf 'CUDA' oder 'CPU'. Standard ist 'Cuda'
pinType (optional): Wenn das Gerät auf 'CPU' eingestellt ist, können Sie mit dem Pined -Speicher angeben. Standard ist "falsch".
Methoden:
optInit : Initialisiert den Optimierer -Variablen -Switcher.
beforeForwardPass(retrievedPosIndexes , retrievedNegIndexes = None) : Schaltet die Optimierer -Variablengewichte von der vollständigen Gewichtssammlung zum Optimierer -Gewicht Tensor. retrievedPosIndexes sind die Indizes der positiven Proben, die abgerufen werden sollen. Wenn ebenfalls negative Proben abgerufen werden sollen, kann auch ein Wert für retrievedNegIndexes (optionale) übergeben werden.
afterOptimizerStep( retrievedPosIndexes , retrievedNegIndexes = None) : Schaltet die Optimierer -Variablengewichte von Ihrem Optimierer auf die vollständige Gewichtssammlung um. retrievedPosIndexes sind die Indizes der positiven Proben, die abgerufen wurden. Wenn auch negative Proben abgerufen wurden, kann auch ein Wert für retrievedNegIndexes (optionale) Wert übergeben werden.
Wenn Sie SpeedTorch in Ihrer Recherche verwenden oder zitieren möchten, zitieren Sie bitte mit:
@misc {
Titel = {SpeedTorch},
Autor = {Santosh Gupta},
HowPubliered = { url {github.com/santosh-gupta/speedtorch}},
Jahr = {2019}
}
