Untersuchung der neu auftretenden Fähigkeiten in grossen Sprachmodellen

Grosse Sprachmodelle (LLMs) werden ziemlich populär, besonders in der Software-Engineering-Welt. Sie sind wie die neuen Kids in der Nachbarschaft, und jeder will wissen, was sie draufhaben. Die grosse Frage ist: Werden diese Modelle plötzlich supertoll, je grösser und komplexer sie werden, wie ein Superheld, der seine Kräfte entdeckt?

Diese Idee nennt man oft "emergente Fähigkeiten." Einfach gesagt bedeutet das, dass diese Modelle bestimmte Fähigkeiten vielleicht erst zeigen, wenn sie eine bestimmte Grösse oder eine bestimmte Menge an Training erreicht haben. Denk daran wie bei einem Videospiel, wo du erst ab Level 10 deine Superkräfte bekommst.

Aber hier ist der Haken: Es gab nicht viel Forschung, die untersucht hat, ob das für Aufgaben wie Bugs beheben, Code übersetzen oder Commit-Nachrichten schreiben zutrifft. Die meisten bestehenden Studien haben sich auf andere Bereiche konzentriert, wie die Verarbeitung natürlicher Sprache.

#Was sind emergente Fähigkeiten?

Emergente Fähigkeiten in LLMs beziehen sich auf Fähigkeiten, die nur auftauchen, wenn die Modelle gross genug sind. Es ist wie zu warten, dass eine Party richtig in Gang kommt – bis genug Gäste da sind, gibt’s nur peinliches Schweigen.

Im Kontext des Software Engineerings interessiert uns, ob diese Modelle helfen können, Bugs im Code zu fixen, zwischen Programmiersprachen zu übersetzen oder sinnvolle Commit-Nachrichten zu generieren – alles Aufgaben, die einige fortgeschrittene Fähigkeiten erfordern. Wenn ein Modell emergente Fähigkeiten zeigt, bedeutet das, dass es in kleineren Grössen schlecht abschneidet, aber bei grösseren deutlich besser abschneidet.

Stell dir ein Modell vor, das nicht zwischen einem Bug und einem Feature unterscheiden kann, bis es ein riesiges Modell wird. Wir wollen herausfinden, ob das so ist oder ob das alles nur Täuschung ist.

#Unser Ansatz

Um das zu untersuchen, haben wir uns entschieden, einen systematischen Ansatz zu verfolgen. Wir haben einen Schritt-für-Schritt-Prozess erstellt, um diese Modelle basierend auf bestimmten Aufgaben zu bewerten.

Wir haben uns drei Hauptaufgaben im Software Engineering angesehen:

1. Bugs beheben: Kann das Modell defekten Code nehmen und ihn wieder zum Laufen bringen?
2. Codeübersetzung: Kann das Modell Code von einer Sprache in eine andere übersetzen?
3. Generierung von Commit-Nachrichten: Kann das Modell eine sinnvolle Zusammenfassung der Codeänderungen schreiben?

Wir wollten sehen, ob die Modelle unerwartete Leistungssprünge zeigen, wenn wir sie grösser machen. Stell dir vor, du hast einen kleinen Hund, der plötzlich zu einem riesigen Biest wird – wenn er jetzt Rückwärtssaltos machen kann, ist das erwähnenswert!

#Die Modellfamilie

Für unsere Experimente haben wir eine spezielle Gruppe von Modellen verwendet, die CodeGen-Familie. Diese Modelle gibt es in verschiedenen Grössen, von klein (350 Millionen Parameter) bis riesig (über 16 Milliarden Parameter). Wir wollten sehen, wie sich ihre Leistung verändert, wenn wir sie hochskalieren.

Wir dachten: "Lass uns vergleichen, wie gut diese Modelle in verschiedenen Grössen abschneiden und ob wir etwas Überraschendes finden."

#Aufgabe 1: Bugs beheben

Zuerst haben wir uns das Bugs beheben angeschaut. Wir haben eine Menge Beispielprobleme genommen und die Modelle gefragt, sie zu beheben. Wenn es gut gelaufen ist, hätten wir gehofft, dass das Modell besser wird, je grösser es wird.

Wir haben verschiedene Eingabeaufforderungen eingerichtet, die wie Anweisungen für das Modell sind. Zum Beispiel könnte eine Aufforderung sagen: "Bitte behebe diesen Code." Dann haben wir getestet, wie gut das Modell abgeschnitten hat.

Was haben wir gefunden? Nun, es stellte sich heraus, dass selbst die grössten Modelle nicht plötzlich besser im Bugs beheben wurden. Sie waren eher wie ein Büroangestellter, der immer den gleichen Ansatz verfolgt, egal wie viele Kaffeepausen er gemacht hat.

