neulich eine interessante Bibliothek, von der ich vorher noch nie gehört hatte.

PythoC ist ein Area-Particular Language (DSL)-Compiler, der es Entwicklern ermöglicht, C-Programme mit der Customary-Python-Syntax zu schreiben. Es nimmt eine statisch typisierte Teilmenge des Python-Codes und kompiliert ihn über LLVM IR (Low Degree Digital Machine Intermediate Illustration) direkt in nativen Maschinencode.

LLVM IR ist ein plattformunabhängiges Codeformat, das intern vom LLVM-Compiler-Framework verwendet wird. Compiler übersetzen den Quellcode zunächst in LLVM-IR, und dann wandelt LLVM diese IR in optimierten Maschinencode für bestimmte CPUs (x86, ARM usw.) um.

Eine zentrale Designphilosophie von PythoC ist: C-äquivalente Laufzeit + Python-basierte Kompilierungszeit, und es hat die folgenden nahezu Alleinstellungsmerkmale.

1. Erstellt eigenständige native ausführbare Dateien

Im Gegensatz zu Instruments wie Cython, die hauptsächlich zum Erstellen von C-Erweiterungen zur Beschleunigung bestehender Python-Skripte verwendet werden, kann PythoC völlig unabhängige, eigenständige ausführbare Dateien im C-Stil generieren. Nach der Kompilierung benötigt die resultierende Binärdatei weder den Python-Interpreter noch einen Rubbish Collector, um ausgeführt zu werden.

2. Verfügt über Low-Degree-Steuerung mit Python-Syntax

PythoC spiegelt die Fähigkeiten von C wider, verpackt sie jedoch in die sauberere Syntax von Python. Um dies zu erreichen, werden maschinennative Typhinweise anstelle der standardmäßigen dynamischen Typen von Python verwendet.

• Primitive: i32, i8, f64 usw.
• Gedächtnisstrukturen: Zeiger (ptr(T)), Arrays (array(T, N)) und Strukturen (erstellt durch Dekoration von Customary-Python-Klassen).
• Manuelle Speicherverwaltung: Da es standardmäßig keinen Rubbish Collector verwendet, ist die Speicherverwaltung genau wie in C explizit. Es bietet jedoch moderne, optionale Sicherheitsprüfungen, wie z lineare Typen (die sicherstellen, dass jede Zuweisung explizit freigegeben wird, um Lecks zu verhindern) und Verfeinerungsarten (um Validierungsprüfungen zur Kompilierungszeit zu erzwingen).

Python als Metaprogrammierungs-Engine

Eine der leistungsstärksten Funktionen von PythoC ist die Handhabung des Kompilierungsschritts. Da es sich bei der Kompilierungszeitumgebung nur um Python handelt, können Sie Customary-Python-Logik verwenden, um Ihren PythoC-Code zu generieren, zu bearbeiten und zu spezialisieren vor es wird auf LLVM herunterkompiliert. Dies bietet Ihnen hochflexible Funktionen zur Codegenerierung zur Kompilierungszeit (ähnlich wie C++-Vorlagen, aber angetrieben durch reines Python).

Es klingt vielversprechend, aber wird die Realität dem Hype gerecht? Okay, sehen wir uns diese Bibliothek in Aktion an. Die Set up ist einfach, wie bei den meisten Python-Bibliotheken ist es nur eine Pip-Set up wie diese:

pip set up pythoc

Aber es ist wahrscheinlich besser, eine geeignete Entwicklungsumgebung einzurichten, in der Sie Ihre verschiedenen Projekte isolieren können. In meinem Beispiel verwende ich das UV-Dienstprogramm, aber verwende die Methode, mit der du am besten zurechtkommst. Geben Sie die folgenden Befehle in Ihr Befehlszeilenterminal ein.

