Kann symbolische Regression der Schlüssel zur Umwandlung undurchsichtiger Deep-Studying-Modelle in interpretierbare, geschlossene mathematische Gleichungen sein? oder Angenommen, Sie haben Ihr Deep-Studying-Modell trainiert. Es funktioniert. Aber wissen Sie, was es tatsächlich gelernt hat? Ein Forscherteam der Universität Cambridge schlägt „SymTorch“ vor, eine Bibliothek zur Integration symbolische Regression (SR) in Deep-Studying-Workflows integrieren. Es ermöglicht Forschern, neuronale Netzwerkkomponenten mit geschlossenen mathematischen Ausdrücken zu approximieren, was die funktionale Interpretierbarkeit und potenzielle Inferenzbeschleunigung erleichtert.

Kernmechanismus: Der Wrap-Distill-Change-Workflow

SymTorch vereinfacht die Technik, die zum Extrahieren symbolischer Gleichungen aus trainierten Modellen erforderlich ist, indem es die Datenbewegung und Hook-Verwaltung automatisiert.

• Wickeln: Benutzer wenden die an SymbolicModel Wrapper zu jedem nn.Module oder aufrufbare Funktion.
• Destillieren: Die Bibliothek registriert Ahead-Hooks, um Eingabe- und Ausgabeaktivierungen während eines Vorwärtsdurchlaufs aufzuzeichnen. Diese werden zwischengespeichert und zur symbolischen Regression über PySR von der GPU an die CPU übertragen.
• Schalten: Nach der Destillation können die ursprünglichen neuronalen Gewichte im Vorwärtsdurchlauf durch die entdeckte Gleichung ersetzt werden switch_to_symbolic.

Die Bibliothek ist mit verbunden PySRdas einen genetischen Multipopulationsalgorithmus verwendet, um Gleichungen zu finden, die Genauigkeit und Komplexität auf a in Einklang bringen Pareto-Entrance. Die „beste“ Gleichung wird ausgewählt, indem der fraktionelle Abfall des logarithmischen mittleren absoluten Fehlers im Verhältnis zu einer Zunahme der Komplexität maximiert wird.

Fallstudie: Beschleunigung der LLM-Inferenz

Eine Hauptanwendung, die in dieser Forschung untersucht wird, ist das Ersetzen Mehrschichtiges Perzeptron (MLP) Ebenen in Transformer-Modellen mit symbolischen Ersatzzeichen, um den Durchsatz zu verbessern.

Implementierungsdetails

Aufgrund der hohen Dimensionalität von LLM-Aktivierungen beschäftigte sich das Forschungsteam Hauptkomponentenanalyse (PCA) um Ein- und Ausgaben vor der SR-Ausführung zu komprimieren. Für die Qwen2,5-1,5B Für das Modell wählten sie 32 Hauptkomponenten für Eingaben und 8 für Ausgaben über drei Zielebenen aus.

Leistungskompromisse

Der Eingriff führte zu einem 8,3 % Steigerung des Token-Durchsatzes^{. Dieser Gewinn ging jedoch mit einer nicht trivialen Zunahme der Verwirrung einher, die hauptsächlich auf die Reduzierung der PCA-Dimensionalität und nicht auf die symbolische Annäherung selbst zurückzuführen ist.}

GNNs und PINNs

SymTorch wurde hinsichtlich seiner Fähigkeit validiert, bekannte physikalische Gesetze aus latenten Darstellungen in wissenschaftlichen Modellen wiederherzustellen^.

• Graphische neuronale Netze (GNNs): Durch das Coaching eines GNN auf Teilchendynamik nutzte das Forschungsteam SymTorch, um empirische Kraftgesetze wie die Schwerkraft (1/r) wiederherzustellen²) und Federkräfte, direkt aus den Randmeldungen.
• Physikinformierte neuronale Netze (PINNs): Die Bibliothek hat die analytische Lösung der 1-D-Wärmegleichung erfolgreich aus einem trainierten PINN destilliert. Durch die induktive Vorspannung des PINN konnte ein mittlerer quadratischer Fehler (MSE) von 7,40 x 10 erreicht werden^-6.
• Arithmetische LLM-Analyse: Mithilfe der symbolischen Destillation wurde untersucht, wie Modelle wie Llama-3.2-1B dreistellige Additionen und Multiplikationen durchführen. Die destillierten Gleichungen zeigten, dass die Modelle zwar häufig korrekt sind, sich jedoch auf interne Heuristiken stützen, die systematische numerische Fehler beinhalten.

