Matthew McConaughey hat einen juristischen Versuch unternommen, sich gegen AI-Deepfakes zu wehren. Das US-Patent- und Markenamt hat ihm eine Reihe von Fragen gestellt, die ihm zugute gekommen sind, und die nun als Bundesgerichtshof tätig sind.​

McConaugheys Followers haben ein Video erstellt und es herausgefunden, um ihm den Rücken zu kehren und es zu tun. Das ist die Antwort von Hans Ikoniska.In Ordnung, in Ordnung, in Ordnung„aus dem Movie Dazed and Confused 1993.

Han har även skyddat frasen „Lebe einfach weiter, oder?“. Registrieren Sie sich bei der Simply Maintain Livin‘ Basis, der Organisation, die Sie mit Ihrer Frau Camila betreut.

Zu den Inhalten gehören:

• Video- und Videoclip von McConaughey, nachdem er sie gesehen hatte, und ihn bewegte
• Ljudinspelning av „In Ordnung, in Ordnung, in Ordnung“
• Ljudinspelning av „Leb einfach weiter, oder?“
• Olika Bilder von Hans Ansiktsuttryck und Gester

McConaughey ist ein echter KI-Investor, der tatsächlich in ElevenLabs investiert hat, und ist ein Experte für KI-Modelle, und er hat die KI-Model von Hans Röst mit seinem Sohn entwickelt.

Weitere Informationen:

Schauspieler McConaughey möchte sein Bild patentieren lassen, um es vor KI zu schützen

Matthew McConaughey nutzt einen cleveren juristischen Trick

Obwohl die MMD-Critic-Methode ein leistungsfähiges Werkzeug zur Datenzusammenfassung ist, ist ihre Anwendung und Abdeckung überraschend gering. Vielleicht liegt dies daran, dass es einfachere und etabliertere Methoden zur Datenzusammenfassung gibt (z. B. Ok-Medoide, siehe (1) oder einfacher die Wikipedia-Seite), oder vielleicht liegt es daran, dass (bisher) kein Python-Paket für die Methode existierte. Unabhängig davon sind die in der Originalpapier (2) rechtfertigen mehr Verwendung als MMD-Critic derzeit. Daher werde ich die MMD-Critic-Methode hier so klar wie möglich erklären. Ich habe auch eine Open-Supply-Python-Paket mit einer Implementierung der Technik, damit Sie sie einfach verwenden können.

Bevor wir uns mit der MMD-Critic-Methode selbst befassen, sollten wir uns zunächst einmal damit befassen, was wir damit erreichen wollen. Letztendlich möchten wir einen Datensatz nehmen und Beispiele finden, die repräsentativ für die Daten sind (Prototypen) sowie Grenzfallbeispiele, die unsere maschinellen Lernmodelle durcheinander bringen könnten (Kritik).

Es gibt viele Gründe, warum dies nützlich sein kann:

• Wir können eine sehr schöne zusammengefasste Ansicht unseres Datensatzes erhalten, indem wir sowohl stereotype als auch atypische Beispiele betrachten
• Wir können Modelle anhand der Kritikpunkte testen, um zu sehen, wie sie mit Randfällen umgehen (das ist aus offensichtlichen Gründen sehr wichtig).
• Obwohl es vielleicht nicht so nützlich ist, können wir Prototypen verwenden, um einen natürlich erklärbaren Ok-Means-ähnlichen Algorithmus zu erstellen, bei dem der dem neuen Datenpunkt am nächsten kommende Prototyp verwendet wird, um ihn zu kennzeichnen. Dann sind die Erklärungen einfach, da wir dem Benutzer nur den ähnlichsten Datenpunkt zeigen.
• Mehr

Siehe Abschnitt 6.3 in dieses Buch Weitere Informationen zu den Anwendungen finden Sie hier (und auch eine ausführliche Erklärung von MMD-Critic). Es genügt jedoch zu sagen, dass das Auffinden dieser Beispiele aus einer Vielzahl von Gründen nützlich ist. MMD-Critic ermöglicht uns dies.

Leider kann ich nicht behaupten, ein hyper-rigoroses Verständnis der maximalen mittleren Diskrepanz (MMD) zu haben, da ein solches Verständnis einen starken Hintergrund in der Funktionsanalyse erfordern würde. Wenn Sie über einen solchen Hintergrund verfügen, finden Sie das Papier, in dem das Maß eingeführt wurde Hier.

Vereinfacht ausgedrückt ist MMD jedoch eine Methode, um den Unterschied zwischen zwei Wahrscheinlichkeitsverteilungen zu bestimmen. Formal gilt für zwei Wahrscheinlichkeitsverteilungen P Und Qdefinieren wir den MMD der beiden als

