Die Größe großer Modelle erhöht die Leistung weiter, aber auch die Nachfrage nach effizienteren und kompakteren Modellen wächst. Die Reduzierung der Größe des Modells, ohne Kernfunktionen zu verlieren, ist jedoch eine komplexe Aufgabe.
Techniken wie Quantisierung und Schnitt werden häufig verwendet, um die Modellgröße zu reduzieren, während Methoden wie Wissensdestillation oder Übertragungslernen dazu beitragen, verlorene Funktionen während des Reduktionsprozesses zu erhalten oder wiederherzustellen.
unter ihnen ist Beschneidung eine der effektivsten Strategien, um die Größe des Modells zu verringern. Im Gegensatz zur Quantisierung von vereinfachten numerischen Darstellungen umfasst das Beschneiden bestimmte Teile des Modells wie Neuronen oder ganze Schichten. Diese Effektivität gilt jedoch mit Kosten: Das Beschneiden ist schwer korrekt zu bewerben. Sie müssen nicht nur den Teil des zu beschnittenen Modells bestimmen, sondern Sie müssen auch die zu entfernenden Elemente sorgfältig auswählen, um die Auswirkungen auf die Funktionen des Modells zu minimieren.
Dieser Artikel konzentriert sich auf strukturierte Breitenbeschnitte (ausgewählte Neuronen entfernen) und zeigt, wie man es effektiv auf MLP -Schichten mit GLU -Strukturen (Gated Linear Unit) anwendet. Wenn Sie den umrissenen Schritten befolgen, werden Sie verstehen, wie das Beschneiden die Modellgröße erheblich reduzieren kann und gleichzeitig die Fähigkeit beibehält, kohärente Ausgabe zu erzeugen und in kritischen Benchmarks gut abzuschneiden.
Wie bereits erwähnt, beinhaltet das Beschneiden die Entfernung des Teils, der als den kleinsten zur endgültigen Ausgabe des Modells beiträgt. Durch die sorgfältige Auswahl dieser weniger wichtigen Komponenten zielt das Beschneiden darauf ab, ein effizienteres Modell mit weniger Parametern und geringeren Rechenanforderungen zu erstellen, ohne seine Kernfunktionen zu beeinträchtigen.
Die Hauptherausforderung des Beschneidens besteht darin, zu entscheiden, welche Teile des Modells entfernt werden sollen. Nicht alle Teile des Modells haben den gleichen Effekt auf die Leistung.
Um dies zu veranschaulichen, untersuchen wir die Struktur des in diesem Artikel verwendeten Modell: Lama 3.2–1b.
<code>LlamaForCausalLM(
(model): LlamaModel(
(embed_tokens): Embedding(128256, 2048)
(layers): ModuleList(
(0-15): 16 x LlamaDecoderLayer(
(self_attn): LlamaSdpaAttention(
(q_proj): Linear(in_features=2048, out_features=2048, bias=False)
(k_proj): Linear(in_features=2048, out_features=512, bias=False)
(v_proj): Linear(in_features=2048, out_features=512, bias=False)
(o_proj): Linear(in_features=2048, out_features=2048, bias=False)
(rotary_emb): LlamaRotaryEmbedding()
)
(mlp): LlamaMLP(
(gate_proj): Linear(in_features=2048, out_features=8192, bias=False)
(up_proj): Linear(in_features=2048, out_features=8192, bias=False)
(down_proj): Linear(in_features=8192, out_features=2048, bias=False)
(act_fn): SiLU()
)
(input_layernorm): LlamaRMSNorm((2048,), eps=1e-05)
(post_attention_layernorm): LlamaRMSNorm((2048,), eps=1e-05)
)
)
(norm): LlamaRMSNorm((2048,), eps=1e-05)
(rotary_emb): LlamaRotaryEmbedding()
)
(lm_head): Linear(in_features=2048, out_features=128256, bias=False)
)</code>Bei der Untersuchung der Struktur können wir drei Hauptmodule identifizieren, die als Beschneidungsziele verwendet werden können: Einbettung, Selbstbekämpfungsmechanismus und MLP-Schicht. Um zu entscheiden, welche Teile im Mittelpunkt des Beschneidungsprozesses stehen sollten, müssen die potenziellen Vorteile und möglichen Auswirkungen verstehen.
Der erste Schritt besteht darin, die Platzgröße zu bewerten, die diese Teile im Modell einnehmen, um die potenzielle Reduzierung zu verstehen.
Einbettung und Ausgabeschichten (Einbetten_Tokens, lm_head):
Selbstauffälligkeitsmechanismus (self_attn):
MLP -Schicht (MLP):
Wir können sehen, dass MLP -Schichten mehr als 50% der Modellgröße belegen, sodass sie explizite Beschneidungskandidaten sind. Es ist jedoch wichtig, den Beitrag jedes Abschnitts zum Modellverhalten zu verstehen, bevor diese Entscheidung getroffen wird.
Die Einbindung der Schicht ist für die Konvertierung der Eingaben in dichte Vektordarstellungen verantwortlich, die das Modell effektiv verarbeiten kann. Das Beschneiden von Einbetten von Schichten kann dazu führen, dass das Modell die Fähigkeit verliert, bestimmte Wörter zu verstehen, oder zumindest die Fähigkeit zu verringern, Vektoren zu erstellen, die die Bedeutung der Eingabemantik korrekt erfassen. Wenn Sie beispielsweise ein hochspezifisches Modell erstellen möchten, das nur sehr spezifische Teile seines Eingangsvokabulars verwendet (z. B. ein Modell für die finanzielle oder medizinische Analyse), kann das Beschneiden dieser Schicht eine Option sein.
Aufmerksamkeitsmechanismus ermöglicht es dem Modell, sich auf die relevantesten Teile der Eingabebereich bei der Verarbeitung jedes Markers zu konzentrieren. Es berechnet die gewichtete Wertschöpfungswerte zwischen jedem Markerpaar in der Eingabebestellungssequenz, sodass das Modell den Kontext erfassen und sich auf relevante Informationen konzentriert. Das Beschneiden dieses Abschnitts reduziert die Fähigkeit des Modells, Aufgaben auszuführen, die ein breites Verständnis des Eingabekontexts erfordern, wie z. B. Textzusammenfassung oder Übersetzung. Es beeinflusst auch die Konsistenz des generierten Textes.
MLP -Schicht verbessern zusammen mit Aufmerksamkeitsmechanismen die Fähigkeit des Modells, komplexe Muster durch eine Reihe von Datenerweiterung und Kontraktion zu verstehen. Das Beschneiden dieses Abschnitts begrenzt die Reaktion des Modells auf Aufgaben, die während des Trainings nicht gesehen oder nicht behandelt werden. Mit anderen Worten, es reduziert die Generalisierungsfähigkeit des Modells und seine Fähigkeit, kohärente Reaktionen auf unbekannte Eingaben zu liefern.
Sobald Sie entschieden haben, auf welchen Teil des Modells Sie abzielen möchten, besteht der nächste Schritt darin, zu bestimmen, ob Sie Breitenbeschnitte (ein einzelnes Neuron entfernen) oder Tiefenbeschnitten (Entfernen der gesamten Schicht) durchführen sollen.
Wie Sie sehen, sind Schnittmodelle ein ziemlich komplexer Prozess, der viele Entscheidungen umfasst. Sie müssen nicht nur die Fähigkeiten des generierten Modells, sondern auch seine Schulungsfähigkeiten bewerten. Diese Modelle sind so konzipiert, dass sie fein abgestimmt sind und werden häufig für bestimmte Aufgaben verwendet, sodass sie für die spezifischen Aufgaben effizienter sind, die sie erzeugen, als das zugrunde liegende Modell.
GLU -Architekturen (Gated Linear Unit) werden häufig in modernen neuronalen Netzwerken verwendet, darunter Lama, Gemma, Mistral, Qwen und ähnliche Großsprachenmodelle. GLU führt einen Element-by-Element-Gating-Mechanismus ein, mit dem das Modell den Informationsfluss selektiv filtern und steuern kann. Diese Architektur besteht aus Schichtpaaren, normalerweise: GATE_PROJ, UP_PROJ und DOWN_PROJ (wie in der oben gezeigten Modellstruktur gezeigt), die zusammenarbeiten, um Daten zu erweitern und zu schrumpfen.
Dieser Mechanismus ermöglicht es dem Modell, komplexere Muster zu bewältigen und gleichzeitig die Effizienz beizubehalten. Dies bedeutet jedoch auch, dass die Schichten in der GLU -Struktur eng gekoppelt sind und diese Schichten eine sorgfältige Prüfung erfordern.
Jede Operation auf einer Schicht (z. B. Entfernen von Neuronen) muss in ihrer entsprechenden gepaarten Schicht reflektiert werden. Wenn Sie beispielsweise ein Neuron aus _gate proj entfernen, müssen Sie das gleiche Neuron von up_proj entfernen und die _down proj Schicht muss entsprechend geändert werden. Bei der Berechnung der Bedeutung von Neuronen, um zu bestimmen, welche Neuronen beibehalten werden, müssen neuronale Paare gemeinsam bewertet werden.
Die Zerstörung des Gleichgewichts dieser Schichten kann zu einer Leistungsverschlechterung führen, und selbst das Modell ist vollständig ungültig, auch wenn nur eine kleine Anzahl von Neuronen entfernt wird.
Das Beispiel wird unter Verwendung des Lama -Modells demonstriert, aber der Code wurde auch erfolgreich auf den Gemma- und QWEN -Modellen getestet.
Sie können auf den vollständigen Code in meiner GitHub -Code -Basis zugreifen.
Github-Peremartra/großsprachiger Model-Notebook-Kurs: Praktische Kurse zu großen Sprachen…
Der erste Schritt, den ich mit dem ursprünglichen Modell im Speicher gemacht habe, bestand darin, eine kleine Eingabeaufforderung auszuführen und das Ergebnis zu speichern. Dies ermöglicht es mir, einfach, intuitiv und schnell zu überprüfen, ob die durch den Beschneidungsprozess erzeugten Modelle kohärent sind oder im Gegenteil die Fähigkeit verlieren, verständlicher Text zu erzeugen.
Ich kann Ihnen versichern, dass der resultierende Text in meinem ersten Versuch zweifellos einen grundlegenden Fehler im Schnittprozess angibt, da die Glu -Struktur des Modells nicht eingehalten wird.
Die ursprüngliche Eingabeaufforderung lautet: "Paris ist die Hauptstadt von ...". Schauen wir uns die Antwort des ursprünglichen Modells an und vergleichen Sie es mit der Antwort, die durch meinen ersten fehlgeschlagenen Beschneidungsversuch zurückgegeben wurde.
Grundlegendes Modell:
"Paris ist die Hauptstadt Frankreichs und eine der meistbesuchten Städte der Welt. Es ist eine Hauptstadt Kunst, Kultur, Mode und Essen. Die Stadt hat eine reiche Geschichte und beherbergt viele berühmte Sehenswürdigkeiten, darunter… … ”
Beschneidung nur 20% der falschen Modelle:
"Paris ist die Hauptstadt Frankreichs. Dies ist das Hauptgebiet von .... Dies ist die Stadt ... Frankreich ..."
Offensichtlich hat im ersten Versuch etwas nicht funktioniert. Dies mag trivial erscheinen, aber ein solcher Erfahrungsprüfung kann Ihnen viel Zeit sparen.
Schauen wir uns zunächst die Funktion an, die für die Berechnung der Bedeutung von Neuronen verantwortlich ist, was letztendlich feststellt, welche Neuronen im Modell verbleiben und welche Neuronen entfernt werden.
<code>LlamaForCausalLM(
(model): LlamaModel(
(embed_tokens): Embedding(128256, 2048)
(layers): ModuleList(
(0-15): 16 x LlamaDecoderLayer(
(self_attn): LlamaSdpaAttention(
(q_proj): Linear(in_features=2048, out_features=2048, bias=False)
(k_proj): Linear(in_features=2048, out_features=512, bias=False)
(v_proj): Linear(in_features=2048, out_features=512, bias=False)
(o_proj): Linear(in_features=2048, out_features=2048, bias=False)
(rotary_emb): LlamaRotaryEmbedding()
)
(mlp): LlamaMLP(
(gate_proj): Linear(in_features=2048, out_features=8192, bias=False)
(up_proj): Linear(in_features=2048, out_features=8192, bias=False)
(down_proj): Linear(in_features=8192, out_features=2048, bias=False)
(act_fn): SiLU()
)
(input_layernorm): LlamaRMSNorm((2048,), eps=1e-05)
(post_attention_layernorm): LlamaRMSNorm((2048,), eps=1e-05)
)
)
(norm): LlamaRMSNorm((2048,), eps=1e-05)
(rotary_emb): LlamaRotaryEmbedding()
)
(lm_head): Linear(in_features=2048, out_features=128256, bias=False)
)</code>Diese Funktion empfängt die Gewichte des _gate proj und _Up proj , und wie ich erklärte, funktionieren sie paarweise. Daher muss die Bedeutung von Neuronen in Kombination berechnet werden.
Die Berechnung ist sehr einfach: Sie berechnet den absoluten Wert des Gewichts jedes Neurons. Sowohl positive als auch negative Werte werden berücksichtigt, da Neuronen mit den extremsten Werten theoretisch einen größeren Einfluss auf die Ausgabe des Modells haben, indem die Werte signifikant verändert werden.
Hier muss ich Mariusz Kurman für seinen Beitrag zur Einbeziehung des Mindestwerts in die Berechnung danken. Während die Methode ohne sie gut funktioniert, kann auch sie die Ergebnisse verbessern.
Die Bedeutung jeder Schicht wird separat berechnet, aber die Funktion gibt einen kombinierten Wert zurück.
<code>LlamaForCausalLM(
(model): LlamaModel(
(embed_tokens): Embedding(128256, 2048)
(layers): ModuleList(
(0-15): 16 x LlamaDecoderLayer(
(self_attn): LlamaSdpaAttention(
(q_proj): Linear(in_features=2048, out_features=2048, bias=False)
(k_proj): Linear(in_features=2048, out_features=512, bias=False)
(v_proj): Linear(in_features=2048, out_features=512, bias=False)
(o_proj): Linear(in_features=2048, out_features=2048, bias=False)
(rotary_emb): LlamaRotaryEmbedding()
)
(mlp): LlamaMLP(
(gate_proj): Linear(in_features=2048, out_features=8192, bias=False)
(up_proj): Linear(in_features=2048, out_features=8192, bias=False)
(down_proj): Linear(in_features=8192, out_features=2048, bias=False)
(act_fn): SiLU()
)
(input_layernorm): LlamaRMSNorm((2048,), eps=1e-05)
(post_attention_layernorm): LlamaRMSNorm((2048,), eps=1e-05)
)
)
(norm): LlamaRMSNorm((2048,), eps=1e-05)
(rotary_emb): LlamaRotaryEmbedding()
)
(lm_head): Linear(in_features=2048, out_features=128256, bias=False)
)</code>Diese Funktion erzeugt neue, kleinere Schichten, während die wichtigsten Neuronen beibehalten. Dieser Prozess enthält:
<code>def compute_neuron_pair_importance(gate_weight, up_weight):
"""
计算神经元对重要性分数（最大绝对权重）
参数：
- gate_weight：来自 gate_proj 层的权重矩阵。
- up_weight：来自 up_weight 层的权重矩阵。
返回：
- importance_scores：每个神经元对的重要性分数。
"""
gate_max_abs = torch.max(gate_weight, dim=1).values + torch.abs(torch.min(gate_weight, dim=1).values)
up_max_abs = torch.max(up_weight, dim=1).values + torch.abs(torch.min(up_weight, dim=1).values)
importance_scores = gate_max_abs + up_max_abs
return importance_scores</code><code>def prune_neuron_pairs(mlp, prune_percent):
"""
减少**gate_proj**、**up_proj**、**down_proj**层的维度，移除不太重要的神经元。
参数：
- mlp：要剪枝的层。
- prune_percent：要剪枝的神经元的百分比。
返回：
- new_gate_proj, new_up_proj, new_down_proj：新的剪枝层。
- k：新的中间大小。
"""
# 从 MLP 层提取权重
gate_weight = mlp.gate_proj.weight.data.float()
up_weight = mlp.up_proj.weight.data.float()
# 计算重要性分数
importance_scores = compute_neuron_pair_importance(gate_weight, up_weight)
original_intermediate_size = gate_weight.size(0)
# 计算要保留的神经元
num_neuron_pairs_to_prune = min(int(prune_percent * original_intermediate_size),
original_intermediate_size - 1)
k = original_intermediate_size - num_neuron_pairs_to_prune
# 验证检查
if k < 1:
raise ValueError("k must be greater than 0")
# 选择要保留的神经元
_, indices_to_keep = torch.topk(importance_scores, k, largest=True, sorted=True)
indices_to_keep = indices_to_keep.sort().values
# 创建并填充新层
new_gate_proj = nn.Linear(mlp.gate_proj.in_features, k, bias=False).to(device)
new_up_proj = nn.Linear(mlp.up_proj.in_features, k, bias=False).to(device)
new_down_proj = nn.Linear(k, mlp.down_proj.out_features, bias=False).to(device)
# 将选定的权重复制到新层。
new_gate_proj.weight.data = mlp.gate_proj.weight.data[indices_to_keep, :]
new_up_proj.weight.data = mlp.up_proj.weight.data[indices_to_keep, :]
new_down_proj.weight.data = mlp.down_proj.weight.data[:, indices_to_keep]
return new_gate_proj, new_up_proj, new_down_proj, k</code>Erhalten Sie einen Tensor, der den für jedes Neuron berechneten Wichtigkeitswert enthält. Diese Bewertungen spiegeln den Beitrag jedes Neurons zum endgültigen Ausgang wider und geben an, welche Neuronen beibehalten werden sollen.
<code># 从 MLP 层提取权重
gate_weight = mlp.gate_proj.weight.data.float()
up_weight = mlp.up_proj.weight.data.float()</code>Verwenden Sie den Prozentsatz der als Parameter bereitgestellten Schnitt und die ursprüngliche Größe der zu erhaltenen Schicht, um die Gesamtzahl der zu erhaltenen Neuronen zu berechnen.
<code># 计算重要性分数
importance_scores = compute_neuron_pair_importance(gate_weight, up_weight)
original_intermediate_size = gate_weight.size(0)</code>Taschenlampe wird verwendet, um Neuronen mit der höchsten Bedeutung zu rufen und sie gleichzeitig von der wichtigsten bis zur am wenigsten wichtigen Reihenfolge zu stellen. Da Torch Daten in absteigender Reihenfolge zurückgibt, wird sie mit der Sortiermethode in aufsteigender Reihenfolge neu angeordnet, was wir brauchen.
<code># 计算要保留的神经元
num_neuron_pairs_to_prune = min(int(prune_percent * original_intermediate_size),
original_intermediate_size - 1)
k = original_intermediate_size - num_neuron_pairs_to_prune</code>Erstellen Sie drei neue Ebenen, deren Abmessungen gemäß dem ausgewählten Index angepasst werden. In _new_gate proj und _new_up proj wird die Eingangsdimension erhalten, während die Ausgangsdimension reduziert ist. Stattdessen wird in _new_down proj die Eingangsdimension eingestellt, während die Ausgangsdimension gleich bleibt.
<code># 选择要保留的神经元
_, indices_to_keep = torch.topk(importance_scores, k, largest=True, sorted=True)
indices_to_keep = indices_to_keep.sort().values</code>Die relevanten Gewichte werden von der ursprünglichen Schicht auf die neue Schicht übertragen, um sicherzustellen, dass nur die Gewichten, die dem ausgewählten Neuron entsprechen, beibehalten werden.
Schauen wir uns nun die Funktionen an, die für die Iterierung aller Schichten und das Erstellen des modifizierten Modells verantwortlich sind.
<code># 创建并填充新层
new_gate_proj = nn.Linear(mlp.gate_proj.in_features, k, bias=False).to(device)
new_up_proj = nn.Linear(mlp.up_proj.in_features, k, bias=False).to(device)
new_down_proj = nn.Linear(k, mlp.down_proj.out_features, bias=False).to(device)</code>Diese Funktion iteriert über jede Ebene des Modells, wendet den Beschneidungsvorgang an und aktualisiert die Konfiguration des Modells, um die neue Architektur widerzuspiegeln.
Wenn die Konfigurationsdatei nicht aktualisiert wird, kann das Modell nach dem Speichern nicht verwendet werden, unabhängig davon, ob er das Gesicht oder lokal umarmt. Viele Bibliotheken (wie Umarmung der Transformatoren von Face) verlassen sich auf model.config , um die Architektur des Modells zu erklären. Wenn die Konfiguration nicht mit der tatsächlichen Struktur übereinstimmt, können Feinabstimmungs- oder Inferenzvorgänge, die über diese Bibliotheken ausgeführt werden, fehlschlagen.
Mit diesem Code habe ich mehrere Modelle erstellt, die für den Umarmungs -Face -Hub verfügbar sind.
Dazu gehören:
Sie können diese Modelle herunterladen, und zusätzlich zu der Verwendung können Sie auch ihre Architektur und welche Änderungen im Vergleich zu dem ursprünglichen Modell, auf dem sie basieren, untersuchen.
Lassen Sie uns die Architekturänderungen nach der Anwendung des LAMAM3.2–1B -Modells auf 20% Beschneidung analysieren.
<code># 将选定的权重复制到新层。 new_gate_proj.weight.data = mlp.gate_proj.weight.data[indices_to_keep, :] new_up_proj.weight.data = mlp.up_proj.weight.data[indices_to_keep, :] new_down_proj.weight.data = mlp.down_proj.weight.data[:, indices_to_keep]</code>
Die Struktur des Modells bleibt mit Ausnahme der Größe der Zwischenschicht im MLP -Block unverändert. Wie Sie sehen können, wurden das _gate proj und _Up proj proj von 8192 Funktionen auf 6554 reduziert, und das gleiche passiert mit dem _down proj Schichten.
Diese Änderung entspricht genau der Funktion des Codes: Ändern Sie diese Ebenen, während Sie Neuronen beibehalten, die für die Modellleistung von entscheidender Bedeutung sind. Wenn wir 20% von 8192 entfernen, erhalten wir 6553,6, was bestätigt, dass der richtige Anteil der Neuronen beschnitten wurde.
Lassen Sie uns nun sehen, wie das beschnittene Modell in der Testaufforderung ausgeführt wird:
Paris ist die Hauptstadt Frankreichs. Es ist auch eine der schönsten Städte der Welt. In Paris gibt es so viele Dinge, die es wert sind, sie zu sehen und zu erleben, dass es unmöglich ist, sie alle an einem Tag abzudecken. Aber es gibt einige Dinge ...
Die Antwort entspricht nicht genau der Reaktion des ursprünglichen Modells, aber sie behält die Kohärenz bei. Dies deutet darauf hin, dass das Modell die meisten seiner Fähigkeiten behält und vor allem alle Verluste durch Wissensdestillation oder feinstimmend wiederherstellen kann.
Zusätzlich zu dieser empirischen Prüfung habe ich das Modell anhand einiger der häufigsten Benchmarks bewertet. Lassen Sie uns analysieren, wie unterschiedliche Beschneidungsgrade die Leistung des Modells beeinflussen.
Wie wir gesehen haben, sind die Auswirkungen des Beschneidens etwas asymmetrisch. Der Boolq -Test bewertete die Aufgabe erlebte keinen signifikanten Rückgang, und für Modelle, die 40% der Neuronen in der MLP -Schicht verloren hatten, nahm er nur etwa 2% ab.
Dies deutet darauf hin, dass das Modell den größten Teil seines Verständnisses beibehält, aber in Tests, die eine mehr offene Generation erfordern, schwer zu behandeln ist.
boolq enthält nur Text und Fragen, die mit Ja/Nein zum Modell beantwortet werden müssen. Dies ist ein Test, der sich darauf konzentriert, die Fähigkeit des Modells zu messen, Beziehungen im Eingabetxt zu verstehen.Lambada hingegen bittet das Modell, das letzte Wort des Absatzes zu erraten, eine komplexe Aufgabe, bei der das letzte Wort die Fähigkeit des Modells in der komplexen Sprachmodellierung testet.
Umarmung des Gesichts offenes LLM -Ranking
In diesem Diagramm können wir die Ergebnisse der beiden Modelle sehen.
Durch die Untersuchung dieses Diagramms können wir die folgende Schlussfolgerung ziehen: 
Die durchschnittliche Leistung des Modells nach dem Beschneiden ist besser als das Basismodell (4.86 vs. 4.03) . Dies deutet darauf hin, dass der Beschneidungsprozess die Leistung in Schlüsselbereichen effektiv behält oder verbessert und gleichzeitig die Redundanz verringert.
Vorteile:
Nachteile:
Energieeffizienz : Das beschnittene Modell hat eine geringfügige Energieeffizienz (0,4 kg gegenüber 0,42 kg CO₂), was mit dem Ziel übereinstimmt, den Rechenaufwand zu reduzieren und gleichzeitig die Wettbewerbsleistung aufrechtzuerhalten.
Eine umfassendere Untersuchung der Leistung des Modells in verschiedenen Rankings ist erforderlich. Diese Ergebnisse legen jedoch nahe, dass wir ein vielversprechendes Modell haben, das mit der richtigen Wissensdestillation oder der Feinabstimmung erheblich verbessert werden kann. Am wichtigsten ist, dass diese Ergebnisse mit dem auf der MLP -Schicht durchgeführten Schnittprozess übereinstimmen.
Der Beschneidungsprozess des Modells war erfolgreich. Dieser Ansatz zur Behandlung der GLU -Schicht ermöglicht es uns, das Beschneiden durchzuführen und gleichzeitig die meisten Funktionen des Modells beizubehalten und seine Größe und den Ressourcenverbrauch erheblich zu verringern.
Es ist wichtig zu beachten . zukünftige Arbeit Es gibt viele Beschneidungstechniken, die es wert sind, erkunden zu werden. Am direktesten ist das Tiefenbeschnitten, bei dem Schichten entfernt werden, die am wenigsten zur Modellleistung beitragen. Ein weiterer wichtiger Forschungsbereich ist der Prozess der Wissensdestillation dieser geschnittenen Modelle und beurteilen, ob sie die Fähigkeit beibehalten, neue Aufgaben zu erlernen. Dies kann ihre Leistung näher an das Basismodell bringen, insbesondere in Benchmarks, in denen beschnittene Modelle maximale Verluste aufweisen.
Die Entwicklung leichterer, effizienterer Modelle bleibt ein attraktiver Bereich, insbesondere für Unternehmen, die LLM -Funktionen ohne umfangreiche Infrastrukturanforderungen einsetzen möchten. Diese Arbeit bildet die Grundlage für weitere Untersuchungen darüber, wie diese leistungsstarken Modelle zugänglich und bereitgestellt werden können.Dieser Artikel ist Teil eines vollständigen Kurs über große Sprachmodelle und ist auf GitHub verfügbar. Um sich über neue Artikel -Updates zu informieren, sollten Sie die Codebasis oder die Hauptrolle folgen. Auf diese Weise werden Sie beim Hinzufügen neuer Inhalte benachrichtigt.
Ich bin der Autor des Buches "Grand Language Model Project: Anwendung und Implementierung von Strategien für Großsprachmodell", das von Apress Publishing House veröffentlicht wurde.Ich schreibe regelmäßig über generative KI, Deep Learning und TensorFlow. Befolgen Sie bitte mein Konto auf Medium für Aktualisierungen zu neuen Artikeln. Natürlich können Sie mich gerne unter LinkedIn kontaktieren.
Das obige ist der detaillierte Inhalt vonWie man Lama 3.2 und ähnliche große Sprachmodelle beschnitten. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