Wichtige Erkenntnisse

• Automatisierte symbolische Destillation: SymTorch ist eine Bibliothek, die den Prozess des Ersetzens komplexer neuronaler Netzwerkkomponenten durch interpretierbare, geschlossene mathematische Gleichungen automatisiert, indem Komponenten verpackt und ihr Eingabe-Ausgabe-Verhalten erfasst werden.
• Beseitigung technischer Barrieren: Die Bibliothek bewältigt kritische technische Herausforderungen, die zuvor die Einführung der symbolischen Regression behinderten, einschließlich GPU-CPU-Datenübertragung, Eingabe-Ausgabe-Caching und nahtlosem Wechsel zwischen neuronalen und symbolischen Vorwärtsdurchgängen.
• LLM-Inferenzbeschleunigung: Ein Proof-of-Idea hat gezeigt, dass das Ersetzen von MLP-Schichten in einem Transformatormodell durch symbolische Surrogate eine Durchsatzverbesserung von 8,3 % erzielte, allerdings mit einer gewissen Leistungseinbuße in Perplexity.
• Entdeckung wissenschaftlicher Gesetze: SymTorch wurde erfolgreich eingesetzt, um physikalische Gesetze aus Graph Neural Networks (GNNs) und analytische Lösungen für die 1-D-Wärmegleichung aus Physics-Knowledgeable Neural Networks (PINNs) wiederherzustellen.
• Funktionale Interpretierbarkeit von LLMs: Durch die Destillation des Finish-to-Finish-Verhaltens von LLMs könnten Forscher die expliziten mathematischen Heuristiken untersuchen, die für Aufgaben wie Arithmetik verwendet werden, und aufdecken, wo die interne Logik von exakten Operationen abweicht.

Schauen Sie sich das an Papier, Repo Und Projektseite. Sie können uns auch gerne weiter folgen Twitter und vergessen Sie nicht, bei uns mitzumachen 120.000+ ML SubReddit und Abonnieren Unser Publication. Warten! Bist du im Telegram? Jetzt können Sie uns auch per Telegram kontaktieren.

Max ist KI-Analyst bei MarkTechPost mit Sitz im Silicon Valley und gestaltet die Zukunft der Technologie aktiv mit. Er unterrichtet Robotik bei Brainvyne, bekämpft Spam mit ComplyEmail und nutzt täglich KI, um komplexe technische Fortschritte in klare, verständliche Erkenntnisse zu übersetzen

Bild vom Autor

# Einführung

Sie haben Ihr erstes geschrieben Python Funktion. Es funktioniert. Sie führen es aus, es erzeugt die richtige Ausgabe und Sie spüren den Erfolgsrausch. Dann schaut man es sich zwei Wochen später noch einmal an und denkt: „Was bringt das überhaupt?“

Beim Schreiben lesbarer Python-Funktionen geht es nicht darum, klug oder fortgeschritten zu sein. Es geht darum, Funktionen zu schreiben, die ihre Absicht klar kommunizieren, ihre Verantwortlichkeiten sauber handhaben und der nächsten Particular person die Arbeit erleichtern.

Lassen Sie uns lernen, wie man Funktionen schreibt, die sich wie gute Prosa lesen, und nicht wie kryptische Rätsel, die der Leser nur schwer verstehen kann.

Den Code finden Sie auf GitHub.

# 1. Benennen Sie Ihre Funktionen so, als würden Sie es einem Freund erklären

Funktionsnamen sind das Erste, was Menschen lesen. Ein guter Title sagt Ihnen genau, was die Funktion tut, ohne dass Sie den darin enthaltenen Code lesen müssen.