Hier, F ist irgendein Veranstaltungsfläche — das heißt, jede Menge von Funktionen mit derselben Domäne und demselben Wertebereich. Beachten Sie auch, dass die Notation x~P bedeutet, dass wir behandeln X als ob es eine Zufallsvariable aus der Verteilung wäre P — das heißt, X Ist beschrieben durch P. Diese Formel findet additionally den größten Unterschied in den Erwartungswerten von X Und Y wenn sie durch eine Funktion aus unserem Raum transformiert werden F.

Das ist vielleicht ein wenig schwer zu verstehen, aber hier ist ein Beispiel. Angenommen, X Ist Uniform(0, 1) (d. h. eine Verteilung, die der Auswahl einer Zufallszahl zwischen 0 und 1 entspricht) und Y Ist Uniform(-1, 1) . Lassen wir auch F eine ziemlich einfache Familie mit drei Funktionen sein — f(x) = 0, f(x) = xUnd f(x) = x². Wenn wir über jede Funktion in unserem Raum iterieren, erhalten wir:

1. Im f(x) = 0 Fall, E(f(x)), wenn x ~ P ist 0, da egal was X wir wählen, f(x) wird 0 sein. Dasselbe gilt, wenn x ~ Q. Somit erhalten wir eine mittlere Diskrepanz von 0
2. Im f(x) = x In diesem Fall haben wir E(f(x)) = 0,5 für die P Fall und 0 für den Q Fall, additionally beträgt unsere mittlere Diskrepanz 0,5
3. Im f(x) = x² Fall stellen wir fest, dass

additionally erhalten wir im P-Fall

und im Q-Fall erhalten wir

daher ist unsere Diskrepanz in diesem Fall auch 0. Das Supremum über unserem Funktionenraum ist additionally 0,5, das ist additionally unser MMD.

Sie werden jetzt vielleicht ein paar Probleme mit unserem MMD bemerken. Es scheint stark von unserer Wahl des Funktionsraums abhängig zu sein und scheint auch sehr teuer (oder sogar unmöglich) zu berechnen für einen großen oder unendlichen Funktionsraum. Nicht nur das, es erfordert auch, dass wir unsere Verteilungen kennen P Und Qwas nicht realistisch ist.

Das letztere Downside lässt sich leicht lösen, da wir unsere MMD-Metrik so umschreiben können, dass sie Schätzungen von P und Q basierend auf unserem Datensatz verwendet:

Hier, unsere Xsind unsere Beispiele aus dem Datensatz aus Pund die jsind die Proben aus Q.

Die ersten beiden Probleme sind mit ein wenig zusätzlicher Mathematik lösbar. Ohne zu sehr ins Element zu gehen, stellt sich heraus, dass wenn F ist etwas, das man Reproduktion des Kernel-Hilbert-Raums (RKHS) wissen wir im Voraus, welche Funktion uns unseren MMD liefern wird. Es ist nämlich die folgende Funktion, genannt Zeugenfunktion:

Wo okay ist das Kernel (inneres Produkt) im Zusammenhang mit dem RKHS¹. Intuitiv „bezeugt“ diese Funktion die Diskrepanz zwischen P Und Q an dem Punkt X.

Wir müssen additionally nur einen ausreichend ausdrucksstarken RKHS/Kernel wählen — normalerweise wird der RBF-Kernel verwendet, der die Kernelfunktion hat

Dies führt im Allgemeinen zu recht intuitiven Ergebnissen. Hier ist beispielsweise die Darstellung der Zeugenfunktion mit dem RBF-Kernel, wenn sie (auf die gleiche Weise wie zuvor erwähnt, d. h. durch Ersetzen der Erwartungen durch eine Summe) auf zwei Datensätzen geschätzt wird, die aus Uniform(-0.5, 0.5) Und Uniform(-1, 1) :