C:Usersthomaprojects> cd tasks
C:Usersthomaprojects> uv init pythoc_test
C:Usersthomaprojects> cd pythoc_test
C:Usersthomaprojectspythoc_test> uv venv --python 3.12
C:Usersthomaprojectspythoc_test> .venvScriptsactivate
(pythoc_test) C:Usersthomaprojectspythoc_test> uv pip set up pythoc

Ein einfaches Beispiel

Um PythoC zu verwenden, definieren Sie Funktionen mithilfe bestimmter Maschinentypen und markieren sie mit der Kompilierung von PythoC Dekorateur. Es gibt zwei Möglichkeiten, Ihren PythoC-Code auszuführen. Sie können die kompilierte Bibliothek wie folgt direkt aus Python aufrufen:

from pythoc import compile, i32

@compile
def add(x: i32, y: i32) -> i32:
    return x + y

# Can compile to native code
@compile
def important() -> i32:
    return add(10, 20)

# Name the compiled dynamic library from Python immediately
outcome = important()
print(outcome)

Führen Sie es dann so aus.

(pythoc_test) C:Usersthomaprojectspythoc_test>python test1.py

30

Oder Sie können eine eigenständige ausführbare Datei erstellen, die Sie unabhängig von Python ausführen können. Verwenden Sie dazu Code wie diesen.

from pythoc import compile, i32

@compile
def add(x: i32, y: i32) -> i32:
    print(x + y)
    return x + y

# Can compile to native code
@compile
def important() -> i32:
    return add(10, 20)

if __name__ == "__main__":
    from pythoc import compile_to_executable
    compile_to_executable()

Bei uns läuft es genauso.

(pythoc_test) C:Usersthomaprojectspythoc_test>python test4.py

Efficiently compiled to executable: buildtest4.exe
Linked 1 object file(s)

Dieses Mal sehen wir keine Ausgabe. Stattdessen erstellt PythoC ein Construct-Verzeichnis unterhalb Ihres aktuellen Verzeichnisses und erstellt dort dann eine ausführbare Datei, die Sie ausführen können.

(pythoc_test) C:Usersthomaprojectspythoc_test>dir buildtest4*
 Quantity in drive C is Home windows
 Quantity Serial Quantity is EEB4-E9CA

 Listing of C:Usersthomaprojectspythoc_testbuild

26/02/2026  14:32               297 test4.deps
26/02/2026  14:32           168,448 test4.exe
26/02/2026  14:32               633 test4.ll
26/02/2026  14:32               412 test4.o
26/02/2026  14:32                 0 test4.o.lock
26/02/2026  14:32         1,105,920 test4.pdb

Wir können die Datei test4.exe genauso ausführen wie jede andere ausführbare Datei.

(pythoc_test) C:Usersthomaprojectspythoc_test>buildtest4.exe

(pythoc_test) C:Usersthomaprojectspythoc_test>

Aber warte mal. In unserem Python-Code haben wir ausdrücklich darum gebeten, das Additionsergebnis zu drucken, aber wir sehen keine Ausgabe. Was ist los?

Die Antwort ist, dass die integrierte Python-Funktion print() darauf angewiesen ist, dass der Python-Interpreter im Hintergrund läuft, um herauszufinden, wie Objekte angezeigt werden. Da PythoC all das entfernt, um eine winzige, blitzschnelle native ausführbare Datei zu erstellen, wird die print-Anweisung entfernt.

Um in einer nativen Binärdatei auf dem Bildschirm zu drucken, müssen Sie die Customary-C-Bibliotheksfunktion verwenden: printf.

So verwenden Sie printf in PythoC

In C (und damit in PythoC) erfordert das Drucken von Variablen Formatbezeichner. Sie schreiben eine Zeichenfolge mit einem Platzhalter (wie %d für eine dezimale Ganzzahl) und übergeben dann die Variable, die Sie in diesen Platzhalter einfügen möchten.

So aktualisieren Sie unseren Code, um die C-Printf-Funktion zu importieren und korrekt zu verwenden:

from pythoc import compile, i32, ptr, i8, extern

# 1. Inform PythoC to hyperlink to the usual C printf operate
@extern
def printf(fmt: ptr(i8), *args) -> i32:
    cross

@compile
def add(x: i32, y: i32) -> i32:
  
    printf("Including 10 and 20 = %dn", x+y)
    return x + y

@compile
def important() -> i32:
    outcome = add(10, 20)
    
    # 2. Use printf with a C-style format string. 
    # %d is the placeholder for our integer (outcome).
    # n provides a brand new line on the finish.
   
    
    return 0

if __name__ == "__main__":
    from pythoc import compile_to_executable
    compile_to_executable()

Wenn wir nun den obigen Code erneut ausführen und die resultierende ausführbare Datei ausführen, entspricht unsere Ausgabe unseren Erwartungen.

(pythoc_test) C:Usersthomaprojectspythoc_test>python test5.py
Efficiently compiled to executable: buildtest5.exe
Linked 1 object file(s)

(pythoc_test) C:Usersthomaprojectspythoc_test>buildtest5.exe
Including 10 and 20 = 30

Aber ist es die Mühe wirklich wert?

All die Dinge, über die wir gesprochen haben, werden sich nur dann lohnen, wenn wir in unserem Code echte Geschwindigkeitsverbesserungen sehen. Schauen wir uns additionally für unser letztes Beispiel an, wie schnell unsere kompilierten Programme mit dem Äquivalent in Python verglichen werden können, und das sollte unsere Frage endgültig beantworten.

Zuerst der reguläre Python-Code. Wir verwenden eine rekursive Fibonacci-Berechnung, um einen lang laufenden Prozess zu simulieren. Berechnen wir die vierzigste Fibonacci-Zahl.

import time

def fib(n):
    # This calculates the sequence recursively
    if n <= 1:
        return n
    return fib(n - 1) + fib(n - 2)

if __name__ == "__main__":
    print("Beginning Customary Python pace take a look at...")
    
    start_time = time.time()
    
    # fib(38) often takes round 10 seconds in Python, 
    # relying in your laptop's CPU.
    outcome = fib(40) 
    
    end_time = time.time()
    
    print(f"Consequence: {outcome}")
    print(f"Time taken: {end_time - start_time:.4f} seconds")

Ich habe dieses Ergebnis erhalten, als ich den obigen Code ausgeführt habe.

(pythoc_test) C:Usersthomaprojectspythoc_test>python test6.py
Beginning Customary Python pace take a look at...
Consequence: 102334155
Time taken: 15.1611 seconds

Nun zum PythoC-basierten Code. Auch hier können wir, wie bei der print-Anweisung in unserem früheren Beispiel, nicht einfach die reguläre Import-Timing-Direktive von Python für unsere Timings verwenden. Stattdessen müssen wir die Customary-Timing-Funktion direkt aus der Programmiersprache C ausleihen: Uhr(). Wir definieren dies auf die gleiche Weise wie die printf-Anweisung, die wir zuvor verwendet haben.

Hier ist das aktualisierte PythoC-Skript mit integriertem C-Timer.

from pythoc import compile, i32, ptr, i8, extern

# 1. Import C's printf
@extern
def printf(fmt: ptr(i8), *args) -> i32:
    cross

# 2. Import C's clock operate
@extern
def clock() -> i32:
    cross

@compile
def fib(n: i32) -> i32:
    if n <= 1:
        return n
    return fib(n - 1) + fib(n - 2)

@compile
def important() -> i32:
    printf("Beginning PythoC pace take a look at...n")
    
    # Get the beginning time (this counts in "ticks")
    start_time = clock()
    
    # Run the heavy calculation
    outcome = fib(40)
    
    # Get the top time
    end_time = clock()
    
    # Calculate the distinction. 
    # Observe: On Home windows, 1 clock tick = 1 millisecond.
    elapsed_ms = end_time - start_time
    
    printf("Consequence: %dn", outcome)
    printf("Time taken: %d millisecondsn", elapsed_ms)
    
    return 0

