Comment tailler Llama 3.2 et des modèles de langage similaires similaires

La taille des grands modèles continue d'augmenter les performances, mais la demande de modèles plus efficaces et compacts augmente également. Cependant, la réduction de la taille du modèle sans perdre les fonctions centrales est une tâche complexe.

Des techniques telles que la quantification et l'élagage sont souvent utilisées pour réduire la taille du modèle, tandis que des méthodes telles que la distillation de connaissances ou l'apprentissage du transfert aident à conserver ou à restaurer les fonctions perdues pendant le processus de réduction.

Parmi eux, l'élagage est l'une des stratégies les plus efficaces pour réduire la taille du modèle. Contrairement à la quantification des représentations numériques simplifiées, l'élagage implique de supprimer des parties spécifiques du modèle, telles que les neurones ou les couches entières. Mais cette efficacité a un coût: l'élagage est difficile à appliquer correctement. Non seulement vous devez déterminer la partie du modèle à élaguer, mais vous devez également sélectionner soigneusement les éléments à supprimer pour minimiser l'impact sur les capacités du modèle.

Cet article se concentre sur l'élagage de la largeur structurée (éliminer les neurones sélectionnés) et montre comment l'appliquer efficacement aux couches MLP avec des structures d'unité linéaire (GLU). En suivant les étapes décrites, vous comprendrez comment l'élagage peut réduire considérablement la taille du modèle tout en conservant sa capacité à générer une sortie cohérente et à bien performer dans des repères critiques.

Qu'est-ce que l'élagage et comment affecte-t-il le modèle?

Comme mentionné précédemment, l'élagage implique de supprimer la partie qui est considérée comme contribuant la plus petite à la sortie finale du modèle. En sélectionnant soigneusement ces composants moins importants, l'élagage vise à créer un modèle plus efficace avec moins de paramètres et des exigences de calcul inférieures sans sacrifier ses capacités de base.

Le principal défi de l'élagage est de décider quelles parties du modèle seront supprimées. Toutes les parties du modèle n'ont pas le même effet sur les performances; chaque partie a son propre rôle unique.

Pour illustrer cela, examinons la structure du modèle utilisé dans cet article: Llama 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>

Lors de l'examen de la structure, nous pouvons identifier trois modules principaux qui peuvent être utilisés comme cibles d'élagage: incorporer, mécanisme d'auto-agence et couche MLP. Afin de décider quelles pièces devraient être au centre du processus d'élagage, il est nécessaire de comprendre les avantages potentiels et les effets possibles.

La première étape consiste à évaluer la taille de l'espace que ces pièces occupent dans le modèle pour comprendre la réduction potentielle.

Analyse de la distribution des paramètres

Couches d'intégration et de sortie (Embed_Tokens, LM_head):

• 128256 × 2048 ≈ 262M Paramètres / couche
• Les deux couches ont un total de 524 m de paramètres

Mécanisme d'attention de soi (self_attn):

• 16 couches, chaque couche contient quatre sous-couches de projection
• par couche: 2048 × (2048 512 512 2048) ≈ 10,5m Paramètres
• Total: 10,5 × 16 ≈ 168m Paramètres

Couche MLP (MLP):

• 16 couches avec structure Glu (_gate proj , _up proj et _down proj )
• par couche: 2048 × 8192 2048 × 8192 8192 × 2048 ≈ 50m Paramètres
• Total: 50 × 16 ≈ 805m Paramètres

Nous pouvons voir que les couches MLP occupent plus de 50% de la taille du modèle, ce sont donc des candidats explicites. Cependant, il est important de comprendre la contribution de chaque section au comportement du modèle avant de prendre cette décision.

Analyse d'impact