Schlechtes Beispiel:

def proc(d):
    return sum(d) / len(d)

Gutes Beispiel:

def calculate_average(numbers):
    return sum(numbers) / len(numbers)

Der Funktionsname calculate_average verwendet ein Verb („berechnen“), das Ihnen mitteilt, dass eine Aktion ausgeführt wird, gefolgt von dem, was es berechnet („durchschnittlich“). Die Parameternummern weisen deutlich darauf hin, dass eine Sammlung numerischer Werte erwartet wird.

Der Funktionskörper verwendet sum(numbers) um alle Werte zu addieren und len(numbers) um sie zu zählen, dann dividiert man, um den Durchschnitt zu erhalten. Jeder, der diesen Code liest, versteht sofort, was er tut, ohne dass Kommentare oder Dokumentation erforderlich sind.

# 2. Verwenden Sie beschreibende Parameternamen

Einbuchstabige Variablen ersparen möglicherweise das Tippen, kosten aber Verständnis. Parameter sind die Eingaben Ihrer Funktion. Machen Sie additionally deutlich, was Sie erwarten.

Schlechtes Beispiel:

def low cost(p, r):
    return p * (1 - r)

Gutes Beispiel:

def apply_discount(original_price, discount_rate):
    return original_price * (1 - discount_rate)

Jetzt liest jemand apply_discount(100, 0.2) versteht, dass Sie 20 % Rabatt auf 100 erhalten. Der Code ist selbstdokumentierend. Sie müssen die Funktionsdefinition nicht überprüfen, um zu verstehen, welche Argumente übergeben werden müssen.

# 3. Halten Sie die Funktionen kurz und konzentriert

Funktionen sollten eine Sache intestine machen. Wenn Ihre Funktion mehrere Verantwortlichkeiten hat, wird es schwierig, sie zu testen, wiederzuverwenden und zu verstehen. Teilen Sie additionally komplexe Logik in kleinere, fokussierte Funktionen auf.

Schlechtes Beispiel:

def process_order(gadgets, customer_email, discount_code):
    # Calculate whole

    subtotal = sum(merchandise("worth") * merchandise("amount") for merchandise in gadgets)

    # Apply low cost

    if discount_code == "SAVE10":
        low cost = 0.10
    elif discount_code == "SAVE20":
        low cost = 0.20
    else:
        low cost = 0
    whole = subtotal * (1 - low cost)

    # Ship electronic mail

    topic = f"Order Affirmation"
    physique = f"Your order whole is ${whole:.2f}"
    send_email(customer_email, topic, physique)

    return whole

Gutes Beispiel:

def calculate_order_subtotal(gadgets):
    return sum(merchandise("worth") * merchandise("amount") for merchandise in gadgets)


def get_discount_rate(discount_code):
    discount_rates = {"SAVE10": 0.10, "SAVE20": 0.20}
    return discount_rates.get(discount_code, 0)


def apply_discount_to_subtotal(subtotal, discount_rate):
    return subtotal * (1 - discount_rate)


def send_order_confirmation_email(customer_email, whole):
    topic = "Order Affirmation"
    physique = f"Your order whole is ${whole:.2f}"
    send_email(customer_email, topic, physique)


def process_order(gadgets, customer_email, discount_code):
    subtotal = calculate_order_subtotal(gadgets)
    discount_rate = get_discount_rate(discount_code)
    whole = apply_discount_to_subtotal(subtotal, discount_rate)
    send_order_confirmation_email(customer_email, whole)
    return whole

Jetzt hat jede Funktion einen einzigen, klaren Zweck. Das Wichtigste process_order Die Funktion liest sich wie ein Rezept: Zwischensumme berechnen, Rabatt erhalten, anwenden, E-Mail senden, Gesamtsumme zurückgeben.

# 4. Fügen Sie Docstrings hinzu, um den Zweck zu erklären