Der Code zum Generieren der obigen Grafik lautet hier:

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
def rbf(v1, v2, sigma=0.5):
return np.exp(-(v2 - v1) ** 2/(2 * sigma**0.5))
def comp_wit_fn(x, d1, d2):
return 1/len(d1) * sum((rbf(x, dp) for dp in d1)) - 1/len(d2) * sum((rbf(x, dp) for dp in d2))
low1, high1 = -0.5, 0.5  # Vary for the primary uniform distribution
low2, high2 = -1, 1  # Vary for the second uniform distribution
# Generate information for the uniform distributions
data1 = np.random.uniform(low1, high1, 10000)
data2 = np.random.uniform(low2, high2, 10000)
# Generate a variety of x values for which to compute comp_wit_fn
x_values = np.linspace(min(low1 * 2, low2 * 2), max(high1 * 2, high2 * 2), 100)
comp_wit_values = (comp_wit_fn(x, data1, data2) for x in x_values)
sns.kdeplot(data1, label=f'Uniform({low1}, {high1})', shade='blue', fill=True)
sns.kdeplot(data2, label=f'Uniform({low2}, {high2})', shade='crimson', fill=True)
plt.plot(x_values, comp_wit_values, label='Witness Operate', shade='inexperienced')
plt.xlabel('Worth')
plt.ylabel('Density / Wit Fn')
plt.legend()
plt.present()

Die Idee hinter MMD-Critic ist nun ziemlich einfach: Wenn wir finden wollen okay Prototypen müssen wir den Satz von Prototypen finden, der am besten der Verteilung des ursprünglichen Datensatzes entspricht, die durch ihre quadrierten MMD gegeben ist. Mit anderen Worten, wir möchten eine Teilmenge finden P der Kardinalität okay unseres Datensatzes, der minimiert MMD²(F, X, P). Ohne zu sehr ins Element zu gehen, warum, ist das Quadrat MMD gegeben durch

Nachdem wir diese Prototypen gefunden haben, wählen wir als Kritikpunkte die Punkte aus, an denen die hypothetische Verteilung unserer Prototypen am stärksten von unserer Datensatzverteilung abweicht. Wie wir bereits gesehen haben, kann der Unterschied zwischen zwei Verteilungen an einem Punkt durch unsere Zeugenfunktion gemessen werden. Wir suchen additionally nur nach Punkten, die ihren absoluten Wert im Kontext von maximieren. X Und PMit anderen Worten definieren wir unseren Kritik-„Rating“ als

Oder in der brauchbareren Näherungsform:

Um die gewünschte Anzahl an Kritikpunkten zu finden, sagen wir M Von ihnen wollen wir einfach die Menge finden C der Größe M das maximiert

Um die Auswahl vielfältigerer Kritiken zu fördern, schlägt das Papier auch vor, einen Regularisierungsterm hinzuzufügen, der dazu anregt, dass ausgewählte Kritiken so weit wie möglich auseinander liegen. Der im Papier vorgeschlagene Regularisierer ist der Log-Determinanten-Regularisierer, obwohl dies nicht erforderlich ist. Ich werde hier nicht näher darauf eingehen, da dies nicht kritisch ist, aber das Papier schlägt vor, (6) zu lesen.².

Damit realisieren wir eine äußerst naiv MMD-Kritik ohne Kritik-Regularisierung wie folgt (verwenden Sie dies NICHT):

import math
import itertools
def euc_distance(p1, p2):
return math.sqrt(sum((x - y) ** 2 for x, y in zip(p1, p2)))
def rbf(v1, v2, sigma=0.5):
return math.exp(-euc_distance(v1, v2) ** 2/(2 * sigma**0.5))
def mmd_sq(X, Y, sigma=0.5):
sm_xx = 0
for x in X:
for x2 in X:
sm_xx += rbf(x, x2, sigma)
sm_xy = 0
for x in X:
for y in Y:
sm_xy += rbf(x, y, sigma)
sm_yy = 0
for y in Y:
for y2 in Y:
sm_yy += rbf(y, y2, sigma)
return 1/(len(X) ** 2) * sm_xx 
- 2/(len(X) * len(Y)) * sm_xy 
+ 1/(len(Y) ** 2) * sm_yy
def select_protos(X, n, sigma=0.5):
min_score, min_sub = math.inf, None
for subset in itertools.mixtures(X, n):
new_mmd = mmd_sq(X, subset, sigma)
if new_mmd < min_score:
min_score = new_mmd
min_sub = subset
return min_sub
def criticism_score(criticism, prototypes, X, sigma=0.5):
return abs(1/len(X) * sum((rbf(criticism, x, sigma) for x in X))
- 1/len(prototypes) * sum((rbf(criticism, p, sigma) for p in prototypes)))
def select_criticisms(X, P, n, sigma=0.5):
candidates = (c for c in X if c not in P)
max_score, crits = -math.inf, ()
for subset in itertools.mixtures(candidates, n):
new_score = sum((criticism_score(c, P, X, sigma) for c in subset))
if new_score > max_score:
max_score = new_score
crits = subset
return crits

