Bytedance-Modell groß angelegter Einsatz im tatsächlichen Kampf

1. Einführung in den Hintergrund

In ByteDance florieren Anwendungen, die auf Deep Learning basieren, während sich Ingenieure zunächst auf die Konsistenz und Leistung von Online-Diensten konzentrieren Normalerweise ist eine Arbeitsteilung zwischen Algorithmenexperten und Ingenieurexperten erforderlich. Dieser Modus ist mit relativ hohen Kosten verbunden, z. B. für die Fehlerbehebung und Überprüfung.

Mit der Popularität des PyTorch/TensorFlow-Frameworks wurden Deep-Learning-Modelltraining und Online-Inferenz vereinheitlicht. Entwickler müssen nur noch auf die spezifische Algorithmuslogik achten und die Python-API des Frameworks aufrufen, um den Trainingsüberprüfungsprozess abzuschließen Das Modell kann problemlos sequenziell exportiert werden, und die Argumentationsarbeit wird durch eine einheitliche leistungsstarke C++-Engine vervollständigt. Verbesserte Entwicklererfahrung von der Schulung bis zur Bereitstellung.

Allerdings verfügt ein vollständiger Dienst normalerweise noch über eine Menge Geschäftslogik wie Vorverarbeitung/Nachverarbeitung. Diese Art von Logik verarbeitet normalerweise verschiedene Eingaben in Tensoren und gibt sie dann in den Ausgabetensor des Modells ein im Zielformat verarbeitet wird, sind einige typische Szenarien wie folgt:

• Bert
• Resnet

Unser Ziel ist es, automatisierte und einheitliche Trainings- und Inferenzlösungen für den oben genannten End-to-End-Prozess bereitzustellen , und erleichtern Sie die manuelle Entwicklung des Inferenzprozesses, Ausrichtungsunterschiede und eine Reihe anderer Probleme, um eine umfassende, einheitliche Bereitstellungslösung zu erreichen.

2. Kernprobleme

PyTorch/TensorFlow und andere Frameworks haben das Problem des einheitlichen Modelltrainings/der Inferenz relativ gelöst, sodass die Modellberechnung selbst nicht das Problem der Integration von Training und Inferenz aufweist (die Optimierung der Operatorleistung liegt nicht im Rahmen). dieser Diskussion).

Das zu lösende Kernproblem besteht darin, dass Vor- und Nachverarbeitung eine leistungsstarke Trainings- und Push-Integrationslösung bereitstellen müssen.

Für diese Art von Logik stellt TensorFlow 2.x tf.function bereit (noch nicht vollständig) und PyTorch stellt TorchScript bereit, das ausnahmslos eine Teilmenge der nativen Python-Syntax auswählt. Aber auch wenn es so leistungsstark ist, gibt es immer noch Probleme, die nicht ignoriert werden können:

• Leistung: Der größte Teil dieser Lösung basiert auf der Implementierung virtueller Maschinen. Die virtuelle Maschinenlösung ist flexibel und sehr kontrollierbar, die meisten virtuellen Maschinen basieren jedoch auf Deep Learning Frameworks haben normalerweise keine ausreichend gute Leistung. Als Ergänzung wurde das Framework in den Anfängen für Tensor-Computing entwickelt. Die Kosten für jeden Operator beim Array-Computing sind sehr hoch, und die Kosten für den Versand und die Planung virtueller Maschinen können ignoriert werden. Allerdings ist der Mehraufwand bei der Portierung auf die Programmiersprachenprogrammierung schwer zu ignorieren, und das Schreiben von zu viel Code führt zu einem Leistungsengpass. Laut Tests beträgt die Leistung des TorchScript-Interpreters nur etwa 1/5 der von Python, und die Leistung von tf.function ist sogar noch schlechter.
• Unvollständige Funktionen: Tatsächlich können wir bei der Anwendung auf reale Szenarien immer noch viele wichtige Funktionen finden, die tf.function/TorchScript nicht unterstützt. Beispielsweise können benutzerdefinierte Ressourcen nicht gepackt werden und können nur integrierte Zeichenfolgen serialisieren Nur bei der Byte-Verarbeitung führt Unicode wie Chinesisch zu Diff; der Container muss isomorph sein und unterstützt keine benutzerdefinierten Typen usw.