La couche d'encorpation est responsable de la conversion de l'entrée en représentations vectorielles denses que le modèle peut traiter efficacement. Les couches d'intégration de l'élagage peuvent faire perdre le modèle à perdre la capacité de comprendre certains mots, ou du moins réduire la capacité de créer des vecteurs qui capturent correctement la signification de la sémantique d'entrée. Par exemple, si vous souhaitez créer un modèle très spécifique qui utilise uniquement des parties très spécifiques de son vocabulaire d'entrée (par exemple, un modèle d'analyse financière ou médicale), l'élagage de cette couche pourrait être une option.

Mécanisme d'attention permet au modèle de se concentrer sur les parties les plus pertinentes de la séquence d'entrée lors du traitement de chaque marqueur. Il calcule les scores d'importance pondérés entre chaque paire de marqueurs dans la séquence d'entrée, permettant au modèle de capturer le contexte et de se concentrer sur les informations pertinentes. L'élagage de cette section réduit la capacité du modèle à effectuer des tâches qui nécessitent une large compréhension du contexte d'entrée, telles que le résumé de texte ou la traduction. Il affecte également la cohérence du texte généré.

La couche MLP ainsi que les mécanismes d'attention, améliorent la capacité du modèle à comprendre les modèles complexes à travers une série d'expansion et de contraction des données. L'élagage de cette section limite la réponse du modèle aux tâches qui ne sont pas visibles ou non couvertes pendant la formation. En d'autres termes, il réduit la capacité de généralisation du modèle et sa capacité à fournir des réponses cohérentes aux entrées inconnues.

Une fois que vous décidez quelle partie du modèle que vous souhaitez cibler, l'étape suivante consiste à déterminer s'il faut effectuer l'élagage de largeur (en supprimant un seul neurone) ou une élagage en profondeur (en supprimant la couche entière).

Comme vous pouvez le voir, les modèles d'élagage sont un processus assez complexe impliquant de nombreuses décisions. Vous devez non seulement évaluer les capacités du modèle généré, mais aussi ses capacités de formation. Ces modèles sont conçus pour être affinés et sont souvent utilisés pour des tâches spécifiques, elles sont donc plus efficaces pour les tâches spécifiques qui les créent que le modèle sous-jacent.

Caractéristiques des unités linéaires fermées

Les architectures d'unité linéaire (GLU) fermées sont couramment utilisées dans les réseaux de neurones modernes, notamment des modèles LLAMA, GEMMA, Mistral, Qwen et similaires en grande langue. Glu introduit un mécanisme de déclenchement élément par éléments qui permet au modèle de filtrer sélectivement et de contrôler le flux d'informations. Cette architecture se compose de paires de couches, généralement: gate_proj, up_proj et down_proj (comme indiqué dans la structure du modèle illustré ci-dessus), qui fonctionnent ensemble pour étendre et rétrécir les données.

Ce mécanisme permet au modèle de gérer des modèles plus complexes tout en maintenant l'efficacité. Cependant, cela signifie également que les couches de la structure Glu sont étroitement couplées et l'élagage de ces couches nécessite une attention particulière.

Toute opération sur une couche (par exemple, le retrait des neurones) doit être reflétée dans sa couche appariée correspondante. Par exemple, si vous supprimez un neurone de _gate proj , vous devez supprimer le même neurone de up_proj et la couche _down proj doit être redimensionnée en conséquence. Plus important encore, lors du calcul de l'importance des neurones pour déterminer quels neurones sont conservés, les paires neuronales doivent être évaluées ensemble.

La destruction de l'équilibre de ces couches peut entraîner une dégradation des performances et même le modèle est complètement invalide, même si seul un petit nombre de neurones sont supprimés.

Prune Llama 3.2 Modèle

L'exemple sera démontré en utilisant le modèle LLAMA, mais le code a également été testé avec succès sur les modèles Gemma et Qwen.

Vous pouvez accéder au code complet dans ma base de code GitHub.

github - peremartra / grand-model-note-books cours: cours pratiques sur de grandes langues…

La première étape que j'ai faite avec le modèle d'origine en mémoire a été d'exécuter une petite invite et d'enregistrer le résultat. Cela me permet de vérifier facilement, intuitivement et rapidement si les modèles générés par le processus d'élagage sont cohérents ou, au contraire, perdent la capacité de générer du texte compréhensible.

Je peux vous assurer que dans ma première tentative, le texte résultant indique sans aucun doute un défaut fondamental dans le processus d'élagage en raison de l'échec de l'adhésion à la structure Glu du modèle.

L'invite originale est: "Paris est la capitale de ...". Examinons la réponse du modèle d'origine et comparons-le à la réponse renvoyée par ma première tentative d'élagage ratée.

Modèle de base:

"Paris est la capitale de la France et l'une des villes les plus visitées du monde. C'est une capitale de l'art, de la culture, de la mode et de la nourriture. La ville a une histoire riche et abrite de nombreux monuments célèbres, notamment… … »

élagage seulement 20% des modèles incorrects:

"Paris est la capitale de la France. C'est la zone principale de .... C'est la ville de ... France ..."

Évidemment, quelque chose n'a pas fonctionné dans la première tentative. Cela peut sembler trivial, mais un contrôle d'expérience comme celui-ci peut vous faire gagner beaucoup de temps.

Détails d'implémentation

Voyons d'abord la fonction responsable du calcul de l'importance des neurones, qui déterminera finalement quels neurones restent dans le modèle et quels neurones sont supprimés.

<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>

Cette fonction reçoit les poids de la couche _gate proj et _up proj couche, et comme je l'ai expliqué, ils fonctionnent par paires. Par conséquent, l'importance des neurones doit être calculée en combinaison.

Le calcul est très simple: il calcule la valeur absolue du poids de chaque neurone. Les valeurs positives et négatives sont prises en compte, car en théorie, les neurones avec les valeurs les plus extrêmes ont un impact plus important sur la sortie du modèle en modifiant considérablement les valeurs à travers elles.

Ici, je dois remercier Mariusz Kurman pour sa contribution à l'intégration de la valeur minimale dans le calcul. Bien que la méthode fonctionne bien sans eux, y compris elles peuvent améliorer les résultats.

L'importance de chaque couche est calculée séparément, mais la fonction renvoie une valeur combinée.

<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>

Cette fonction crée de nouvelles couches plus petites tout en conservant les neurones les plus importants. Ce processus comprend:

• Extraire le poids actuel:

<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>

• calcul du score d'importance des paires de neurones:

<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>

Obtenez un tenseur contenant le score d'importance calculé pour chaque neurone. Ces scores reflètent la contribution de chaque neurone à la sortie finale, indiquant quels neurones doivent être conservés.

• Déterminez le nombre de neurones à conserver:

<code># 从 MLP 层提取权重
    gate_weight = mlp.gate_proj.weight.data.float()
    up_weight = mlp.up_proj.weight.data.float()</code>

Utilisez le pourcentage d'élagage fourni comme paramètres et la taille d'origine de la couche à conserver pour calculer le nombre total de neurones à conserver.

• Sélectionnez le neurone le plus important:

<code># 计算重要性分数
    importance_scores = compute_neuron_pair_importance(gate_weight, up_weight)
    original_intermediate_size = gate_weight.size(0)</code>

La torche est utilisée pour récupérer les neurones avec le score d'importance la plus élevée, tout en les plaçant de l'ordre le plus important au moins important. Étant donné que Torch renvoie les données dans l'ordre décroissant, il est réorganisé dans l'ordre croissant en utilisant la méthode de tri, ce dont nous avons besoin.

• Créer de nouvelles couches plus petites:

<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>

Créez trois nouvelles couches dont les dimensions sont ajustées en fonction de l'index sélectionné. Dans _new_gate proj et _new_up proj , la dimension d'entrée est conservée pendant la réduction de la dimension de sortie. Au lieu de cela, dans _new_down proj , la dimension d'entrée est ajustée tandis que la dimension de sortie reste la même.

• Copiez le poids sélectionné sur le nouveau calque:

<code># 选择要保留的神经元
    _, indices_to_keep = torch.topk(importance_scores, k, largest=True, sorted=True)
    indices_to_keep = indices_to_keep.sort().values</code>

Les poids pertinents sont transférés de la couche d'origine à la nouvelle couche, garantissant que seuls les poids correspondant au neurone sélectionné sont conservés.

Maintenant, regardons les fonctions responsables de l'itération de toutes les couches et de la construction du modèle modifié.

<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>

Cette fonction itère sur chaque couche du modèle, applique le processus d'élagage et met à jour la configuration du modèle pour refléter la nouvelle architecture.

Si le fichier de configuration n'est pas mis à jour, le modèle ne peut pas être utilisé après l'enregistrement, que ce soit sur la face étreinte ou locale. De nombreuses bibliothèques (telles que les transformateurs de Hugging Face) s'appuient sur modèle.config pour expliquer l'architecture du modèle. Si la configuration ne correspond pas à la structure réelle, les opérations de réglage fin ou d'inférence effectuées via ces bibliothèques peuvent échouer.

Analyse des résultats

En utilisant ce code, j'ai créé plusieurs modèles disponibles sur Hugging Face Hub.

Ceux-ci incluent:

• Les trois modèles dérivés de LLAMA-3.2–1b, les neurones de la couche MLP ont été taillés respectivement de 20%, 40% et 60%.
• Un modèle basé sur GEMMA-2–2B, taillé 40%.

Vous pouvez télécharger ces modèles, et en plus de les utiliser, vous pouvez également étudier leur architecture et quels changements se sont produits par rapport au modèle d'origine sur lequel ils sont basés.

Analysons les changements d'architecture après avoir appliqué le modèle LLAMA3.2–1b à 20% d'élagage.

<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>

La structure du modèle reste inchangée, à l'exception de la taille de la couche intermédiaire dans le bloc MLP. Comme vous pouvez le voir, le _gate proj et _up proj proj Les couches ont été réduites de 8192 fonctionnalités à 6554, et il en va de même pour le _down proj

Couches.

Ce changement est exactement le même que la fonction du code: modifiez ces couches tout en conservant les neurones qui sont essentiels pour modéliser les performances. Si nous supprimons 20% de 8192, nous obtiendrons 6553,6, ce qui confirme que la proportion correcte de neurones a été taillée.

Test des conseils d'expérience

Maintenant, voyons comment le modèle taillé fonctionne dans l'invite de test:

Paris est la capitale de la France. C'est aussi l'une des plus belles villes du monde. Il y a tellement de choses à voir et à vivre à Paris qu'il est impossible de les couvrir tous en une journée. Mais il y a certaines choses ...

La réponse n'est pas exactement la même que la réponse du modèle d'origine, mais elle maintient la cohérence. Cela suggère que le modèle conserve la plupart de ses capacités, et plus important encore, il peut récupérer les pertes par le biais de Distillation de connaissances ou fin de réglage .

eleutherai / lm-evaluation

En plus de ce contrôle empirique, j'ai également évalué le modèle en utilisant certains des références les plus courantes. Analysons comment différents degrés d'élagage affectent les performances du modèle.

Comme nous l'avons vu, les effets de l'élagage sont quelque peu asymétriques. Le test BOOLQ a évalué la tâche n'a pas connu de baisse significative, et pour les modèles qui ont perdu 40% des neurones dans la couche MLP, il a diminué d'environ 2%.

En revanche, l'impact sur les tests de lambada a été très significatif, avec une baisse de précision de plus de 50%.

Cela suggère que le modèle conserve la majeure partie de sa compréhension mais est difficile à gérer dans les tests qui nécessitent une génération plus ouverte.

boolq ne présente que du texte et des questions auxquelles il faut répondre par oui / non au modèle. Il s'agit d'un test axé sur la mesure de la capacité du modèle à comprendre les relations dans le texte d'entrée.

Lambada, en revanche, demande au modèle de deviner le dernier mot du paragraphe, une tâche complexe dans laquelle le dernier mot teste la capacité du modèle dans la modélisation du langage complexe.

Emballage Face Open LLM Classement

Les résultats de l'élagage à 20% du modèle dans le classement LLM Open LLM étreignant sont encore plus surprenants car il surpasse son modèle de base et le TinyLlama-1.1b-V1.1 largement utilisé.

Dans ce graphique, nous pouvons voir les résultats des deux modèles.

En étudiant ce graphique, nous pouvons tirer la conclusion suivante: Les performances moyennes du modèle après élagage sont meilleures que le modèle de base (4.86 vs 4.03) . Cela suggère que le processus d'élagage conserve ou améliore efficacement les performances dans les domaines clés tout en réduisant la redondance.

Grâce aux résultats de la recherche, nous pouvons identifier les avantages et les inconvénients du modèle d'élagage.

Avantages:

• ifeval : Une amélioration significative (19,94 contre 14,78) indique que l'élagage réduit le sur-ajustement ou améliore la capacité du modèle à extraire efficacement les informations.
• MUSR : Une meilleure performance (4.39 vs 2,56) montre que le modèle élaqué gère les tâches qui nécessitent un raisonnement pour un contexte long ou une compréhension narrative, ce qui peut être dû à la concentration de poids.

Inconvénients:

• BBH : Diminution de la capacité d'inférence de l'incertitude (3.19 vs 4.37) peut indiquer que l'élagage réduit la capacité du modèle à gérer les scénarios ambigus ou multi-interprétés.
• mmlu-pro : La baisse des tâches des zones spécialisées (1,36 contre 2,26) peut être attribuée à la suppression des poids clés qui conservent les détails dans une zone spécifique.

Efficacité énergétique : Le modèle taillé a une efficacité énergétique légèrement plus élevée (0,4 kg contre 0,42 kg de CO₂), ce qui est cohérent avec le but de réduire les frais généraux de calcul tout en conservant des performances compétitives.

Une étude plus complète des performances du modèle dans différents classements est nécessaire, mais ces résultats suggèrent que nous avons un modèle prometteur qui peut être considérablement amélioré avec une distillation de connaissances appropriée ou un réglage fin. Plus important encore, ces résultats sont cohérents avec le processus d'élagage effectué sur la couche MLP.

Conclusion

Le processus d'élagage du modèle a réussi. Cette approche pour gérer la couche Glu nous permet d'effectuer l'élagage tout en conservant la plupart des capacités du modèle, réduisant considérablement sa taille et sa consommation de ressources.

Il est important de noter que les résultats des tests sont obtenus en effectuant un processus de récupération de capacité (par exemple Distillation de connaissances ou ajustement fin ) Avant le modèle d'élagage, cela se fait généralement sur des modèles élagués . Travail futur

Il existe de nombreuses techniques d'élagage qui méritent d'être explorées. La chose la plus directe est peut-être l'élagage de profondeur, qui implique de supprimer les couches qui contribuent le moins aux performances du modèle.

Un autre domaine de recherche important est le processus de distillation des connaissances de ces modèles élagués et évaluer s'ils conservent la capacité d'apprendre de nouvelles tâches. Cela peut rapprocher leurs performances du modèle de base, en particulier dans les repères où les modèles élagués présentent des pertes maximales.

Le développement de modèles plus légers et plus efficaces reste un domaine attractif, en particulier pour les entreprises qui cherchent à déployer des capacités LLM sans exigences d'infrastructure approfondies. Ce travail jette les bases de recherches supplémentaires sur la façon de faciliter l'accès et le déploiement de ces modèles puissants.

Cet article fait partie d'un cours complet sur les modèles de grande langue et est disponible sur GitHub. Pour en savoir plus sur les nouvelles mises à jour de l'article, envisagez de suivre la base de code ou de vedette.

De cette façon, vous serez informé lors de l'ajout de nouveau contenu. Je suis l'auteur du livre "Grand Language Model Project: Application and Implementation of Big Language Model Strategies" publié par Apress Publishing House.

J'écris régulièrement sur l'IA générative, l'apprentissage en profondeur et TensorFlow. Veuillez envisager de suivre mon compte sur Medium pour les mises à jour sur les nouveaux articles. Bien sûr, vous êtes invités à me contacter sur LinkedIn.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!