if __name__ == "__main__":
    from pythoc import compile_to_executable
    compile_to_executable()

Meine Ausgabe conflict dieses Mal:

(pythoc_test) C:Usersthomaprojectspythoc_test>python test7.py
Efficiently compiled to executable: buildtest7.exe
Linked 1 object file(s)

(pythoc_test) C:Usersthomaprojectspythoc_test>buildtest7.exe
Beginning PythoC pace take a look at...
Consequence: 102334155
Time taken: 308 milliseconds

Und in diesem kleinen Beispiel sehen wir, obwohl der Code etwas komplexer ist, den wahren Vorteil der Verwendung kompilierter Sprachen wie C. Unsere ausführbare Datei conflict satte 40-mal schneller als der entsprechende Python-Code. Nicht zu schäbig.

Für wen ist PythoC geeignet?

Ich sehe drei Haupttypen von Benutzern für PythoC.

1/ Wie wir in unserem Fibonacci-Geschwindigkeitstest gesehen haben, kann Customary-Python bei schweren mathematischen Aufgaben langsam sein. PythoC könnte für jeden Python-Entwickler nützlich sein, der physikalische Simulationen, komplexe Algorithmen oder benutzerdefinierte Datenverarbeitungspipelines erstellt und an eine Leistungsgrenze stößt.

2/ Programmierer, die eng mit Computerhardware zusammenarbeiten (z. B. Spiele-Engines erstellen, Treiber schreiben oder kleine IoT-Geräte programmieren), schreiben normalerweise in C, weil sie den Computerspeicher manuell verwalten müssen.

PythoC könnte für diese Entwickler attraktiv sein, weil es die gleiche manuelle Speichersteuerung bietet (mithilfe von Zeigern und nativen Typen), es ihnen aber ermöglicht, Python als „Metaprogrammierungs“-Engine zu verwenden, um saubereren, flexibleren Code zu schreiben, bevor er bis zur Hardwareebene kompiliert wird.

3/ Wenn Sie ein hilfreiches Python-Skript schreiben und es mit einem Kollegen teilen möchten, muss dieser normalerweise Python installieren, eine virtuelle Umgebung einrichten und Ihre Abhängigkeiten herunterladen. Dies kann problematisch sein, insbesondere wenn der Zielbenutzer nicht über große IT-Kenntnisse verfügt. Mit PythoC kann jedoch jeder, sobald Sie Ihre kompilierte ausführbare C-Datei haben, sie ausführen, indem Sie einfach auf die Datei doppelklicken.

Und für wen es nicht ist

Die Kehrseite des oben Gesagten ist, dass PythoC wahrscheinlich nicht das beste Software für einen Webentwickler ist, da Leistungsengpässe dort normalerweise in der Netzwerk- oder Datenbankgeschwindigkeit liegen und nicht in der CPU-Berechnungsgeschwindigkeit.

Wenn Sie bereits optimierte Bibliotheken wie NumPy verwenden, werden Sie ebenfalls nicht viele Vorteile sehen.

Zusammenfassung

In diesem Artikel wurde Ihnen die relativ neue und unbekannte PythoC-Bibliothek vorgestellt. Damit können Sie mit Python superschnellen, eigenständigen ausführbaren C-Code erstellen.

Ich habe mehrere Beispiele für die Verwendung von Python und der PythoC-Bibliothek zum Erstellen ausführbarer C-Programme gegeben, darunter eines, das eine unglaubliche Beschleunigung beim Ausführen der von der PythoC-Bibliothek erstellten ausführbaren Datei im Vergleich zu einem Customary-Python-Programm zeigte.