Darüber hinaus gibt es viele nicht tiefe Lernaufgaben, wie zum Beispiel noch viele Nicht-Deep-Learning-Aufgaben in der Verarbeitung natürlicher Sprache Anwendungen oder Teilaufgaben des Deep Learning, wie z. B. Sequenzannotation, Sprachmodelldekodierung, künstliche Merkmalskonstruktion von Baummodellen usw. Diese verfügen normalerweise über flexiblere Merkmalsparadigmen, verfügen aber gleichzeitig über flexiblere Merkmalsparadigmen Es gibt noch viel Entwicklungs- und Korrektheitsüberprüfungsarbeit.

Um die oben genannten Probleme zu lösen, haben wir eine kompilierungsbasierte Vorverarbeitungslösung entwickelt: MATXScript!

3. MATXScript

Bei der Entwicklung von Deep-Learning-Algorithmen verwenden Entwickler normalerweise Python für schnelle Iterationen und Experimente, während C++ zur Entwicklung leistungsstarker Online-Dienste verwendet wird, bei denen die Korrektheitsüberprüfung und die Dienstentwicklung zu einer größeren Belastung werden!

MatxScript (https://github.com/bytedance/matxscript) ist ein AOT-Compiler für die Python-Subsprache, der Python automatisch in C++ übersetzen und Paketierungs- und Veröffentlichungsfunktionen mit einem Klick bereitstellen kann. Durch die Verwendung von MATXScript können Entwickler Modelle schnell iterieren und gleichzeitig leistungsstarke Dienste zu geringeren Kosten bereitstellen.

Die Kernarchitektur ist wie folgt:

• Die unterste Ebene ist eine reine C++/CUDA-Basisbibliothek, die von leistungsstarken Operator-Experten entwickelt wurde.
• Zusätzlich zur Basisbibliothek ist die Python-Bibliothek gemäß der Konvention gekapselt und kann im Trainingsprozess verwendet werden.
• Wenn Rückschlüsse erforderlich sind, kann MATXScript verwendet werden, um den Python-Code in den entsprechenden C++-Code zu übersetzen, ihn in eine dynamische Linkbibliothek zu kompilieren, das Modell und andere abhängige Ressourcen hinzuzufügen und ihn zusammen zu verpacken und zu veröffentlichen.

Unter diesen ist die Rolle des Compilers sehr wichtig, und sein Kernprozess ist wie folgt:

Durch den obigen Prozess kann der vom Benutzer geschriebene Vorverarbeitungscode in einem JitOp in der Pipeline kompiliert werden. Um die Vor- und Nachbearbeitung mit dem Modell zu verknüpfen, haben wir außerdem ein Tracing-System entwickelt (das Interface-Design bezieht sich auf PyTorch), mit folgender Architektur:

Basierend auf MATXScript können wir dasselbe verwenden Codesatz für Training und Inferenz, was die Kosten für die Modellbereitstellung erheblich senkt. Gleichzeitig sind Architektur und Algorithmus entkoppelt, und Algorithmenstudenten können sich vollständig auf die Compilerentwicklung und Laufzeitoptimierung konzentrieren. Diese Lösung wurde durch eine groß angelegte Bereitstellung überprüft.

4. Ein kleiner Test

Hier nehmen wir die einfachste englische Textvorverarbeitung als Beispiel, um zu zeigen, wie man MATXScript verwendet.

Ziel: Einen englischen Text in Indizes umwandeln

1. Eine grundlegende Wörterbuchsuchlogik schreiben

class Text2Ids:
def __init__(self) -> None:
self.table: Dict[str, int] = {
"hello": 0,
"world": 1,
"[UNK]": 2,
}

def lookup(self, word: str)
return self.table.get(word, 2)

def__call__ (self, words: List[str])
return [self.lookup(w) for w in words]

2. Pipeline schreiben

import matx

class WorkFlow:
def __init__(self):
# 此处会进行代码编译，Python 代码自动编译封装为 Callable 对象
self.text2ids = matx.script(Text2Ids)()

def process(self, texts):
ids = self.text2ids(texts)
return ids

# test
handler = WorkFlow()
print(handler.process("hello world unknown"))
# output: [0, 1, 2]

3. Trace-Export auf die Festplatte

# dump
mod = matx.trace(handler.process, "hello world")
print(mod.run({"texts": "hello world"}))
mod.save('./my_dir')
# load
mod = matx.load('./my_dir', -1)
print(mod.run({"texts": "hello world"}))

4. C++ laden

#include <string>
#include <vector>
#include <map>
#include <iostream>
#include <matxscript/pipeline/tx_session.h>
using namespace ::matxscript::runtime;
int main()
{
// test case
std::unordered_map<std::string, RTValue> feed_dict;
feed_dict.emplace("texts", Unicode(U"hello world"));
std::vector<std::pair<std::string, RTValue>> result;
const char* module_path = "./my_dir";
const char* module_name = "model.spec.json";
{
// -1 mean cpu
auto sess = TXSession::Load(module_path, module_name, -1);
auto result = sess->Run(feed_dict);
for (auto& r : result) {
std::cout << "key: " << r.first << ", value: " << r.second << std::endl;
}
}
return 0;
}

Schließen Sie das ab Code finden Sie unter: https://github.com/bytedance/matxscript/tree/main/examples/text2ids

Zusammenfassung: Das Obige ist eine sehr einfache Vorverarbeitungslogik, die in reinem Python implementiert ist und von einem allgemeinen C++ geladen werden kann Code ausführen, kombinieren wir das Modell, um einen tatsächlichen multimodalen End-to-End-Fall zu zeigen!

5. Multimodaler Fall

Hier nehmen wir Grafik- und Text-Multimodal (Bert+Resnet) als Beispiel. Das Modell wurde mit PyTorch geschrieben, um die tatsächliche Arbeit in Training und Bereitstellung zu zeigen.

1. Konfigurieren Sie die Umgebung
   a. Konfigurieren Sie die Infrastruktur wie gcc/cuda (normalerweise haben dies die Betriebs- und Wartungsstudenten bereits getan)
   b Installieren Sie MATXScript und darauf basierende Basisbibliotheken (Text, Vision usw.)
2. Schreiben Sie Modellcode
   a. Sie können auf Papiere oder andere Open-Source-Implementierungen zurückgreifen, um dies selbst zu tun. Schreiben Sie einen Vorverarbeitungscode
a. TextPipeline kann als normale Python-Klasse verwendet werden. Stellen Sie einfach eine Verbindung zum Datensatz her.
3. b. VisionPipeline erfordert eine GPU-Vorverarbeitung und ist besser für die Stapelverarbeitung geeignet. Sie müssen einen DataLoader separat erstellen Quelle ByteDances interner Multithread-DataLoader später)