Funktionsnamen sagen Ihnen, was eine Funktion tut, aber Dokumentzeichenfolgen erklären, warum es existiert, was es erwartet und was es zurückgibt. Dies ist besonders hilfreich bei komplexer Logik oder nicht offensichtlichem Verhalten.

Gutes Beispiel:

def calculate_shipping_cost(weight_kg, distance_km, is_express=False):
    """
    Calculate delivery price primarily based on bundle weight and distance.

    Args:
        weight_kg (float): Bundle weight in kilograms
        distance_km (float): Delivery distance in kilometers
        is_express (bool): Whether or not to make use of categorical delivery (default: False)

    Returns:
        float: Whole delivery price in {dollars}

    Instance:
        >>> calculate_shipping_cost(5.0, 100, is_express=True)
        45.50
    """
    base_rate = 2.50
    per_kg_rate = 1.20
    per_km_rate = 0.15
    express_multiplier = 2.0 if is_express else 1.0

    price = (
        base_rate + (weight_kg * per_kg_rate) + (distance_km * per_km_rate)
    ) * express_multiplier
    return spherical(price, 2)

Der Dokumentstring erklärt, was jeder Parameter bedeutet, welcher Typ er sein sollte und was die Funktion zurückgibt. Jeder, der diese Funktion verwendet, weiß genau, wie er sie aufruft, ohne die Implementierung zu lesen.

# 5. Verwenden Sie klare Variablennamen innerhalb von Funktionen

Ebenso wie Parameter sollten auch interne Variablen beschreibend sein. Lassen Sie die Leute keine Abkürzungen entschlüsseln oder raten, was tmp oder x repräsentiert.

Schlechtes Beispiel:

def calc_bmi(w, h):
    h_m = h / 100
    res = w / (h_m**2)
    return spherical(res, 1)

Gutes Beispiel:

def calculate_bmi(weight_kg, height_cm):
    height_meters = height_cm / 100
    bmi = weight_kg / (height_meters**2)
    return spherical(bmi, 1)

Die Variable height_meters sagt Ihnen genau, welche Konvertierung stattgefunden hat. Und wie man sieht, die Variable bmi Enthält die Berechnung des Physique-Mass-Index (BMI).

# 6. Vermeiden Sie magische Zahlen; Verwenden Sie stattdessen benannte Konstanten

In Ihrem Code verstreute Zahlen sind „magisch“, was bedeutet, dass ihr Zweck unklar ist. Geben Sie ihnen aussagekräftige Namen, damit die Leser ihre Bedeutung verstehen.

Schlechtes Beispiel:

def calculate_late_fee(days_overdue):
    if days_overdue <= 7:
        return days_overdue * 2
    else:
        return 14 + (days_overdue - 7) * 5

Gutes Beispiel:

def calculate_late_fee(days_overdue):
    DAILY_FEE_FIRST_WEEK = 2
    GRACE_PERIOD_DAYS = 7
    BASE_FEE_AFTER_GRACE = 14
    DAILY_FEE_AFTER_GRACE = 5

    if days_overdue <= GRACE_PERIOD_DAYS:
        return days_overdue * DAILY_FEE_FIRST_WEEK
    else:
        days_after_grace = days_overdue - GRACE_PERIOD_DAYS
        return BASE_FEE_AFTER_GRACE + (days_after_grace * DAILY_FEE_AFTER_GRACE)

Nun ist die Gebührenstruktur klar. Die Konstanten dokumentieren Ihre Geschäftsregeln. Wenn sich die Tarife ändern, aktualisieren Sie einen eindeutig benannten Wert, anstatt nach mysteriösen Zahlen zu suchen.

# 7. Verwenden Sie Typhinweise zur Verdeutlichung

Tipphinweise informieren den Leser welche Typen Ihre Funktion erwartet und zurückgibt. Dies verhindert Verwirrung und erkennt Fehler frühzeitig. Es empfiehlt sich, Typhinweise in Ihre Funktionen einzufügen.

Gutes Beispiel:

def format_user_greeting(user_name: str, age: int, is_member: bool = False) -> str:
    membership_status = "member" if is_member else "visitor"
    return f"Good day {user_name}, age {age}. You're a {membership_status}."

