Un guide d'introduction et de développement pour le LLM open source - MPT-7B

Global

Mosaic est une startup spécialisée dans les modèles d'IA, et dans cet article, nous présenterons leur nouvelle série de modèles MPT-7B. Ce sont des modèles entièrement open-source et disponibles dans le commerce, formés en 9,5 jours à partir de zéro sur 1 billion de jetons, dont le processus de développement est beaucoup plus compliqué et coûteux que les modèles affinés de LLaMA ou Pythia que j'ai présentés dans mes articles précédents. C'est un exploit remarquable pour une startup, d'autant plus qu'elle a entraîné jusqu'à un billion de jetons pour un coût matériel de 200 000 USD. La capacité du modèle de base est équivalente au modèle LLaMA de 7 milliards. En plus de cela, ils ont également affiné d'autres modèles pour inspirer les communautés de développement, notamment un modèle Instruct, un modèle Chat et un modèle StoryWriter.

Le modèle MPT-7B est le premier modèle de langage open source avec des performances équivalentes au modèle LLaMA-7B dans les tests d'évaluation de Mosaic, et il semble de meilleure qualité et plus stable que Pythia et StableLM et de nombreux autres modèles open source jusqu'à présent selon les échelles de résultat et d'entraînement. D'autres modèles, tels que ceux de RedPajama et OpenLLaMA, n'ont été que des instantanés des modèles de formation actuels qui n'ont pas encore été entièrement publiés. C'est le premier que nous avons réellement reçu où il s'agit du modèle complet et a été comparé pour montrer qu'il est fondamentalement à égalité avec LLaMA. Le modèle MPT-7B est également le premier modèle disponible dans le commerce, et nous pouvons l'affiner nous-mêmes sur nos propres données pour un usage commercial.

Contexte Longueur du modèle StoryWriter

L'une des choses les plus intéressantes à propos du modèle MPT-7B est qu'il a fourni le modèle Story-Writer MPT-7B-StoryWriter-65k+, qui a été formé avec l'architecture ALiBi , permettant aux utilisateurs d'étendre le contexte à une longueur aussi extrême. Si vous vouliez affiner un modèle plus long, vous pourriez le faire aujourd'hui. C'est exactement ce qu'ils ont fait avec le modèle Story-Writer, où ils ont pris le modèle de base et l'ont affiné avec une longueur de contexte de plus de 65 000 jetons. Pour mettre cela en perspective, le modèle LLaMA original n'accepte que 2048 jetons, le StableLM a été formé pour 4096 jetons, et pour ChatGPT et GPT-4, le nombre est de 4096 et 8000-32000 selon la version à laquelle vous avez accès.

Il y a un exemple impressionnant sur son blog montrant que l'équipe Mosaic a une fois suscité le livre entier de The Great Gatsby , puis le modèle a généré avec succès un épilogue décent basé sur l'entrée de 67873 jetons. Je n'ai jamais vu d'autre modèle proche ou ouvert capable de faire cela, ce qui me fait réfléchir à la méthode la plus rentable pour effectuer un apprentissage en contexte à l'avenir, l'intégration d'OpenAI ou le modèle Story-Writer. Si vous êtes intéressé par l'apprentissage en contexte, veuillez vous référer à mon article précédent.

Ensembles de données pour la formation

Ils ont également formé un modèle d'instruction à 7 milliards MPT-7B-Instruct, qui est un modèle abrégé de suivi d'instructions. Il est affiné à partir du mode de base sur des ensembles de données open source principalement à partir de l'augmentation de l'ensemble de données Dolly-15K de Databricks. En conséquence, ils obtiennent un plus grand ensemble de données basé sur des instructions et conservent une licence utilisable à des fins commerciales. Comme je l'ai mentionné dans l' articlesur Dolly 2.0, le principal catalyseur de l'utilisabilité commerciale de Dolly est son ensemble de données pur sans licence qui n'est pas généré à partir d'autres modèles d'IA comme ChatGPT mais créé par des humains. À cause de cela, lorsque vous jouez avec et que vous lui posez des questions, vous n'obtenez pas de réponses aussi familières que « En tant que modèle de langage d'IA, je ne peux pas… ». Cependant, il ne s'agit pas d'un ensemble de données aussi volumineux que celui utilisé par les modèles Vicuna et les modèles Koala et l'équipe prévoit d'étendre sa formation aux ensembles de données 1T pour une plus grande compétitivité de ce modèle d'instruction.

Autres

Il existe également un autre modèle étendu de MPT-7B appelé MPT-7B-Chat à fournir des interactions multi-tours fluides et engageantes pour les utilisateurs. Veuillez noter que ce modèle de chatbot est le seul à ne pas être autorisé à un usage commercial.

De plus, la couche d'optimisation du modèle MPT-7B inclut FlashAttention et une norme de couche de faible précision, qui expliquent en partie les vitesses d'inférence plus rapides que les autres modèles de 7 milliards environ " 1,5x-2x plus rapides " sur le hub HuggingFace.

Voici les ressources des modèles MPT-7B dont vous pouvez apprendre :

• Article de blog :https://www.mosaicml.com/blog/mpt-7b
• Instruire la démo :https://huggingface.co/spaces/mosaicml/mpt-7b-instruct
• Démo de chat :https://huggingface.co/spaces/mosaicml/mpt-7b-chat

Bien qu'un modèle soit si adapté à un usage commercial, un déploiement facile et peu coûteux devrait en être l'une des autres caractéristiques essentielles. Heureusement, MPT-7B a été conçu pour être rapide, simple et abordable à déployer pour les tâches d'inférence, grâce à la compatibilité transparente avec la PreTrainedModelclasse de base HuggingFace.

