Zum Hauptinhalt springen
TextGrad: Automatic "Differentiation" via TextMert Yuksekgonul et al.

Aufwärmübung: System mit zwei LLM-Aufrufen

Beispiel-Berechnungsgraph. In der traditionellen automatischen Differenzierung berechnen wir Gradienten, die mit der Kettenregel eine Richtung liefern, die die Variable im Hinblick auf einen nachgelagerten Verlust verbessern würde. Für ein einfaches Analogon betrachten wir das einfache System:

Prediction=LLM(Prompt+Question),Evaluation=LLM(Evaluation+Prediction),(1)\begin{array}{r}\mathrm{Prediction} = \mathrm{LLM}(\mathrm{Prompt} + \mathrm{Question}),\\ \mathrm{Evaluation} = \mathrm{LLM}(\mathrm{Evaluation} + \mathrm{Prediction}), \end{array} \quad (1)

a Neuronales Netz und Backpropagation unter Verwendung numerischer Gradienten

b Blackbox-KI-Systeme und Backpropagation unter Verwendung natürlicher Sprach-„Gradienten“

C 1 Analogie in Abstraktionen

MathematikPyTorchTextGrad
EingabexTensor(Bild)tg.Variable(Artikel)
Modelly = fθ(x)ResNet50( )tg.BlackboxLLM("Du bist ein Zusammenfasser.")
VerlustL(y, y) = ∑ y; log( y; )CrossEntropyLoss( )tg.TextLoss("Bewerte die Zusammenfassung.")
OptimiererGD(θ; θ) = θ - θL/θ0SGD(List(model.parameters( )))tg.TGD(List(model.parameters( )))

2 Automatische Differenzierung

PyTorch und TextGrad teilen dieselbe Syntax für Backpropagation und Optimierung.

d TextGrad zur Moleküloptimierung

e TextGrad zur Codeoptimierung

f TextGrad zur Optimierung von Behandlungsplänen

g TextGrad zur Prompt-Optimierung

Sie werden eine Reasoning-Frage beantworten. Denken Sie Schritt für Schritt. Die letzte Zeile Ihrer Antwort sollte das folgende Format haben: ‚Answer: ‘SVAULE‘, wobei VALUEl ein numerischer Wert ist.

Prompt bei der Initialisierung (Genauigkeit = 77,8 %)

Sie werden eine Reasoning-Frage beantworten. Listen Sie jedes Element und seine Menge in einem klaren und konsistenten Format auf, z. B. ‚- Element: Menge‘. Summieren Sie die Werte direkt aus der Liste und geben Sie eine prägnante Summation an. Stellen Sie sicher, dass die endgültige Antwort klar im Format ‚Answer: ‘SVAULE‘ angegeben wird, wobei VALUEl ein numerischer Wert ist. Überprüfen Sie die Relevanz jedes Elements für den Kontext der Anfrage und behandeln Sie mögliche Fehler oder Unklarheiten in der Eingabe. Überprüfen Sie die endgültige Zählung doppelt, um Genauigkeit zu gewährleisten.„

Prompt nach der Optimierung (Genauigkeit = 91,9 %)

Abbildung 1: Automatische „Differenzierung“ über Text (a, b). Die Backpropagation von Gradienten ist die treibende Kraft des Deep Learning. Für zusammengesetzte Systeme aus Blackbox-KI-Systemen haben wir keine Gradienten, aber wir können eine analoge Backpropagation für textbasiertes Feedback konstruieren, die die Grundlage von TEXTGRAD bildet. Abstraktionen in TEXTGRAD (c). Wir verwenden dieselben Abstraktionen und dieselbe Syntax wie PyTorch, damit unser Framework verallgemeinerbar und leicht erlernbar ist. Anwendungen von TEXTGRAD (d,e,f,g). In Abschnitt 3.4 optimieren wir molekulare Strukturen für Eigenschaften wie Arzneimittelähnlichkeit und Proteinbindungsaffinität (d). In Abschnitt 3.1 optimieren wir Lösungen für Programmierprobleme (e). In Abschnitt 3.5 optimieren wir Strahlentherapie-Behandlungspläne, um die Patientenergebnisse zu verbessern (f). In Abschnitt 3.3 optimieren wir Prompts, um das Reasoning von Sprachmodellen zu verbessern (g). Dabei bezeichnen wir den freien Parameter, der optimiert werden soll, nämlich den Prompt, mit Grün, und wir verwenden ++ zur Bezeichnung der Verkettung zweier Strings und verwenden LLM(x)\mathrm{LLM}(x), um xx als Prompt an ein Sprachmodell zu geben, um die Antwort zu sammeln. Wir verwenden die Kettennotation:

Prompt+Question→LLMEvaluationInstruction+Prediction→LLMEvaluation,(3)\mathrm{Prompt} + \mathrm{Question} \xrightarrow{\mathrm{LLM}} \mathrm{Evaluation} \mathrm{Instruction} + \mathrm{Prediction} \xrightarrow{\mathrm{LLM}} \mathrm{Evaluation}, \quad (3)

als eine weitere Möglichkeit, dieses System zu bezeichnen, wobei wir einen LLM-Aufruf machen, um eine Prediction für eine Question unter Verwendung eines Prompt zu erzeugen, und einen weiteren LLM-Aufruf, um diese Prediction zu bewerten.

Beispiel für die Gradientenberechnung. In diesem Beispielsystem instanziieren wir, um den Prompt im Hinblick auf die Evaluation zu verbessern, ein Analogon des Backpropagation-[19]-Algorithmus durch Folgendes:

Gradientenberechnung für den einfachen Graphen: Prompt →LLM\xrightarrow{\mathrm{LLM}} Prediction →LLM\xrightarrow{\mathrm{LLM}} Evaluation

∂Evaluation∂Prompt=∂Evaluation∂Prediction⋅∂Prediction∂Prompt=∇LLM(Prediction,Evaluation),(4)\frac{\partial\mathrm{Evaluation}}{\partial\mathrm{Prompt}} = \frac{\partial\mathrm{Evaluation}}{\partial\mathrm{Prediction}}\cdot \frac{\partial\mathrm{Prediction}}{\partial\mathrm{Prompt}} = \nabla_{\mathrm{LLM}}(\mathrm{Prediction},\mathrm{Evaluation}), \quad (4)

wobei wir ∇LLM\nabla_{\mathrm{LLM}} für den Gradientenoperator verwenden, wenn die Vorwärtsfunktion ein LLM-Aufruf ist. Insbesondere gibt diese Funktion natürlichsprachliches Feedback wie ‚This prediction can be improved by...‘ zurück, wobei das Feedback beschreibt, wie die Variable zu ändern ist, um das nachgelagerte Ziel zu verbessern, analog zu Gradienten in der Optimierung. Wir sammeln zuerst Feedback für die Variable Prediction unter Verwendung der Evaluation. Dann sammeln wir, gegeben dieses Feedback und den Aufruf (Prompt →LLM\xrightarrow{\mathrm{LLM}} Prediction), das Feedback zum Prompt.

„Beachten Sie, dass wir die Notation überladen, um sowohl Fälle zu bezeichnen, in denen die Ausgabevariable keine Nachfolger hat (z. B. ∇LLM(Prediction,Evaluation)\nabla_{\mathrm{LLM}}(\mathrm{Prediction},\mathrm{Evaluation})), als auch Fälle, in denen sie Nachfolger und somit Gradienten hat (z. B. ∇LLM(Prompt,Prediction,∂Loss∂Prediction)\nabla_{\mathrm{LLM}}(\mathrm{Prompt},\mathrm{Prediction},\frac{\partial\mathrm{Loss}}{\partial\mathrm{Prediction}})).

Im Folgenden findet sich eine flexible Möglichkeit, ∇LLM\nabla_{\mathrm{LLM}} zu instanziieren, um Feedback für ein einfaches System wie x→LLMy→LLMLx \xrightarrow{\mathrm{LLM}} y \xrightarrow{\mathrm{LLM}} \mathcal{L} zu sammeln:

Beispielimplementierung für den Gradientenoperator

