PyTorch-Modelle am Edge ausführen

Die meisten modernen ML-Modelle werden mit PyTorch entwickelt. Die Agilität und Flexibilität, die PyTorch für die Erstellung und das Training von Modellen bietet, hat es zum beliebtesten Deep-Learning-Framework von heute gemacht. Der typische Workflow besteht darin, diese Modelle in der Cloud zu trainieren und sie auch von dort auszuführen. Es gibt jedoch viele Szenarien, die es attraktiver – oder in einigen Fällen sogar zwingend erforderlich – machen, lokal auf Geräten auszuführen. Dazu gehören:

• Vermeidung von Netzwerkrückschleifen zur Cloud (z. B. bei der Audio- und Videoverarbeitung)
• Speicherung von Benutzerdaten auf dem Gerät (zum Schutz der Privatsphäre oder aufgrund gesetzlicher Vorschriften)
• Hohe Kosten für Cloud-Ressourcen (insbesondere wenn die Gerätefähigkeiten unterausgelastet sind)
• Anwendungsanforderungen für den Betrieb ohne Internetverbindung

In diesem Artikel werden wir das Ausführen von PyTorch-Modellen am Edge entmystifizieren. Wir definieren „Edge“ als überall außerhalb der Cloud, von großen, gut ausgestatteten PCs bis hin zu kleinen Geräten wie Mobiltelefonen. Dies war in der Vergangenheit eine herausfordernde Aufgabe, aber neue Fortschritte bei der Modelloptimierung und Software wie ONNX Runtime machen es machbarer – selbst für neue generative KI- und große Sprachmodelle wie Stable Diffusion, Whisper und Llama2.

Überlegungen zu PyTorch-Modellen am Edge

Es gibt mehrere Faktoren zu beachten, wenn man über die Ausführung eines PyTorch-Modells am Edge nachdenkt:

• Größe: Moderne Modelle können mehrere Gigabyte umfassen (daher der Name Large Language Models!). In der Cloud ist die Größe normalerweise keine Überlegung, bis sie zu groß wird, um auf eine einzelne GPU zu passen. Dann gibt es verschiedene bekannte Lösungen für die Ausführung über mehrere GPUs hinweg. Für Edge-Geräte müssen wir Modelle finden, die in die Beschränkungen des Geräts passen. Dies erfordert manchmal einen Kompromiss bei der Qualität. Die meisten modernen Modelle gibt es in verschiedenen Größen (1 Milliarde Parameter, 13 Milliarden Parameter, 70 Milliarden Parameter usw.), sodass Sie eine Variante auswählen können, die auf Ihr Gerät passt. Techniken wie Quantisierung werden normalerweise angewendet, um die Anzahl der Bits zu reduzieren, die Parameter darstellen, was die Modellgröße weiter reduziert. Die Größe der Anwendung ist auch durch die App-Stores eingeschränkt, daher sind Gigabyte an Bibliotheken am Edge nicht praktikabel.
• API für die Anwendungsintegration: In der Cloud werden Modelle normalerweise als Docker-Container verpackt, die einen Endpunkt bereitstellen, der von einer Anwendung oder einem Dienst aufgerufen wird. Auf Edge-Geräten können Docker-Container zu viele Ressourcen beanspruchen oder werden möglicherweise nicht einmal unterstützt. Durch die Verwendung einer optimierten Engine wie ONNX Runtime kann die Abhängigkeit von Python und Docker-Containern eliminiert werden. ONNX Runtime verfügt außerdem über APIs in vielen Sprachen, darunter C, C++, C#, Rust, Java, JavaScript, Objective-C und Swift, um die Integration mit der Hosting-Anwendung zu erleichtern.
• Leistung: Mit großen Speichermengen, keinen Strombeschränkungen und erheblichen Rechenkapazitäten ist die Ausführung nicht optimierter Modelle in der Cloud möglich. Auf Edge-Geräten existieren diese Luxusgüter nicht, und Optimierung ist entscheidend. ONNX Runtime optimiert beispielsweise Speicherzuweisungen, fusioniert Modelloperatoren, reduziert Kernel-Startzeiten, minimiert Tensor-Übertragungen zwischen Verarbeitungseinheiten und wendet optimierte Matrix-Rechenalgorithmen an. Es kann auch gerätespezifische Compiler und Engines nutzen und bietet eine gemeinsame Schnittstelle für Ihre Anwendung, während es gleichzeitig den besten Ansatz auf jedem Gerät nutzt.
• Wartbarkeit: In der Cloud ist die Aktualisierung eines Modells so einfach wie die Bereitstellung eines neuen Container-Images und die Erhöhung des Datenverkehrs. Am Edge müssen Sie überlegen, wie Sie Modellaktualisierungen verteilen werden. Manchmal bedeutet dies die Veröffentlichung von Updates in einem App-Store, manchmal ist es möglicherweise möglich, einen Datenaktualisierungsmechanismus innerhalb Ihrer App zu implementieren und neue Modelldateien oder sogar Deltas herunterzuladen. Es gibt viele mögliche Wege, daher werden wir in diesem Artikel nicht tief auf dieses Thema eingehen, aber es ist ein Aspekt, den Sie bei der Produktionsplanung berücksichtigen sollten.
• Hybrid: Anstatt Cloud versus Gerät können Sie sich entscheiden, beide zu nutzen. Es gibt mehrere Hybridmuster, die heute von Anwendungen wie Office in der Produktion verwendet werden. Ein Muster besteht darin, dynamisch zu entscheiden, ob auf dem Gerät oder in der Cloud ausgeführt werden soll, basierend auf Netzwerkbedingungen oder Eingabeeigenschaften. Ein weiteres Muster ist die Ausführung eines Teils der Modellpipeline auf dem Gerät und eines Teils in der Cloud. Dies ist besonders nützlich bei modernen Modellpipelines, die separate Encoder- und Decoder-Stufen haben. Die Verwendung einer Engine wie ONNX Runtime, die sowohl in der Cloud als auch auf Geräten funktioniert, vereinfacht die Entwicklung. Wir werden Hybrid-Szenarien in einem zukünftigen Artikel ausführlicher diskutieren.
• Personalisierung: In vielen Fällen wird das PyTorch-Modell einfach auf dem Gerät ausgeführt. Möglicherweise gibt es jedoch auch Szenarien, in denen Sie das Modell auf dem Gerät personalisieren müssen, ohne Daten an die Cloud zu senden. Empfehlungs- und Zielgruppenansprache sind Beispiel-Szenarien, die ihre Qualität durch die Aktualisierung von Modellen basierend auf Aktivitäten auf dem Gerät verbessern können. Fine-Tuning und Training mit PyTorch auf dem Gerät sind möglicherweise nicht machbar (aufgrund von Leistungs- und Größenbedenken), aber die Verwendung einer Engine wie ONNX Runtime ermöglicht die lokale Aktualisierung und Personalisierung von PyTorch-Modellen. Derselbe Mechanismus ermöglicht auch das föderierte Lernen, was die Exposition von Benutzerdaten mindern kann.

Werkzeuge für PyTorch-Modelle am Edge

Wir haben mehrfach ONNX Runtime erwähnt. ONNX Runtime ist eine kompakte, standardbasierte Engine, die tief in PyTorch integriert ist. Durch die Verwendung der ONNX-APIs von PyTorch können Ihre PyTorch-Modelle mit ONNX Runtime auf einer Reihe von Edge-Geräten ausgeführt werden.

Der erste Schritt zur Ausführung von PyTorch-Modellen am Edge besteht darin, sie in ein leichtgewichtiges Format zu bringen, das das PyTorch-Framework und seine Gigabytes an Abhängigkeiten nicht benötigt. PyTorch hat dies berücksichtigt und enthält eine API, die genau dies ermöglicht – torch.onnx. ONNX ist ein offener Standard, der die Operatoren definiert, aus denen Modelle bestehen. Die PyTorch ONNX APIs nehmen den Python-Code von PyTorch und wandeln ihn in einen funktionalen Graphen um, der die für die Ausführung des Modells ohne Python benötigten Operatoren erfasst. Wie bei allem im Bereich maschinelles Lernen gibt es einige Einschränkungen zu beachten. Einige PyTorch-Modelle können nicht als einzelner Graph dargestellt werden – in diesem Fall müssen Sie möglicherweise mehrere Graphen ausgeben und diese in Ihrer eigenen Pipeline zusammensetzen.