J'ai créé un bloc-notes Google Colab auquel vous pouvez vous référer si vous souhaitez déployer et exécuter le modèle MPT-7B-Instruct localement : https://colab.research.google.com/drive/16D9tjggLukD38Un0hC-Gss3mrehPXng_?usp=sharing

N'hésitez pas à le copier dans votre espace, mais sachez que pour exécuter ce modèle, vous pouvez avoir un compte Colab Pro ou un support GPU local pour avoir des ressources décentes dont le pré-formé a besoin et qui nécessitent un minimum de GPU T4 de 15 Go et 22 Go de RAM MPT-7B-Instruct.

Parcourons le code dans le cahier.

a) Installer les packages

!pip install requests torch transformers einops

from typing import Any, Dict, Tuple
import warnings
import datetime
import os
from threading import Event, Thread
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, StoppingCriteria, StoppingCriteriaList, TextIteratorStreamer

import textwrap

INSTRUCTION_KEY = "### Instruction:"
RESPONSE_KEY = "### Response:"
END_KEY = "### End"
INTRO_BLURB = "Below is an instruction that describes a task. Write a response that appropriately completes the request."
PROMPT_FOR_GENERATION_FORMAT = """{intro}
{instruction_key}
{instruction}
{response_key}
""".format(
    intro=INTRO_BLURB,
    instruction_key=INSTRUCTION_KEY,
    instruction="{instruction}",
    response_key=RESPONSE_KEY,
)


class InstructionTextGenerationPipeline:
...

INSTRUCTION_KEY, RESPONSE_KEY, et END_KEYsont utilisés comme clés pour identifier des sections spécifiques de l'invite. INTRO_BLURBest une chaîne qui fournit un texte d'introduction pour l'invite. PROMPT_FOR_GENERATION_FORMATest une chaîne qui définit le format de l'invite transmise au modèle de langage.

Une classe nommée InstructionTextGenerationPipelineest définie pour générer du texte donné une instruction à l'aide d'un modèle de langage de transformateur pré-formé. La classe utilise la transformersbibliothèque pour charger le modèle et le générateur de jetons pré-formés et définit une __call__méthode qui prend une chaîne d'instructions en entrée et génère une chaîne de réponse à l'aide du modèle de langage.

d) Modèle de charge avec pipeline

generate = InstructionTextGenerationPipeline(
    "mosaicml/mpt-7b-instruct",
    torch_dtype=torch.bfloat16,
    trust_remote_code=True,
)
stop_token_ids = generate.tokenizer.convert_tokens_to_ids(["<|endoftext|>"])

# Define a custom stopping criteria
class StopOnTokens(StoppingCriteria):
    def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor, **kwargs) -> bool:
        for stop_id in stop_token_ids:
            if input_ids[0][-1] == stop_id:
                return True
        return False

def process_stream(instruction, temperature, top_p, top_k, max_new_tokens):
    # Tokenize the input
    input_ids = generate.tokenizer(
        generate.format_instruction(instruction), return_tensors="pt"
    ).input_ids
    input_ids = input_ids.to(generate.model.device)

    # Initialize the streamer and stopping criteria
    streamer = TextIteratorStreamer(
        generate.tokenizer, timeout=10.0, skip_prompt=True, skip_special_tokens=True
    )
    stop = StopOnTokens()

    if temperature < 0.1:
        temperature = 0.0
        do_sample = False
    else:
        do_sample = True

    gkw = {
        **generate.generate_kwargs,
        **{
            "input_ids": input_ids,
            "max_new_tokens": max_new_tokens,
            "temperature": temperature,
            "do_sample": do_sample,
            "top_p": top_p,
            "top_k": top_k,
            "streamer": streamer,
            "stopping_criteria": StoppingCriteriaList([stop]),
        },
    }

    response = ''

    def generate_and_signal_complete():
        generate.model.generate(**gkw)

    t1 = Thread(target=generate_and_signal_complete)
    t1.start()

    for new_text in streamer:
        response += new_text
   
    return response

Maintenant, nous pouvons appeler la process_stream() méthode avec les arguments appropriés pour voir comment le modèle répond à nos instructions.

instruction = "Write a travel blog about a 3-day trip to The Philippines. You need describe day by day."
temperature = 0.3
top_p = 0.95
top_k = 0
max_new_tokens = 2000
response = process_stream(instruction, temperature, top_p, top_k, max_new_tokens)

wrapped_text = textwrap.fill(response, width=100)
print(wrapped_text +'\n\n')

Vous pouvez essayer beaucoup plus d'instructions pour le modèle une fois que votre Colab ou votre machine locale a déployé le modèle avec succès et ajuste les paramètres dans le code pour voir différents comportements en fonction de votre point de vue. D'après mes tests jusqu'à présent, l'achèvement du texte et du code est assez bon, mais le raisonnement et les mathématiques n'ont pas encore mûri pour exécuter une tâche d'instruction commerciale. D'après le blog officiel de Mosaic, nous savons qu'ils essaient de mettre plus de données de formation dans ces modèles affinés.

Le modèle de base, le réglage fin, les ensembles de données, la formation et l'inférence de MPT-7B sont tous open-source et sans publicité, vous pouvez donc maintenant commencer à envisager de former et de publier votre propre modèle privé pour votre entreprise d'IA à un coût abordable.

C'est ça.

J'espère que vous trouverez quelque chose d'utile dans cet article et merci de votre lecture !

Codage de niveau supérieur

Merci de faire partie de notre communauté ! Avant que tu partes:

• Applaudissez pour l'histoire et suivez l'auteur
• Voir plus de contenu dans la publication Level Up Coding
• Cours d'entretien de codage gratuit ⇒ Voir le cours
• Suivez-nous : Twitter | LinkedIn | Bulletin