Es ist spannend zu sehen, wie sich die Welt der KI von Tag zu Tag revolutioniert und immer leistungsfähigere Instruments entwickelt werden. Gleichzeitig gibt es große Herausforderungen Hardwareanforderungen (GPU, TPU, IPU usw.) für das Modelltraining und den Einsatz, was einen enormen Aufwand erfordert Kostenfaktoren Und Latenzprobleme die wir für KI-Systeme in Produktionsqualität angehen müssen. Verschiedene Sätze von KI-Technologien wie Tensorflow, PyTorch und andere haben ihre eigenen Arbeitsabläufe. Denken Sie daran, diese überfüllte KI-Infrastruktur zu skalieren, Modular hat eine Reihe von Produkten auf den Markt gebracht, die Einheitlichkeit in der KI-Entwicklung mit schneller Leistung lösen.
Mojo – Die neue KI-Programmiersprache
Mojo gilt als Obermenge des KI-Sprachgiganten Python. Modular, das Unternehmen von Chris Lattner (der Schöpfer der Programmiersprache Swift) und Tim Davis (ehemaliger GoogleML-Produktleiter) behauptet, Mojo sei es 35.000 Mal schneller als Python. Es kommt mit der Kraft/Geschwindigkeit von C Programmiersprache mit Python-Syntax und darauf aufbauender Construct-Funktion.
Der Compiler muss noch veröffentlicht werden, da er sich noch in der Entwicklungsphase befindet. Der Vorschauzugriff zum Ausprobieren von Mojo auf dem Jupyter Pocket book-Spielplatz ist durch eine frühzeitige Anmeldung möglich. Ich habe versucht, den nativen Python-Code im Vergleich zur Mojo-Implementierung einer 3*3-Matrixmultiplikation zu verwenden, und die Ergebnisse hinsichtlich der Rechenzeit waren erstaunlich. Da Mojo auf Python aufbaut, bietet es die Unterstützung der umfangreichen Bibliotheken und Pakete, die Python berühmt machen.
NEBENBEI: Mojo erlaubt eine andere Dateierweiterung als Feuer-Emoji (.🔥) als .mojo. Z.B. hallo.🔥oder hallo.mojo
Was macht Mojo so mächtig?
Mojo basiert explizit auf MLIR Compiler-Infrastruktur (abgeleitet von LLVMs), die unter der Haube der meisten Beschleuniger für maschinelles Lernen verwendet wird (entwickelt bei TensorFlow). MLIR unterstützt ein Framework zur Darstellung und Transformation verschiedener Berechnungsebenen und ermöglicht so eine effiziente und transportable Ausführung auf verschiedenen Hardwarezielen. MLIR spielt eine entscheidende Rolle bei der Überbrückung der Lücke zwischen Excessive-Stage-Frameworks für maschinelles Lernen und Low-Stage-Hardwarezielen und bietet ein einheitliches Darstellungs- und Optimierungsframework für eine effiziente Modellausführung.
Mojo verfügt zusätzlich zu Python über einige zusätzliche Funktionen, die eine schnellere Ausführung ermöglichen. Zu diesen Funktionen gehören:
Systemprogrammierung — Lexikalisches Scoping von Variablen statt globaler Festlegung.
def your_function():
let x: SI8 = 42
let y: SI64 = 17let z: SI8
if x != 0:
z = 1
else:
z = foo()
use(z)
Stark getippt Sprache (Deklaration von Variablentypen) überwindet die dynamische Typisierung von Python, die Variablen während der Laufzeit bestimmt, was sie langsam macht.
Gebrauch von Strukturen Dies ist statisch und funktioniert daher zur Kompilierungszeit anstelle von Klassen in Python.
@worth
struct MyPair:
var first: Int
var second: Int
def __lt__(self, rhs: MyPair) -> Bool:
return self.first < rhs.first or
(self.first == rhs.first and
self.second < rhs.second)
fn Definitionen, die Pythons def ersetzen.
fn useStrings():
var a: MyString = "howdy"
print(a) # Ought to print "howdy"
var b = a # ERROR: MyString does not implement __copyinit__a = "Goodbye"
print(b) # Ought to print "howdy"
print(a) # Ought to print "Goodbye"
Metaprogrammierung und adaptive Kompilierung/Autotuning– Überwindung von Python GIL (World Interpreter Lock), um Parallelität mit Multithreading-Funktionen zu unterstützen. Mojo definiert Pythons Funktionsparameter und Funktionsargumente neu und nutzt parametrisierte Typen und Funktionen. Mojo erlaubt SIMD (Single Instruction A number of Knowledge) Operationen.
fn funWithSIMD():
# Make a vector of 4 floats.
let small_vec = SIMD[DType.float32, 4](1.0, 2.0, 3.0, 4.0)# Make an enormous vector containing 1.0 in float16 format.
let big_vec = SIMD[DType.float16, 32].splat(1.0)
# Do some math and convert the weather to float32.
let bigger_vec = (big_vec+big_vec).solid[DType.float32]()
# You possibly can write varieties out explicitly if you need in fact.
let bigger_vec2 : SIMD[DType.float32, 32] = bigger_vec
Die Laufzeit des Autotunings steigt exponentiell mit der Anzahl der abzustimmenden Parameter. Autotuning profitiert von den internen Implementierungsdetails des Mojo-Compiler-Stacks. Autotuning muss im Laufe der Zeit kontinuierlich weiterentwickelt und iteriert werden, um seine Genauigkeit und Effizienz zu verbessern
# vector-length-agnostic algorithm to a buffer of information,from Autotune import autotune
def exp_buffer_impl[dt: DType](knowledge: ArraySlice[dt]):
# Choose vector size for this dtype and {hardware}
alias vector_len = autotune(1, 4, 8, 16, 32)
# Use it because the vectorization size
vectorize[exp[dt, vector_len]](knowledge)
Um tiefer in die Mojo-Welt einzutauchen, schauen Sie sich die offiziellen Dokumente an https://docs.modular.com/mojo/programming-manual.html
Die Inferenz-Engine von Modular
Die Modular AI Inference Engine ist eine einheitliche KI-Ausführungs-Engine, die alle Ihre PyTorch- und TensorFlow-Workloads unterstützt und gleichzeitig erhebliche Verbesserungen bei Benutzerfreundlichkeit, Leistung und Portabilität bietet. Es ist die schnellste einheitliche Inferenz-Engine der Welt und kann mit minimalen Codeänderungen in jeder Cloud- oder lokalen Umgebung bereitgestellt werden.
Die Modular AI Inference Engine bietet mehrere Vorteile, darunter:
- Geschwindigkeit: Die Modular AI Inference Engine ist unglaublich schnell und liefert Ergebnisse 3–4-fache Latenz- und Durchsatzsteigerung sofort einsatzbereit auf modernsten Modellen auf Intel-, AMD- und Graviton-Architekturen.
- Portabilität: Die Modular AI Inference Engine ist überall portierbar breit Reihe von Hardwareplattformen, einschließlich CPUs, GPUs und ASICs. Das bedeutet, dass Sie Ihre Modelle in jeder Umgebung bereitstellen können, ohne sie neu schreiben oder konvertieren zu müssen.
- Benutzerfreundlichkeit: Die Modular AI Inference Engine ist einfach zu verwenden. Es bietet eine einfache API mit dem sich Modelle auf vielfältige Weise bereitstellen lassen.
- Erweiterbarkeit: Die Modular AI Inference Engine ist erweiterbar. Du kannst Fügen Sie der Engine neue Options und Funktionen hinzu wie benötigt.
Python-API der Inferenz-Engine
from modular import engine
session = engine.InferenceSession()# Load and initialize each the TensorFlow and PyTorch fashions
tf_bert_session = session.load(tf_bert_model)
pt_dlrm_session = session.load(pt_dlrm_model)
# Run inference on each the TensorFlow BERT and PyTorch DLRM Fashions
# Run BERT TensorFlow mannequin with a given query.
query = "When did Copenhagen change into the capital of Denmark?"
attention_mask, input_ids, token_type_ids = convert_to_tokens(query)
bert_outputs = tf_bert_session.execute(attention_mask, input_ids, token_type_ids)
# Carry out DLRM PyTorch mannequin with random one-hot row of instructed objects and options.
recommended_items = np.random.rand(4, 8, 100).astype(np.int32)
dense_features = np.random.rand(4, 256).astype(np.float32)
dlrm_outputs = pt_dlrm_session.execute(dense_features, recommended_items)
# Inspecting the output of BERT
print("Variety of output tensors:", len(bert_outputs))
print(bert_outputs[0].form, bert_outputs[0].dtype)
print(bert_outputs[1].form, bert_outputs[1].dtype)
print("Reply:", convert_to_string(input_ids, bert_outputs))
# Output
Variety of output tensors: 2
(1, 192) float32
(1, 192) float32
Reply: Copenhagen grew to become the capital of Denmark within the early fifteenth century
Abschluss
Ich freue mich darauf, den Mojo-Compiler auf meinem lokalen Rechner auszuprobieren, sobald er verfügbar ist. Es wird interessant sein zu sehen, wie effektiv es Python übertrifft. Dann wird es sicherlich ein Meilenstein in der KI-Programmierung sein. Es ist lobenswert, wie Modular die effektiven Aspekte aller vorhandenen Programmiersprachen effizient berücksichtigt und seinen Compiler für Mojo so entwickelt hat, dass er leistungsfähig ist und die Nachteile und Fallstricke dieser Systeme berücksichtigt, um seine Inferenz-Engine und sein plattformübergreifendes {Hardware}-Ökosystem zu schaffen.