Die obige Implementierung ist so unpraktisch, dass ich bei der Ausführung nicht in der Lage conflict, in einem Datensatz mit 25 Punkten in angemessener Zeit 5 Prototypen zu finden. Dies liegt daran, dass unsere MMD-Berechnung O(max(|X|, |Y|)²)und die Iteration über jede Teilmenge der Länge n ist O(C(|X|, n)) (wobei C die Auswahlfunktion ist), was zu einer furchtbaren Laufzeitkomplexität führt.

Wenn wir nicht auf effizientere Berechnungsmethoden zurückgreifen (z. B. reine Numpy/Numexpr/Matrix-Berechnungen anstelle von Schleifen/was auch immer) und wiederholte Berechnungen zwischenspeichern, können wir auf theoretischer Ebene einige Optimierungen vornehmen. Erstens ist die offensichtlichste Verlangsamung, die wir haben, das Schleifen über die C(|X|, n) Teilmengen in unseren Prototyp- und Kritikmethoden. Stattdessen können wir eine Näherung verwenden, die eine Schleife durchläuft N mal, wobei wir jedes Mal gierig den besten Prototypen auswählen. Dadurch können wir unseren Prototypenauswahlcode ändern in

def select_protos(X, n, sigma=0.5):
protos = ()
for _ in vary(n):
min_score, min_proto = math.inf, None
for cand in X:
if cand in protos:
proceed
new_score = mmd_sq(X, protos + (cand), sigma)
if new_score < min_score:
min_score = new_score
min_proto = cand
protos.append(min_proto)
return protos

und ähnliches gilt für die Kritik.

Es gibt noch ein weiteres wichtiges Lemma, das dieses Downside viel optimierbarer macht. Es stellt sich heraus, dass wir die Kostenfunktion sehr effizient mit Matrixoperationen berechnen können, indem wir unsere Prototypauswahl in ein Minimierungsproblem umwandeln und den Kosten einen Regularisierungsterm hinzufügen. Ich werde hier nicht näher darauf eingehen, aber Sie können sich für weitere Einzelheiten das Originalpapier ansehen.

Nachdem wir nun die MMD-Critic-Methode verstanden haben, können wir endlich damit experimentieren! Sie können sie installieren, indem Sie

pip set up mmd-critic

Die Implementierung im Paket selbst ist viel schneller als die hier vorgestellte, additionally keine Sorge.

Wir können ein ziemlich einfaches Beispiel mit Blobs wie diesen ausführen:

from sklearn.datasets import make_blobs
from mmd_critic import MMDCritic
from mmd_critic.kernels import RBFKernel
n_samples = 50  # Whole variety of samples
facilities = 4       # Variety of clusters
cluster_std = 1 # Commonplace deviation of the clusters
X, _ = make_blobs(n_samples=n_samples, facilities=facilities, cluster_std=cluster_std, n_features=2, random_state=42)
X = X.tolist()
# MMD critic with the kernel used for the prototypes being an RBF with sigma=1,
# for the criticisms one with sigma=0.025
critic = MMDCritic(X, RBFKernel(1), RBFKernel(0.025))
protos, _ = critic.select_prototypes(facilities)
criticisms, _ = critic.select_criticisms(10, protos)

Wenn wir dann die Punkte und Kritikpunkte auflisten, erhalten wir

Sie werden feststellen, dass ich die Möglichkeit bereitgestellt habe, einen separaten Kernel für die Auswahl von Prototypen und Kritiken zu verwenden. Dies liegt daran, dass ich festgestellt habe, dass insbesondere die Ergebnisse für Kritiken äußerst empfindlich gegenüber dem Sigma-Hyperparameter. Dies ist eine bedauerliche Einschränkung der MMD Critic-Methode und der Kernelmethoden im Allgemeinen. Insgesamt habe ich gute Ergebnisse erzielt, indem ich für Prototypen ein großes Sigma und für Kritiken ein kleineres verwendet habe.

Wir können natürlich auch einen komplizierteren Datensatz verwenden. Hier ist zum Beispiel die Methode, die bei MNIST verwendet wurde³:

from sklearn.datasets import fetch_openml
import numpy as np
from mmd_critic import MMDCritic
from mmd_critic.kernels import RBFKernel
# Load MNIST information
mnist = fetch_openml('mnist_784', model=1)
photos = (mnist('information').astype(np.float32)).to_numpy() / 255.0
labels = mnist('goal').astype(np.int64)
critic = MMDCritic(photos(:15000), RBFKernel(2.5), RBFKernel(0.025))
protos, _ = critic.select_prototypes(40)
criticisms, _ = critic.select_criticisms(40, protos)

was uns zu den folgenden Prototypen bringt

und Kritik

Ziemlich cool, oder?