Ein Drawback, auf das Sie stoßen werden, ist, dass Python-Importe in PythoC-Programmen nicht unterstützt werden. Ich habe jedoch auch gezeigt, wie Sie dieses Drawback umgehen können, indem Sie sie durch gleichwertige C-Integrationen ersetzen.

Abschließend habe ich besprochen, wer meiner Meinung nach die Artwork von Python-Programmierern ist, die einen Vorteil darin sehen könnten, PythonC in ihren Arbeitslasten zu verwenden, und welche, die das nicht tun würden.

Ich hoffe, das hat Ihren Appetit geweckt, zu sehen, für welche Anwendungsfälle Sie PythoC nutzen können. Sie können viel mehr über diese nützliche Bibliothek erfahren, indem Sie sich das GitHub-Repo unter dem folgenden Hyperlink ansehen.

https://github.com/1flei/PythoC

Transformatoren haben die Artwork und Weise verändert, wie künstliche Intelligenz funktioniert, insbesondere beim Verständnis von Sprache und Lernen aus Daten. Im Kern dieser Modelle sind Tensoren (Eine verallgemeinerte Artwork von mathematischen Matrizen, die die Verarbeitung von Informationen helfen). Wenn sich die Daten durch die verschiedenen Teile eines Transformators bewegt, unterliegen diese Tensoren unterschiedlichen Transformationen, die dem Modell helfen, Dinge wie Sätze oder Bilder zu verstehen. Wenn Sie lernen, wie Tensoren innerhalb von Transformatoren arbeiten, können Sie verstehen, wie die intelligenten KI -Systeme von heute tatsächlich funktionieren und denken.

Was dieser Artikel abdeckt und was es nicht tut

In diesem Artikel geht es um:

• Der Tensorenfluss von Eingabe zu Ausgang innerhalb eines Transformatormodells.
• Gewährleistung der dimensionalen Kohärenz während des gesamten Rechenprozesses.
• Die Schritt-für-Schritt-Transformationen, die Tensoren in verschiedenen Transformatorschichten unterziehen.

In diesem Artikel geht es nicht um:

• Eine allgemeine Einführung in Transformers oder tiefes Lernen.
• Detaillierte Architektur von Transformatormodellen.
• Trainingsprozess oder Hyper-Parameter-Abstimmung von Transformatoren.

Wie Tensoren innerhalb von Transformatoren wirken

Ein Transformator besteht aus zwei Hauptkomponenten:

• Encoder: Verarbeitet Eingabedaten und erfasst kontextbezogene Beziehungen, um sinnvolle Darstellungen zu erstellen.
• Decoder: Verwendet diese Darstellungen, um eine kohärente Ausgabe zu erzeugen und jedes Factor nacheinander vorherzusagen.

Tensoren sind die grundlegenden Datenstrukturen, die diese Komponenten durchlaufen und mehrere Transformationen erleiden, die eine dimensionale Kohärenz und den richtigen Informationsfluss gewährleisten.

Eingangsbettschicht

Vor dem Eingeben des Transformators werden Roheingangs -Token (Wörter, Unterwörter oder Zeichen) durch die in dichte Vektordarstellungen konvertiert Schicht einbetten. Diese Ebene fungiert als Suchtabelle, die jeden Tokenvektor ordnet und semantische Beziehungen zu anderen Wörtern aufnimmt.

Für eine Cost von fünf Sätzen mit jeweils eine Sequenzlänge von 12 Token und eine Einbettungsdimension von 768 lautet die Tensorform:

• Tensorform: (batch_size, seq_len, embedding_dim) → (5, 12, 768)

Nach dem Einbettung, Positionscodierung wird hinzugefügt, damit sichergestellt wird, dass die Auftragsinformationen erhalten bleiben, ohne die Tensorform zu ändern.

Multi-Head-Aufmerksamkeitsmechanismus

Eine der kritischsten Komponenten des Transformators ist die MAHA-Mechanismus mit mehreren Kopf. Es arbeitet auf drei Matrizen, die von Eingabemaschinen abgeleitet wurden:

• Abfrage (q)
• Schlüssel (okay)
• Wert (v)

Diese Matrizen werden unter Verwendung von matrizen lernbaren Gewicht erzeugt:

• WQ, WK, WV von Kind (embedding_dim, d_model) (z.B, (768, 512)).
• Die resultierenden Q-, Okay-, V -Matrizen haben Abmessungen
  (batch_size, seq_len, d_model).

Aufteilen von Q, Okay, V in mehrere Köpfe

Für eine effektive Parallelisierung und ein verbessertes Lernen spaltet MHA Q, Okay und V in mehrere Köpfe auf. Angenommen, wir haben 8 Aufmerksamkeitsköpfe:

• Jeder Kopf arbeitet auf einem Unterraum von d_model / head_count.

• Die umgeformten Tensorabmessungen sind (batch_size, seq_len, head_count, d_model / head_count).
• Beispiel: (5, 12, 8, 64) → umgeordnet zu (5, 8, 12, 64) Um sicherzustellen, dass jeder Kopf eine separate Sequenzscheibe erhält.

• So erhält jeder Kopf seinen Anteil an Qi, Ki, vi

Aufmerksamkeitsberechnung

Jeder Kopf berechnet die Aufmerksamkeit mit der Formel:

Sobald die Aufmerksamkeit für alle Köpfe berechnet wurde, werden die Ausgänge verkettet und durch eine lineare Transformation geleitet, wodurch die anfängliche Tensorform wiederhergestellt wird.

Restverbindung und Normalisierung

Nach dem Multi-Head-Aufmerksamkeitsmechanismus a Restverbindung wird hinzugefügt, gefolgt von Schichtnormalisierung:

• Restverbindung: Output = Embedding Tensor + Multi-Head Consideration Output
• Normalisierung: (Output − μ) / σ Coaching stabilisieren
• Tensorform bleibt übrig (batch_size, seq_len, embedding_dim)

Feed-Ahead-Netzwerk (FFN)

Im Decoder, Maskierte Aufmerksamkeit mit mehreren Kopf stellt sicher, dass jedes Token nur an frühere Token teilnimmt und die Leckagen zukünftiger Informationen verhindert.

Dies wird unter Verwendung einer niedrigeren dreieckigen Kind erreicht (seq_len, seq_len) mit -inf Werte im oberen Dreieck. Das Anwenden dieser Maske stellt sicher, dass die Softmax -Funktion zukünftige Positionen aufnimmt.

Übereinstimmung in der Dekodierung

Da der Decoder den Eingangssatz nicht vollständig versteht, wird er verwendet Übereinstimmung Vorhersagen verfeinern. Hier:

• Der Decoder generiert Abfragen (QD) von seiner Eingabe ((batch_size, target_seq_len, embedding_dim)).
• Der Encoderausgang dient als Schlüssel (Ke) und Werte (Ve).
• Der Decoder berechnet die Aufmerksamkeit zwischen Qd Und Keextrahieren relevanter Kontext aus der Ausgabe des Encoders.

Abschluss

Transformatoren verwenden Tensoren um ihnen zu helfen zu lernen und kluge Entscheidungen zu treffen. Wenn sich die Daten durch das Netzwerk bewegt, gehen diese Tensoren unterschiedliche Schritte durch-wie in Zahlen, die das Modell verstehen kann (einbetten), sich auf wichtige Teile (Aufmerksamkeit) konzentrieren, ausgewogen bleiben (Normalisierung) und durch Schichten weitergegeben werden, die Muster lernen (Feed-Ahead). Diese Änderungen halten die Daten die ganze Zeit in der richtigen Kind. Wenn wir verstehen, wie sich Tensoren bewegen und verändern, können wir eine bessere Vorstellung davon bekommen, wie KI -Modelle Arbeiten und wie sie eine menschliche Sprache verstehen und schaffen können.