Die beliebte Hugging Face-Bibliothek verfügt ebenfalls über APIs, die auf dieser torch.onnx-Funktionalität aufbauen, um Modelle in das ONNX-Format zu exportieren. Über 130.000 Modelle werden unterstützt, was bedeutet, dass das Modell, das Sie interessiert, sehr wahrscheinlich eines davon ist.

In diesem Artikel zeigen wir Ihnen mehrere Beispiele mit hochmodernen PyTorch-Modellen (wie Whisper und Stable Diffusion) auf beliebten Geräten (wie Windows-Laptops, Mobiltelefonen und Webbrowsern) über verschiedene Sprachen (von C# über JavaScript bis Swift).

Beispiele für PyTorch-Modelle am Edge

Stable Diffusion unter Windows

Die Stable Diffusion-Pipeline besteht aus fünf PyTorch-Modellen, die ein Bild aus einer Textbeschreibung erstellen. Der Diffusionsprozess iteriert über zufällige Pixel, bis das Ausgabebild der Beschreibung entspricht.

Für die Ausführung am Edge können vier der Modelle von HuggingFace in das ONNX-Format exportiert werden.

from optimum.onnxruntime import ORTStableDiffusionPipeline
pipeline = ORTStableDiffusionPipeline.from_pretrained("CompVis/stable-diffusion-v1-4", export=True)
pipeline.save_pretrained("./onnx-stable-diffusion")

Das fünfte Modell, ClipTokenizer, muss nicht exportiert werden, da es in den ONNX Runtime Extensions verfügbar ist, einer Bibliothek zur Vor- und Nachbearbeitung von PyTorch-Modellen.

Um diese Pipeline von Modellen als .NET-Anwendung auszuführen, erstellen wir den Pipeline-Code in C#. Dieser Code kann auf CPU, GPU oder NPU ausgeführt werden, wenn diese auf Ihrem Rechner verfügbar sind, indem die gerätespezifischen Hardwarebeschleuniger von ONNX Runtime verwendet werden. Dies wird mit dem folgenden ExecutionProviderTarget konfiguriert.

static void Main(string[] args)
{
    var prompt = "Two golden retriever puppies playing in the grass.";
    var config = new StableDiffusionConfig
    {
        NumInferenceSteps = 50,
        GuidanceScale = 7.5,
        ExecutionProviderTarget = StableDiffusionConfig.ExecutionProvider.Cpu,
        DeviceId = 0,
        TokenizerOnnxPath = ".\models\tokenizer\model.onnx",
        TextEncoderOnnxPath = ".\models\text_encoder\model.onnx",
        UnetOnnxPath = ".\models\unet\model.onnx",
        VaeDecoderOnnxPath = ".\models\vae_decoder\model.onnx",
        SafetyModelPath = ".\models\safety_checker\model.onnx",
    };

    var image = UNet.Inference(prompt, config);

    if (image == null)
    {
        Console.WriteLine("Unable to create image, please try again.");
    }
}

Dies ist die Ausgabe der Modellpipeline, die mit 50 Inferenziterationen läuft

Sie können die Anwendung erstellen und unter Windows ausführen, indem Sie die detaillierten Schritte in diesem Tutorial befolgen.

Textgenerierung im Browser

Das lokale Ausführen eines PyTorch-Modells im Browser ist nicht nur möglich, sondern mit der transformers.js-Bibliothek super einfach. Transformers.js verwendet ONNX Runtime Web als Backend. Viele Modelle sind bereits in ONNX konvertiert und werden vom tranformers.js CDN bereitgestellt, sodass die Inferenz im Browser eine Sache von wenigen HTML-Zeilen ist.

<html>
    <body>
        <h1>Enter starting text …</h1>
    
        <form id="form">
            <input type="text" id="inputText">
            <button type="submit" id="submitButton">Submit</button>
        </form>
    
        <div id="output"></div>
    
        <script type="module">
    
            import { pipeline } from 'https://cdn.jsdelivr.net/npm/@xenova/transformers@2.6.2';
    
            let inputText = document.getElementById('inputText');
            let outputDiv = document.getElementById('output');
            let submitButton = document.getElementById('submitButton');
    
            submitButton.addEventListener('click', async (e) => {
    
                e.preventDefault();
    
                let generator = await pipeline('text-generation', 'Xenova/LaMini-Neo-125M');
    
                let result = await generator(inputText.value,
                    { max_new_tokens: 200,
                        temperature: 2,
                        repetition_penalty: 1.5,
                        no_repeat_ngram_size: 2,
                        num_beams: 2,
                        num_return_sequences: 1,
                        });
    
                outputDiv.innerHTML = result[0].generated_text;
            });
        </script>    
    </body>
</html>

Sie können den Aufruf der Transformers-Pipeline auch mit nativem JavaScript oder in einer Webanwendung mit React oder Next.js einbetten oder eine Browsererweiterung schreiben.

ONNX Runtime Web verwendet derzeit WebAssembly, um das Modell auf der CPU auszuführen. Dies ist für viele Modelle in Ordnung, aber die Nutzung der GPU, falls auf dem Gerät vorhanden, kann die Benutzererfahrung verbessern. Die Unterstützung von ONNX Runtime Web für WebGPU kommt *sehr bald* und ermöglicht Ihnen den Zugriff auf die GPU, während Sie dieselben Inferenz-APIs verwenden.

Spracherkennung mit Whisper auf Mobilgeräten

Whisper von OpenAI ist ein PyTorch-Spracherkennungsmodell. Whisper gibt es in verschiedenen Größenvarianten – die kleinste, Whisper Tiny, ist für die Ausführung auf Mobilgeräten geeignet. Alle Komponenten des Whisper Tiny-Modells (Audio-Decoder, Encoder, Decoder und Textsequenzgenerierung) können mithilfe des Olive Frameworks zu einem einzigen ONNX-Modell zusammengesetzt und exportiert werden. Um dieses Modell als Teil einer mobilen Anwendung auszuführen, können Sie ONNX Runtime Mobile verwenden, das Android, iOS, React Native und MAUI/Xamarin unterstützt.

ONNX Runtime Mobile unterstützt Hardwarebeschleunigung über NNAPI (unter Android), CoreML (unter iOS) und XNNPACK (sowohl unter iOS als auch unter Android).

Der relevante Ausschnitt einer Beispiel-Android-Mobilanwendung, die Sprachtranskriptionen für kurze Audioclips durchführt, ist unten dargestellt.

init {
    val env = OrtEnvironment.getEnvironment()
    val sessionOptions = OrtSession.SessionOptions()
    sessionOptions.registerCustomOpLibrary(OrtxPackage.getLibraryPath())

    session = env.createSession(modelBytes, sessionOptions)

    val nMels: Long = 80
    val nFrames: Long = 3000

    baseInputs = mapOf(
        "min_length" to createIntTensor(env, intArrayOf(1), tensorShape(1)),
        "max_length" to createIntTensor(env, intArrayOf(200), tensorShape(1)),
        "num_beams" to createIntTensor(env, intArrayOf(1), tensorShape(1)),
        "num_return_sequences" to createIntTensor(env, intArrayOf(1), tensorShape(1)),
        "length_penalty" to createFloatTensor(env, floatArrayOf(1.0f), tensorShape(1)),
        "repetition_penalty" to createFloatTensor(env, floatArrayOf(1.0f), tensorShape(1)),
    )
}

data class Result(val text: String, val inferenceTimeInMs: Long)

fun run(audioTensor: OnnxTensor): Result {
    val inputs = mutableMapOf()
    baseInputs.toMap(inputs)
    inputs["audio_pcm"] = audioTensor
    val startTimeInMs = SystemClock.elapsedRealtime()
    val outputs = session.run(inputs)
    val elapsedTimeInMs = SystemClock.elapsedRealtime() - startTimeInMs
    val recognizedText = outputs.use {
        @Suppress("UNCHECKED_CAST")
        (outputs[0].value as Array>)[0][0]
    }
    return Result(recognizedText, elapsedTimeInMs)
}

Sie können einen kurzen Audioclip aufnehmen, um ihn zu transkribieren.

Trainieren Sie ein Modell zur Erkennung Ihrer Stimme auf Mobilgeräten

ONNX Runtime kann auch ein vortrainiertes Modell nehmen und es an neue Daten anpassen. Dies kann am Edge geschehen – insbesondere auf Mobilgeräten, wo es einfach ist, Ihre Stimme aufzunehmen, auf Ihre Fotos und andere personalisierte Daten zuzugreifen. Wichtig ist, dass Ihre Daten während des Trainings das Gerät nicht verlassen.

Sie können beispielsweise ein PyTorch-Modell trainieren, um nur Ihre eigene Stimme auf Ihrem Mobiltelefon für Authentifizierungsszenarien zu erkennen.

Das PyTorch-Modell wird in Ihrer Entwicklungsumgebung von HuggingFace bezogen, und zusätzliche Schichten werden hinzugefügt, um die Sprecherklassifizierung durchzuführen.

from transformers import Wav2Vec2ForSequenceClassification, AutoConfig
                    import torch

                    config = AutoConfig.from_pretrained("superb/wav2vec2-base-superb-sid")
                    model = Wav2Vec2ForSequenceClassification.from_pretrained("superb/wav2vec2-base-superb-sid")

                    model.classifier = torch.nn.Linear(256, 2)

Das Modell und andere für das Training notwendige Komponenten (eine Verlustfunktion zur Messung der Qualität des Modells und ein Optimierer zur Steuerung der Gewichtungsanpassung während des Trainings) werden mit ONNX Runtime Training exportiert.

artifacts.generate_artifacts(
    onnx_model,
    requires_grad=requires_grad,
    frozen_params=frozen_params,
    loss=CustomCELoss(),
    optimizer=artifacts.OptimType.AdamW,
    artifact_directory="MyVoice/artifacts",
)

Dieser Satz von Artefakten ist nun bereit, von der mobilen App geladen zu werden, hier gezeigt als iOS Swift-Code. Die App fragt den Benutzer nach Sprachbeispielen, und das Modell wird mit den Beispielen trainiert.

func trainStep(inputData: [Data], labels: [Int64]) throws  {

    let inputs = [try getORTValue(dataList: inputData), try getORTValue(labels: labels)]
    try trainingSession.trainStep(withInputValues: inputs)
    
    try trainingSession.optimizerStep()
    
    try trainingSession.lazyResetGrad()
}

Sobald das Modell trainiert ist, können Sie es ausführen, um zu überprüfen, ob eine Sprachprobe von Ihnen stammt!

Sie können das vollständige Speaker Verification Tutorial lesen und die Anwendung aus dem Quellcode erstellen und ausführen.

Wo geht es weiter?

In diesem Artikel haben wir gezeigt, warum Sie PyTorch-Modelle am Edge ausführen sollten und welche Aspekte zu berücksichtigen sind. Wir haben auch mehrere Beispiele mit Code geteilt, die Sie zum Ausführen von hochmodernen PyTorch-Modellen am Edge mit ONNX Runtime verwenden können. Wir haben auch gezeigt, wie ONNX Runtime für Leistung und plattformübergreifende Ausführung entwickelt wurde, was es zur idealen Lösung für die Ausführung von PyTorch-Modellen am Edge macht. Viel Spaß beim Ausführen von PyTorch-Modellen am Edge mit ONNX Runtime!

Möglicherweise haben Sie bemerkt, dass wir kein Llama2-Beispiel aufgenommen haben, obwohl ONNX Runtime für dessen Ausführung optimiert ist. Das liegt daran, dass das erstaunliche Llama2-Modell einen eigenen Artikel verdient, also bleiben Sie dran!