Und das conflict es auch schon mit der MMD-Critic-Methode. Sie ist im Kern recht einfach und lässt sich intestine verwenden, abgesehen davon, dass man mit dem Sigma-Hyperparameter herumspielen muss. Ich hoffe, dass das neu veröffentlichte Python-Paket ihr mehr Verwendungsmöglichkeiten bietet.

Bei Fragen wenden Sie sich bitte an mchak@calpoly.edu. Alle Bilder stammen vom Autor, sofern nicht anders angegeben.

Um die hier vorgenommenen Änderungen zu verstehen, müssen wir zunächst den Key-Worth-Cache besprechen. Innerhalb des Transformators haben wir 3 Vektoren, die für die Funktion der Aufmerksamkeit entscheidend sind – Schlüssel, Wert und Abfrage. Auf einer hohen Ebene ist Aufmerksamkeit die Artwork und Weise, wie wir wichtige Informationen über die vorherigen Token an den aktuellen Token weitergeben, damit dieser den nächsten Token vorhersagen kann. Im Beispiel der Selbstaufmerksamkeit mit einem Kopf multiplizieren wir den Abfragevektor des aktuellen Tokens mit den Schlüsselvektoren der vorherigen Token und normalisieren dann die resultierende Matrix (die resultierende Matrix nennen wir das Aufmerksamkeitsmuster). Wir multiplizieren nun die Wertvektoren mit dem Aufmerksamkeitsmuster, um die Aktualisierungen für jeden Token zu erhalten. Diese Daten werden dann zur Einbettung des aktuellen Tokens hinzugefügt, sodass sie nun den Kontext haben, um zu bestimmen, was als Nächstes kommt.

Wir erstellen das Aufmerksamkeitsmuster für jedes einzelne neue Token, das wir erstellen. Während sich die Abfragen ändern, bleiben die Schlüssel und Werte konstant. Daher versuchen die aktuellen Architekturen, die Rechenzeit zu reduzieren, indem sie die Schlüssel- und Wertevektoren zwischenspeichern, während sie in jeder nachfolgenden Aufmerksamkeitsrunde generiert werden. Dieser Cache wird als Schlüssel-Wert-Cache bezeichnet.

Obwohl Architekturen wie Nur-Encoder- und Encoder-Decoder-Transformatormodelle erfolgreich waren, gehen die Autoren davon aus, dass die oben gezeigte Autoregression und die Geschwindigkeit, die sie ihren Modellen ermöglicht, der Grund dafür ist, dass Nur-Decoder-Modelle heutzutage am häufigsten verwendet werden.

Um die YOCO-Architektur zu verstehen, müssen wir zunächst verstehen, wie ihre Schichten aufgebaut sind.

Für eine Hälfte des Modells verwenden wir eine Artwork von Aufmerksamkeit, um die Vektoren zu generieren, die zum Füllen des KV-Cache erforderlich sind. Sobald es in die zweite Hälfte übergeht, wird der KV-Cache ausschließlich für die Schlüssel- bzw. Wertevektoren verwendet und generiert nun die Ausgabetoken-Einbettungen.

Diese neue Architektur erfordert zwei Arten von Aufmerksamkeit: effiziente Selbstaufmerksamkeit und gegenseitige Aufmerksamkeit. Im Folgenden werden wir auf beide Arten eingehen.

Environment friendly Self-Consideration (ESA) ist darauf ausgelegt, einen konstanten Inferenzspeicher zu erreichen. Anders ausgedrückt: Wir möchten, dass die Cache-Komplexität nicht von der Eingabelänge abhängt, sondern von der Anzahl der Schichten in unserem Block. In der folgenden Gleichung haben die Autoren ESA abstrahiert, aber der Relaxation des Selbstdecoders ist konsistent, wie unten gezeigt.

Gehen wir die Gleichung Schritt für Schritt durch. X^l ist unsere Token-Einbettung und Y^l ist eine Zwischenvariable, die zur Generierung der nächsten Token-Einbettung X^l+1 verwendet wird. In der Gleichung ist ESA Environment friendly Self-Consideration, LN ist die Schichtnormalisierungsfunktion – die hier immer Root Imply Sq. Norm warfare (RMSNorm ), und schlussendlich SwiGLU. SwiGLU wird wie folgt definiert:

Hier swish = x*sigmoid (Wg * x)wobei Wg ein trainierbarer Parameter ist. Wir finden dann das elementweise Produkt (Hadamard-Produkt) zwischen diesem Ergebnis und X*W1, bevor wir das gesamte Produkt mit W2 multiplizieren. Das Ziel mit SwiGLU besteht darin, eine Aktivierungsfunktion zu erhalten, die unterschiedliche Informationsmengen bedingt durch die Schicht an das nächste Token weiterleitet.