#Aufgabe 2: Codeübersetzung

Als Nächstes haben wir uns der Codeübersetzung gewidmet. Diese Aufgabe ist wie ein Übersetzer zu sein, aber anstelle von Sprachen sind es Programmiersprachen. Wir haben die Modelle gebeten, Java-Code in C-Code zu übersetzen.

Wieder erwarteten wir, dass die Leistung besser wird, je grösser die Modelle werden. Aber Spoiler-Alarm: Die Ergebnisse waren ziemlich enttäuschend. Wir haben keinen grossen Unterschied in der Qualität der Codeübersetzungen gesehen, egal wie gross die Modelle waren.

Es war, als würden wir jemanden, der kaum Spanisch spricht, bitten, es plötzlich zu meistern, nur weil er ein paar Telenovelas geschaut hat.

#Aufgabe 3: Generierung von Commit-Nachrichten

Schliesslich haben wir uns der Generierung von Commit-Nachrichten gewidmet. Commit-Nachrichten zu schreiben ist ein bisschen so, als würde man eine Postkarte darüber senden, was man im Urlaub gemacht hat. Sie sollten klar und informativ sein. Die Aufgabe war, zusammenzufassen, welche Änderungen am Code vorgenommen wurden.

Wir haben Aufforderungen für die Modelle festgelegt und ihre Ausgaben verglichen. Leider war die Leistung, genau wie bei den vorherigen Aufgaben, dürftig. Die Ergebnisse zeigten, dass selbst die grössten Modelle Schwierigkeiten hatten, anständige Commit-Nachrichten zu schreiben.

Es war, als hätten wir unseren Büroangestellten gebeten, ihre Woche zusammenzufassen, aber sie hätten einfach geschrieben: "Ich habe viel gearbeitet." Nicht sehr informativ!

#Einsichten und Erkenntnisse

Also, was haben wir aus alledem gelernt?

1. Keine Überraschungs-Leistungssteigerungen: Wir haben keine unerwarteten Leistungssprünge gesehen, als wir die Modelle grösser gemacht haben. Wenn überhaupt, waren die Verbesserungen schrittweise und vorhersehbar, was nicht die aufregende Geschichte ist, die wir uns erhofft hatten.

2. Wichtigkeit der Eingabeaufforderungen: Die Art und Weise, wie wir die Modelle gebeten haben, ihre Aufgaben zu erfüllen - unsere Eingabeaufforderungen - schien einen grösseren Einfluss auf ihre Fähigkeiten zu haben als ihre Grösse. Es ist, als würde man einem Koch sagen, er soll mit einem Rezept kochen; wenn das Rezept schlecht ist, schmeckt das Essen nicht gut, egal wie teuer die Zutaten sind.

3. Skalierung garantiert keine Fähigkeiten: Nur ein Modell grösser zu machen, ist kein Zaubertrick, der Superkräfte freischaltet. Wir fanden keine Hinweise darauf, dass die Modelle bei grösseren Grössen neue Fähigkeiten entwickelten, was Fragen aufwirft, ob wir sie weiter vergrössern sollten, ohne bessere Ergebnisse zu sehen.

#Fazit

Zusammenfassend begaben wir uns auf die Suche, ob die Grösse für LLMs bei Software Engineering-Aufgaben wichtig ist. Leider fanden wir keine klaren Anzeichen für emergente Fähigkeiten. Unsere Ergebnisse deuten darauf hin, dass Verbesserungen in der Leistung mehr mit der Art und Weise zusammenhängen, wie wir die Modelle ansprechen, als nur mit der Erhöhung ihrer Grösse.

Es scheint, als wäre die Reise, Superkräfte zu entdecken, eher ein Spaziergang durch ein gewöhnliches Büro gewesen. Während das Skalieren dieser Modelle in einigen Bereichen Vorteile haben mag, garantiert es keine dramatische Veränderung ihrer Fähigkeiten.

Als Forscher hoffen wir, dass unsere Ergebnisse zukünftige Studien dazu anregen können, wie man LLMs in Software Engineering-Aufgaben am besten nutzt. Schliesslich gibt es, egal ob wir es mit Superhelden zu tun haben oder nicht, noch viel über das Ausschöpfen ihres vollen Potenzials zu lernen – solange wir Grösse nicht mit Fähigkeiten verwechseln.

Lass uns weiter an diesen Modellen tüfteln, neue Eingabeaufforderungen ausprobieren, und vielleicht finden wir eines Tages den schimmernden Funken, der sie in die Superstars verwandelt, die wir uns wünschen!