Hinzufügen Modellcode hochladen und mit dem Training beginnen

End-to-End-Inferenzmodell exportieren

from typing import List, Dict, Tuple
import libcut
import matx
class Vocabulary:
...
def utf8_decoder(s: List[bytes]):
return [x.decode() for x in s]
class TextNDArrayBuilder:
...
class TextPipeline:
def __init__(self, mode: str = "eval"):
self.mode = mode
self.cut_engine = libcut.Cutter('/path/to/cut_models', ...)
self.vocab = matx.script(Vocabulary)('/path/to/vocab.txt')
self.decoder = matx.script(utf8_decoder)
self.input_builder = matx.script(TextNDArrayBuilder)(self.vocab)
def process(self, text: List[bytes]):
# List[bytes] 是对齐 C++ 的 vector<string>
text: List[str] = self.decoder(text)
words: List[List[str]] = self.cut_engine(text)
batch_ids: List[List[int]] = self.vocab(words)
input_ids, segment_ids, mask_ids = self.input_builder(batch_ids, 32)
if self.mode == "train":
return input_ids.torch(), segment_ids.torch(), mask_ids.torch()
return input_ids, segment_ids, mask_ids

Zusammenfassung: Nach den obigen Schritten können wir das Ende-zu-Ende abschließen Schulungs- und Release-Arbeiten, und der gesamte Prozess wird mit reinem Python-Code abgeschlossen und kann vollständig von den Algorithmusstudenten selbst gesteuert werden. Sollte es bei der Modellberechnung selbst zu Leistungsproblemen kommen, kann diese natürlich auch hinter den Kulissen durch automatische Bildmodifikation und -optimierung erledigt werden.
4. 
   Hinweis: Vollständige Codebeispiele finden Sie unter https://github.com/bytedance/matxscript/tree/main/examples/e2e_multi_modal
   