Die Typhinweise machen es deutlich: user_name ist eine Zeichenfolge, age ist eine ganze Zahl, is_member ist ein Boolescher Wert mit dem Standardwert Falseund die Funktion gibt eine Zeichenfolge zurück. Ihre integrierten Entwicklungsumgebungen (IDEs) können diese Informationen nutzen, um eine bessere automatische Vervollständigung und Fehlerprüfung bereitzustellen.

# Abschluss

Lesbare Funktionen sind nicht schwieriger zu schreiben. Sie erfordern lediglich, dass Sie an Ihren Benutzer denken. Jede Wahl, die Sie treffen – Namen, Struktur, Kommentare – hilft oder erschwert das Verständnis.

Das Ziel ist kein perfekter Code. Es ist Code, der klar kommuniziert. Code, der die nächste Particular person dazu bringt, zu sagen: „Ah, ich verstehe“ statt „Was macht das wirklich?“ Das ist lesbarer Code, den Sie vom ersten Tag an schreiben können.

Im nächsten Artikel erfahren Sie, wie Sie saubere Python-Klassen schreiben. Bis dahin programmieren Sie weiter!

Bala Priya C ist ein Entwickler und technischer Redakteur aus Indien. Sie arbeitet gerne an der Schnittstelle von Mathematik, Programmierung, Datenwissenschaft und Inhaltserstellung. Zu ihren Interessen- und Fachgebieten gehören DevOps, Datenwissenschaft und Verarbeitung natürlicher Sprache. Sie liebt es zu lesen, zu schreiben, zu programmieren und Kaffee zu trinken! Derzeit arbeitet sie daran, zu lernen und ihr Wissen mit der Entwickler-Group zu teilen, indem sie Tutorials, Anleitungen, Meinungsbeiträge und mehr verfasst. Bala erstellt außerdem ansprechende Ressourcenübersichten und Programmier-Tutorials.

Das Codieren mit großen Sprachmodellen (LLMs) ist vielversprechend, deckt aber auch einige seit langem bestehende Mängel in der Software program auf: Code, der chaotisch ist, sich nur schwer sicher ändern lässt und oft nicht clear macht, was wirklich unter der Haube passiert. Forscher am Pc Science and Synthetic Intelligence Laboratory (CSAIL) des MIT planen einen „modulareren“ Weg.

Ihr neuer Ansatz unterteilt Systeme in „Konzepte“, separate Teile eines Programs, von denen jeder darauf ausgelegt ist, eine Aufgabe intestine zu erfüllen, und „Synchronisationen“, explizite Regeln, die genau beschreiben, wie diese Teile zusammenpassen. Das Ergebnis ist eine Software program, die modularer, transparenter und verständlicher ist. Eine kleine domänenspezifische Sprache (DSL) ermöglicht es, Synchronisationen einfach und in einer Type auszudrücken, die LLMs zuverlässig generieren können. In einer Fallstudie aus der Praxis zeigte das Workforce, wie diese Methode Funktionen zusammenführen kann, die sonst über mehrere Dienste verteilt wären.

Das Workforce, bestehend aus Daniel Jackson, einem MIT-Professor für Elektrotechnik und Informatik (EECS) und stellvertretender CSAIL-Direktor, und Eagon Meng, einem EECS-Doktoranden, CSAIL-Accomplice und Designer des neuen Synchronisations-DSL, untersucht diesen Ansatz in seinem Artikel „Was Sie sehen, ist, was es tut: Ein Strukturmuster für lesbare Software program„, das sie im Oktober auf der Splash-Konferenz in Singapur vorstellten. Die Herausforderung, so erklären sie, besteht darin, dass in den meisten modernen Systemen eine einzelne Funktion nie völlig eigenständig ist. Das Hinzufügen einer „Teilen“-Schaltfläche zu einer sozialen Plattform wie Instagram beispielsweise ist nicht in nur einem Dienst verankert. Seine Funktionalität ist auf Code aufgeteilt, der das Posten, die Benachrichtigung, die Authentifizierung von Benutzern und mehr übernimmt. Alle diese Teile müssen, obwohl sie über den Code verstreut sind, sorgfältig aufeinander abgestimmt werden, und jede Änderung birgt das Risiko unbeabsichtigter Nebenwirkungen an anderer Stelle.