\[\begin{array}{r l} & {\frac{\partial\mathcal{L}}{\partial x} = \nabla_{\mathrm{LLM}}(x,y,\frac{\partial\mathcal{L}}{\partial y})\triangleq \mathrm{"H e r e~i s~a~c o n v e r s a t i o n~w i t h~a n~L L M:~}\{x|y\} .}\\ & {\qquad +\qquad}\\ & {\qquad \mathrm{LLM}(\mathrm{H e r e~i s~a~c o n v e r s a t i o n~w i t h~a n~L L M:~}\{x|y\} .}\\ & {\qquad \mathrm{Below~a r e~t h e~c r i t i c i s m s~o n~\{y\} :}}\\ & {\qquad \left\{\frac{\partial\mathcal{L}}{\partial y}\right\}}\\ & {\qquad \mathrm{Explain~h o w~t o~i m p r o v e~\{x\} .),} \end{array} \quad (6)

wobei das Gradientenobjekt eine Kombination aus dem Kontext, in dem die Variable erscheint, und dem von einem LLMa\mathrm{LLM}^a erhaltenen Feedback ist, definiert analog zu Pryzant et al. [25]. Beachten Sie, dass dieser Operator nicht z. B. von der Anwendungsdomäne abhängt. Einmal implementiert, sind die Gradientenoperatoren für LLM-Aufrufe im gesamten Framework für alle Anwendungen festgelegt.

aDie genauen Prompts, die wir verwenden, unterscheiden sich, um Allgemeinheit und Flexibilität zu gewährleisten; wir verwenden diese Beispiele nur zur Veranschaulichung.

Beispieloptimierer. Beim standardmäßigen Gradientenabstieg wird der aktuelle Wert der Variable mit den Gradienten durch Subtraktion kombiniert, z. B.:

θnew=GradientDescent.step(θ,∂L∂θ)=θ−∂L∂θ.(7)\theta_{\mathrm{new}} = \mathrm{GradientDescent.step}(\theta ,\frac{\partial\mathcal{L}}{\partial\theta}) = \theta -\frac{\partial\mathcal{L}}{\partial\theta}. \quad (7)

In Fortführung der Analogie zur gradientenbasierten Optimierung verwenden wir Textual Gradient Descent (TGD):

Aktualisierung der Variable Prompt im einfachen Graphen über TGD.

Promptnew=TGD.step(Prompt,∂Evaluation∂Prompt).(8)\mathrm{Prompt}_{\mathrm{new}} = \mathrm{TGD.step}(\mathrm{Prompt},\frac{\partial\mathrm{Evaluation}}{\partial\mathrm{Prompt}}). \quad (8)

um die Parameter zu aktualisieren, in diesem Fall den Prompt. Insbesondere strebt der Optimierer, gegeben die aktuelle Variable und die Gradienten (Feedback), die wir für diese Variable gesammelt haben, danach, diese Variable zu aktualisieren.

Eine konkrete Möglichkeit, TGD zu instanziieren, ist die folgende:

Beispielimplementierung einer TGD-Iteration

xnew=TGD.step(x,∂L∂x)≜LLM(Below are the criticisms on {x};{∂L∂x}Incorporate the criticisms, and produce a new variable. ).(9)\begin{array}{r l} & {x_{\mathrm{new}} = \mathrm{TGD.step}(x,\frac{\partial\mathcal{L}}{\partial x})\triangleq \mathrm{LLM}(\mathrm{Below~are~the~criticisms~on~}\{x\} ;}\\ & {\qquad \left\{\frac{\partial\mathcal{L}}{\partial x}\right\}}\\ & {\qquad \mathrm{Incorporate~the~criticisms,~and~produce~a~new~variable.~).}} \end{array} \quad (9)

wobei xx die Variable ist, die wir verbessern möchten, und ∂L∂x\frac{\partial\mathcal{L}}{\partial x} das Feedback ist, das wir für die Variable während des Rückwärtsdurchlaufs erhalten habena. Ähnlich wie der Gradientenoperator hängt diese Funktion ebenfalls nicht von der Anwendungsdomäne ab, und die TGD-Implementierung ist in allen Verwendungen des Frameworks dieselbe.

aDie genauen Prompts, die wir verwenden, unterscheiden sich, um Allgemeinheit und Flexibilität zu gewährleisten; wir verwenden diese Beispiele nur zur Veranschaulichung.