Nachdem wir nun wissen, wie der Selbstdecoder funktioniert, wollen wir uns die beiden Möglichkeiten ansehen, die die Autoren zur Implementierung von ESA in Betracht zogen.

Zunächst betrachteten sie das sogenannte Gated Retention. Retention und Self-Consideration sind sich zugegebenermaßen sehr ähnlich. Die Autoren des Artikels „Retentive Community: A Successor to Transformer for Giant Language Fashions“ sagen, dass der Hauptunterschied in der Aktivierungsfunktion liegt – Retention entfernt Softmax und ermöglicht eine rekurrente Formulierung. Sie verwenden diese rekurrente Formulierung zusammen mit der Parallelisierbarkeit, um die Speichereffizienz zu steigern.

Um in die mathematischen Particulars einzutauchen:

Wir haben unsere typischen Matrizen von Q, Ok und V – jede davon wird mit den lernbaren Gewichten multipliziert, die mit jeder Matrix verknüpft sind. Dann finden wir das Hadamard-Produkt zwischen den gewichteten Matrizen und dem Skalar Θ. Das Ziel bei der Verwendung von Θ ist es, einen exponentiellen Abfall zu erzeugen, während wir dann die D-Matrix verwenden, um bei der gelegentlichen Maskierung (Verhindern, dass zukünftige Token mit aktuellen Token interagieren) und Aktivierung zu helfen.

Gated Retention unterscheidet sich von Retention über den γ-Wert. Hier wird die Matrix Wγ verwendet, um unsere ESA datengesteuert zu machen.

Sliding Window ESA führt die Idee ein, zu begrenzen, wie viele Token das Aufmerksamkeitsfenster beachten soll. Während bei normaler Selbstaufmerksamkeit alle vorherigen Token in irgendeiner Weise beachtet werden (selbst wenn ihr Wert 0 ist), wählen wir bei Sliding Window ESA einen konstanten Wert C, der die Größe dieser Matrizen begrenzt. Dies bedeutet, dass der KV-Cache während der Inferenzzeit auf eine konstante Komplexität reduziert werden kann.

Um noch einmal in die Mathematik einzutauchen:

Wir lassen unsere Matrizen anhand ihrer entsprechenden Gewichte skalieren. Als Nächstes berechnen wir den Kopf ähnlich wie die Multi-Head-Aufmerksamkeit, wobei B sowohl als kausale Karte fungiert als auch sicherstellt, dass nur die Token C zurück beachtet werden.

Ausgehend von einer hohen Ebene benötigen Transformer zwei Informationen für Eingaben: die Token-Einbettungen und die Positionskodierungen. Token-Einbettungen sind Dinge wie tiktoken Dabei verwenden sie eine feste Vokabulargröße, um für jedes Token einen eindeutigen Schlüssel zu generieren. Durch Coaching lernt das Modell dann die Abfrage und den Wert für jedes Token, sodass es mit den Informationen erfolgreich das nächste Token generieren kann.

Zusätzlich zu den Einbettungen benötigen wir auch Positionsinformationen, um dem LLM mitzuteilen, wo in einem Satz sich das Token befindet. Die obigen Gleichungen zeigen die am stärksten abstrahierte Sichtweise für die Weitergabe der Positionsinformationen. Wir haben 3 Funktionen, 1 für jedes Ingredient des Tokens, und 2 Worteinbettungsvektoren (XM und XNWo M Und N bedeuten die unterschiedlichen Dimensionen, die jeder Vektor hat).

Ein Ansatz besteht darin, einfach für jedes angezeigte Token einen neuen Vektor zu erstellen, sodass die Place vollkommen eindeutig ist. Der Nachteil hierbei ist natürlich, dass der eindeutige Vektor es dem Modell erschwert, Ähnlichkeiten in den Trainingsdaten zu erkennen, was die Leistung beeinträchtigt.

Ein sekundärer Ansatz wäre, für jedes Token einen Vektor zu erstellen, der einen Ähnlichkeitsfaktor mit anderen Vektoren aufweist. Auf diese Weise erfassen wir immer noch Informationen darüber, wie ähnlich eine State of affairs einer anderen bestimmten State of affairs ist. Da wir jedoch Kollisionen dieser Vektoren erzeugen können, kann diese Methodik zu Verwirrung führen.

Wie finden wir die beste Kombination dieser Ansätze?