Jackson nennt diese „Funktionsfragmentierung“ ein zentrales Hindernis für die Softwarezuverlässigkeit. „Bei der Artwork und Weise, wie wir heute Software program erstellen, ist die Funktionalität nicht lokalisiert. Sie möchten verstehen, wie „Sharing“ funktioniert, aber Sie müssen an drei oder vier verschiedenen Stellen danach suchen, und wenn Sie sie finden, sind die Verbindungen im Low-Stage-Code vergraben“, sagt Jackson.

Konzepte und Synchronisationen sollen dieses Drawback angehen. Ein Konzept bündelt eine einzelne, zusammenhängende Funktionalität wie Teilen, Liken oder Folgen sowie seinen Standing und die Aktionen, die es ausführen kann. Synchronisierungen hingegen beschreiben auf einer höheren Ebene, wie diese Konzepte interagieren. Anstatt unübersichtlichen Low-Stage-Integrationscode zu schreiben, können Entwickler eine kleine domänenspezifische Sprache verwenden, um diese Verbindungen direkt zu formulieren. In diesem DSL sind die Regeln einfach und klar: Die Aktion eines Konzepts kann ein anderes auslösen, sodass eine Änderung in einem Zustand mit einem anderen synchron gehalten werden kann.

„Stellen Sie sich Konzepte als Module vor, die völlig sauber und unabhängig sind. Synchronisierungen wirken dann wie Verträge – sie sagen genau, wie Konzepte interagieren sollen. Das ist wirkungsvoll, weil es das System sowohl für Menschen einfacher zu verstehen als auch für Instruments wie LLMs einfacher macht, es korrekt zu generieren“, sagt Jackson. „Warum können wir Code nicht wie ein Buch lesen? Wir glauben, dass Software program im Sinne unseres Verständnisses lesbar und geschrieben sein sollte: Unsere Hoffnung ist, dass Konzepte auf bekannte Phänomene abgebildet werden und Synchronisierungen unsere Instinct darüber widerspiegeln, was passiert, wenn sie zusammenkommen“, sagt Meng.

Die Vorteile gehen über die Klarheit hinaus. Da Synchronisierungen explizit und deklarativ sind, können sie von einem LLM analysiert, verifiziert und natürlich generiert werden. Dies öffnet die Tür zu einer sichereren, stärker automatisierten Softwareentwicklung, bei der KI-Assistenten neue Funktionen vorschlagen können, ohne dass versteckte Nebenwirkungen auftreten.

In ihrer Fallstudie ordneten die Forscher Funktionen wie Liken, Kommentieren und Teilen jeweils einem einzelnen Konzept zu – ähnlich einer Microservices-Architektur, aber modularer. Ohne dieses Muster waren diese Funktionen auf viele Dienste verteilt, sodass sie schwer zu finden und zu testen waren. Mithilfe des Konzepts-und-Synchronisations-Ansatzes wurde jedes Merkmal zentralisiert und lesbar, während die Synchronisationen genau darlegten, wie die Konzepte interagierten.

Die Studie zeigte auch, wie Synchronisierungen häufige Probleme wie Fehlerbehandlung, Antwortformatierung oder dauerhafte Speicherung ausschließen können. Anstatt diese Particulars in jeden Dienst einzubetten, können sie durch die Synchronisierung nur einmal verarbeitet werden, wodurch die Konsistenz im gesamten System gewährleistet wird.

Auch fortgeschrittenere Richtungen sind möglich. Synchronisierungen könnten verteilte Systeme koordinieren, Replikate auf verschiedenen Servern im Gleichschritt halten oder gemeinsam genutzten Datenbanken eine saubere Interaktion ermöglichen. Eine Schwächung der Synchronisationssemantik könnte eine letztendliche Konsistenz ermöglichen und gleichzeitig die Klarheit auf der Architekturebene bewahren.