6. Im letzten Kapitel haben wir ein Modellpaket von einem veröffentlicht Algorithmus-Student: In diesem Kapitel wird erläutert, wie ein einheitlicher Dienst geladen und ausgeführt wird.
Der komplette Server umfasst: IDL-Protokoll, Stapelstrategie, Thread-/Thread-Planung und -Anordnung, Modellbegründung ...
Hier besprechen wir nur die Modellbegründung, der Rest kann wie vereinbart entwickelt werden. Wir verwenden eine Hauptfunktion, um den Prozess des Ladens und Ausführens eines Modells zu veranschaulichen:

from typing import List, Dict, Tuple
import matx
from matx import vision
class VisionPipeline:
def __init__(self,
 device_id: int = 0,
 mode: str = "eval",
 image_size: int = 224,):
self.is_training = mode == 'train'
self.mode = mode
...
def process(self, image,):
if self.is_training:
decode_nds = self.random_crop_decode(image)
flip_nds = self.random_flip(decode_nds)
resize_nds = self.resize(flip_nds)
transpose_nd = self.transpose_norm(resize_nds, vision.SYNC)
else:
decode_nds = self.decode(image)
resize_nds = self.resize(decode_nds)
crop_nds = self.center_crop(resize_nds)
transpose_nd = self.transpose_norm(crop_nds, vision.SYNC)
if self.mode == "trace":
return transpose_nd
return transpose_nd.torch()

Der obige Code ist der einfachste Fall des Ladens eines multimodalen Modells in C++. Für Studenten, die Server entwickeln, müssen sie nur einfache Abstraktionen und Konventionen erstellen . Der obige Code kann in ein einheitliches C++-Modelldienst-Framework umgewandelt werden.

VII. Weitere Informationen

Wir sind das Bytedance-AML-Machine-Learning-System-Team, das sich dafür einsetzt, dem Unternehmen ein einheitliches, leistungsstarkes integriertes Framework für Schulung und Förderung bereitzustellen und auch die Zusammenarbeit über die Volcano Engine-Plattform für maschinelles Lernen zu unterstützen Für Unternehmen wird erwartet, dass die maschinelle Lernplattform Volcano Engine ab 2023 MATX-bezogene Unterstützung bietet, einschließlich voreingestellter Spiegelumgebungen, öffentlicher Beispiele gängiger Szenarien, technischer Unterstützung beim Unternehmenszugriff und bei der Nutzung usw., wodurch kostengünstige Schulungen und Schlussfolgerungen erzielt werden können Beschleunigungs- und Integrationseffekte. Willkommen, um mehr über unsere Produkte unter https://www.volcengine.com/product/ml-platform zu erfahren.

Das obige ist der detaillierte Inhalt vonBytedance-Modell groß angelegter Einsatz im tatsächlichen Kampf. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!