Die Branche hat sich weitgehend auf RoPE konzentriert, um das Beste aus beiden Welten herauszuholen. Ohne zu tief in die Mathematik einzusteigen, verwendet RoPE Sinusfunktionen, um den Token Positionswerte zuzuweisen. Da sich Sinusfunktionen von Natur aus wiederholen, gibt es einige Positionswerte, die anderen sehr ähnlich sind. Folglich haben ähnliche Elemente einen quantitativen Wert, der angibt, wie ähnlich sie sind.

Wie Sie der obigen Gleichung entnehmen können, haben wir eine dünn besetzte Matrix, die mit verschiedenen Funktionen gefüllt ist, die sich um den Wert θ drehen, der übergeben wird, um alle Positionskodierungen in Beziehung zu halten.

Der genaue Zusammenhang dieser θ ist unten dargestellt:

Der kritischste Teil dieser Gleichung für die Kontextgröße ist der Wert 10.000. Da wir versucht haben, größere Kontexte mit nicht unendlichen Zahlenbereichen zu erstellen, ist der Wert von 10.000 zu einem begrenzenden Faktor geworden – schließlich gibt es nur eine begrenzte Anzahl von Vektoren, die Sie mit dieser Zahl als Foundation erstellen können.

Sie könnten zwar ein neues Modell mit einem größeren Basiswert für Ihre Positionskodierungen von Grund auf trainieren, es gibt jedoch einige Gründe, die die Allgemeinheit davon abhalten, dies zu tun. Erstens ist die Schulung von Grund auf mit enormen Kosten verbunden. Da derzeit nur wenige Organisationen auf der Welt über die Ressourcen dafür verfügen, ist die Belastung dafür groß. Zweitens ist es unglaublich schwierig, eine große Menge an qualitativ hochwertigem Langtext zu finden. Da für das Coaching Billionen von Token erforderlich sind, ist die Suche nach qualitativ hochwertigen Langdaten in diesem Umfang eine große Herausforderung.

Daher haben Forscher verschiedene Methoden zur Ausweitung von RoPE auf größere Thetas vorgeschlagen.

Die erste Methode ist die lineare Positionsinterpolation (PI), bei der Sie die Anzahl der möglichen Positionen erweitern können, indem Sie Theta um einen Wert λ reduzieren. Die folgende Gleichung verwendet Beta, um die θ^(2/d)-Gleichung darzustellen, die wir verwendet haben, um alle Thetas von zuvor zu verbinden.

Obwohl dies funktioniert, stellen die Autoren des Papiers fest, dass es einen Crowding-Effekt gibt, bei dem einige der Informationen nach der Reduzierung verloren gehen.

Die zweite Methode ist YaRN (One more RoPE extensioN methodology), bei der wir die RoPE-Dimensionen in drei Gruppen unterteilen und jeder von ihnen einen anderen linearen Faktor zuweisen. Die Grundidee besteht darin, dass häufig vorkommende Token nicht verändert werden sollten (ihr λ := 1) und diejenigen, die seltener vorkommen, verändert werden. Aus der folgenden Grafik können wir ersehen, dass dies bei der Erweiterung auf eine Kontextlänge von bis zu 128 KB intestine funktioniert. Hier geht es um die Festlegung der Gruppierungen. Die Gruppen werden von Menschen bestimmt und somit kann es zu suboptimalen Entscheidungen kommen, die die Leistung mindern.

Obwohl sowohl YaRN als auch Linear Projection (PI) funktionieren, weisen sie Einschränkungen auf, die sie behindern. Lengthy RoPE nutzt das Beste aus jeder Idee und findet einen cleveren Weg, sie zu kombinieren.

Die Forscher von Lengthy RoPE erkannten, dass sie zur Verbesserung früherer Methoden zwei Schlüsselideen einführen müssten: (1) die Verteilung von gutem λ ist unregelmäßig, daher ist die Suche nach λ besser als die Annahme einer korrekten Antwort, und (2) es gibt eine Teilmenge von Token, deren Place einfach nicht geändert werden sollte.

Beide Ergebnisse sind in der folgenden Formel enthalten. Um das optimale λ zu finden, erstellten sie eine Verlustfunktion, die sie minimieren konnten. Die folgende Formel ist eine neu formatierte Model von RoPE mit dem Ergebnis 𝕀 und ( n/ βich ) stellt die Skalierung unseres Positionsvektors dar. Wenn sie den kleinsten Verlust finden, wählen sie das entsprechende λ.