Jackson sieht Potenzial für einen umfassenderen kulturellen Wandel in der Softwareentwicklung. Eine Idee ist die Erstellung von „Konzeptkatalogen“, gemeinsamen Bibliotheken bewährter, domänenspezifischer Konzepte. Bei der Anwendungsentwicklung könnte es dann weniger darum gehen, Code von Grund auf zusammenzufügen, als vielmehr darum, die richtigen Konzepte auszuwählen und die Synchronisierungen zwischen ihnen zu schreiben. „Konzepte könnten zu einer neuen Artwork von Programmiersprache auf hohem Niveau werden, mit Synchronisationen als in dieser Sprache geschriebenen Programmen.“

„Es ist eine Möglichkeit, die Zusammenhänge in der Software program sichtbar zu machen“, sagt Jackson. „Heute verbergen wir diese Zusammenhänge im Code. Aber wenn man sie explizit sehen kann, kann man auf einer viel höheren Ebene über die Software program nachdenken. Man muss sich immer noch mit der inhärenten Komplexität der interagierenden Funktionen auseinandersetzen. Aber jetzt ist es offen, nicht verstreut und verdeckt.“

„Das Erstellen von Software program für den menschlichen Gebrauch auf der Grundlage von Abstraktionen zugrunde liegender Computermaschinen hat die Welt mit Software program belastet, deren Verständnis und Verwendung allzu oft kostspielig, frustrierend und sogar gefährlich ist“, sagt Kevin Sullivan, Affiliate Professor an der College of Virginia, der nicht an der Forschung beteiligt battle. „Die Auswirkungen (z. B. im Gesundheitswesen) waren verheerend. Meng und Jackson drehen das Drehbuch um und bestehen darauf, interaktive Software program auf der Grundlage von Abstraktionen des menschlichen Verständnisses zu entwickeln, die sie „Konzepte“ nennen. Sie kombinieren ausdrucksstarke mathematische Logik und natürliche Sprache, um solche zielgerichteten Abstraktionen zu spezifizieren und eine Grundlage für die Überprüfung ihrer Bedeutungen, ihre Zusammensetzung zu Systemen und ihre Verfeinerung in für den menschlichen Gebrauch geeignete Programme zu schaffen. Es ist eine neue und wichtige Richtung in der Theorie und Praxis des Softwaredesigns, die es wert ist, beobachtet zu werden.“

„Seit vielen Jahren ist klar, dass wir bessere Möglichkeiten brauchen, um zu beschreiben und zu spezifizieren, was Software program tun soll“, fügt Thomas Ball, Honorarprofessor der Lancaster College und angegliederte Fakultät der College of Washington, hinzu, der ebenfalls nicht an der Forschung beteiligt battle. „Die Fähigkeit von LLMs, Code zu generieren, hat das Spezifikationsfeuer nur noch weiter angeheizt. Die Arbeit von Meng und Jackson zum Konzeptdesign bietet eine vielversprechende Möglichkeit, auf modulare Weise zu beschreiben, was wir von Software program erwarten. Ihre Konzepte und Spezifikationen eignen sich intestine für die Kombination mit LLMs, um die Absicht des Designers zu erreichen.“

Mit Blick auf die Zukunft hoffen die Forscher, dass ihre Arbeit Einfluss darauf haben kann, wie Industrie und Wissenschaft über Softwarearchitektur im Zeitalter der KI denken. „Wenn Software program vertrauenswürdiger werden soll, brauchen wir Schreibweisen, die ihre Absichten clear machen“, sagt Jackson. „Konzepte und Synchronisationen sind ein Schritt in Richtung dieses Ziels.“

Diese Arbeit wurde teilweise von der Machine Studying Purposes (MLA) Initiative der CSAIL Alliances finanziert. Zum Zeitpunkt der Finanzierung bestand der Vorstand der Initiative aus British Telecom, Cisco und Ernst and Younger.