Mit der 𝕀-Step-Funktion aktualisieren wir die Teilmenge der Token, die nicht geändert werden sollten. Indem wir den Wert 1 wählen, signalisieren wir, dass die Positionskodierungen dort gleich bleiben sollten. Um die Suche einzuschränken, wurden nur n-hat-Werte von berücksichtigt {0, 1, 2, 4, 8, 12, 16, 20, 24, 28, 32, 64, 128, 256}. Je höher der Wert von n-hat, desto mehr Token behalten ihre ursprüngliche Positionscodierung.

Nachdem wir uns nun mit der Theorie befasst haben, wollen wir uns die Ergebnisse ansehen!

Lengthy RoPE funktioniert sowohl ohne Feinabstimmung als auch mit. Die obige Grafik zeigt die Leistung von LongRoPE bei Anwendung auf LLaMA2–7B. Der ursprüngliche Kontext für dieses Modell conflict 4k. Indem sie das optimale λ fanden, konnten sie das Kontextfenster auf 32.000 Token erweitern, ohne dass sich die Verwirrung merklich änderte! Das Unglaubliche daran ist, dass der für eine solche Änderung erforderliche Rechenaufwand im Vergleich zu den Kosten für die Feinabstimmung nahezu vernachlässigbar ist. Eine 8-fache Erweiterung ohne großen Rechenaufwand ist unglaublich.

Um eine enorme Erweiterung zu erreichen, ist eine Kombination aus Feinabstimmung und der Suche nach dem optimalen λ erforderlich. Die Forscher in der Arbeit erreichten nach dieser Methodik eine 512-fache Erweiterung. Sie haben das Modell zunächst auf eine Größe von 128 KB und 256 KB gebracht. Sie haben eine Feinabstimmung für 400 Schritte bei 128k vorgenommen und sind dann dazu übergegangen, die 256k-Faktoren für weitere 600 Schritte zu verwenden. Da dies besser funktionierte als nur die direkte Feinabstimmung von 256k, scheint es, dass das Erlernen einer allgemeineren Verteilung statt nur einer der skalierten eine bessere Leistung bringt. Anschließend optimierten sie erneut für das beste λ und erreichten ein Kontextfenster von 2048 KB, eine Steigerung von 512 gegenüber dem ursprünglichen 4 KB-Kontextfenster!

Eine der Schwierigkeiten eines größeren Kontexts ist ein Leistungsverlust bei Aufgaben mit kleinen Kontexten. Dieses Verhalten wurde schon früher beobachtet und die Theorie besagt, dass die Daten zu Beginn auf einen kleineren Bereich komprimiert werden, was zu einem gewissen Aufmerksamkeitsverlust führt.

Sie lösten dieses Drawback im 2048k-Kontextfenstermodell, indem sie das ideale λ für kürzere Längen fanden (in der Arbeit waren dies 4k und 8k). Wenn während der Inferenz festgestellt wird, dass der Kontext klein ist, geht das LLM dynamisch dazu über, das kleinere λ für die Positionskodierungsdaten zu verwenden.

LLMs sind hervorragend im Denken und überraschen uns immer wieder mit ihren Anwendungen in der realen Welt. Mit einem größeren Kontextfenster, insbesondere einem, das zu begrenzten Kosten und dennoch hoher Leistung erhältlich ist, werden ihre Anwendungen nur wachsen.

Eine interessante Frage ist, ob dynamische Positionskodierungsberechnungen der Weg der Zukunft sind. Wenn Sie mehrere Positionscodierungen optimieren und eine qualitativ hochwertige Leistung für 2 λs erzielen können, verfügen wir möglicherweise über ein Modell, das zur Inferenzzeit nahtlos zwischen mehreren λs wechseln kann.

Eines der Dinge, die ich am LLM-Bereich am spannendsten finde, ist die Möglichkeit, Daten zu sichten. Während das Web bei der Demokratisierung des Zugangs zu Informationen hervorragende Arbeit geleistet hat, hat es leider auch unser Leben mit Lärm überschwemmt. Es gibt viele Dinge, die uns on-line gezeigt werden und die für uns quick keine Konsequenzen haben. Mit einem Instrument, das die wichtigen Informationen aus dem Alltäglichen und sogar Schädlichen herausfiltern kann, können wir das Potenzial des Internets voll ausschöpfen.

Mit größeren Kontextfenstern kann die Fähigkeit des LLM, Informationen zusammenzufassen und zu verdichten, noch effektiver genutzt werden. Es könnte sogar eine Zeit kommen, in der große Fortschritte dadurch erzielt werden, dass LLMs zwei scheinbar unterschiedliche Informationssätze erhalten und sie etwas Neues herausfinden lassen, das angesichts der Prämissen in jedem Satz begründet werden kann.

Es ist eine aufregende Zeit zum Bauen.