MPT-7B, chegou a hora dos modelos de linguagem comercialmente utilizáveis

May 10 2023

Um guia de introdução e desenvolvimento para LLM de código aberto — MPT-7B A Overall Mosaic é uma empresa iniciante especializada em modelos de IA e, neste artigo, apresentaremos sua recém-lançada série de modelos MPT-7B. São modelos totalmente de código aberto e disponíveis comercialmente, treinados em 9.

Um guia de introdução e desenvolvimento para LLM de código aberto — MPT-7B

Imagem gerada por Midjourney

Geral

A Mosaic é uma empresa iniciante especializada em modelos de IA e, neste artigo, apresentaremos sua recém-lançada série de modelos MPT-7B. São modelos totalmente de código aberto e comercialmente disponíveis, treinados em 9,5 dias a partir do zero em 1 trilhão de tokens, cujo processo de desenvolvimento é muito mais complicado e caro do que os modelos ajustados de LLaMA ou Pythia que apresentei em meus artigos anteriores. Este é um feito notável para uma startup, especialmente considerando que eles treinaram até um trilhão de tokens a um custo de hardware de 200 mil dólares. A capacidade do modelo básico é equivalente ao modelo LLaMA de 7 bilhões, além disso, eles também ajustaram outros modelos para inspirar comunidades de desenvolvimento, incluindo um modelo Instruct, um modelo Chat e um modelo StoryWriter.

O modelo MPT-7B é o primeiro modelo de linguagem de código aberto com desempenho equivalente ao modelo LLaMA-7B nos testes de avaliação da Mosaic, e parece de maior qualidade e mais estável do que Pythia e StableLM e muitos outros modelos de código aberto até agora de acordo com as escalas de resultado e treinamento. Outros modelos, como os de RedPajama e OpenLLaMA, foram apenas instantâneos dos modelos de treinamento atuais que ainda não foram totalmente lançados. Este é o primeiro que realmente recebemos onde é o modelo completo e foi comparado para mostrar que está basicamente no mesmo nível do LLaMA. O modelo MPT-7B também é o primeiro modelo disponível comercialmente e podemos ajustá-lo com nossos próprios dados para uso comercial.

Precisão zero de MPT-7B vs. LLaMA-7B vs. outros modelos de código aberto em tarefas acadêmicas (da Mosaic).

Contexto Comprimento do modelo StoryWriter

Uma das coisas mais legais sobre o modelo MPT-7B é que ele forneceu o modelo Story-Writer MPT-7B-StoryWriter-65k+, que foi treinado com a arquitetura ALiBi , permitindo que os usuários estendam o contexto a um comprimento tão extremo. Se você quiser ajustar um modelo mais longo, pode fazer isso hoje. Isso é exatamente o que eles fizeram com o modelo Story-Writer, onde pegaram o modelo básico e o ajustaram com um comprimento de contexto de mais de 65.000 tokens. Para colocar isso em perspectiva, o modelo LLaMA original aceita apenas 2.048 tokens, o StableLM foi treinado para 4.096 tokens e para ChatGPT e GPT-4, o número é 4.096 e 8.000-32.000, dependendo de qual versão você tem acesso.

O recurso de entrada de 65+K-token torna o MPT muito mais impressionante entre os modelos

Há um exemplo impressionante em seu blog mostrando que a equipe Mosaic uma vez solicitou todo o livro de O Grande Gatsby , então o modelo gerou um epílogo decente com sucesso com base na entrada de 67873 tokens. Nunca vi nenhum outro modelo fechado ou modelo aberto capaz de fazer isso, então isso me faz considerar qual método é mais econômico para fazer aprendizado no contexto no futuro, a incorporação de OpenAI ou o modelo Story-Writer. Se você estiver interessado em aprender no contexto, consulte meu artigo anterior.

Conjuntos de dados para treinamento

Eles também treinaram um modelo de instruções de 7 bilhões MPT-7B-Instruct, que é um modelo de seguimento de instrução de forma curta. Ele é ajustado do modo base em conjuntos de dados de código aberto principalmente do aumento do conjunto de dados Dolly-15K da Databricks. Como resultado, eles obtêm um conjunto de dados baseado em instrução maior e mantêm uma licença comercialmente utilizável. Como mencionei no artigono Dolly 2.0, o principal facilitador da usabilidade comercial do Dolly é seu conjunto de dados livre de licença, que não é gerado por outros modelos de IA como o ChatGPT, mas criado por humanos. Por causa disso, quando você brinca com ele e faz perguntas, não obtém respostas tão familiares como “Como um modelo de linguagem de IA, não posso …” esse tipo de coisa. No entanto, não é um conjunto de dados tão grande quanto os modelos Vicuna e Koala estão usando e a equipe está planejando estender seu treinamento para conjuntos de dados 1T para obter mais competitividade deste modelo de instrução.

Um exemplo de modelo Instruct na tarefa de conversão JSON

Outros

Há também outro modelo extenso de MPT-7B chamado MPT-7B-Chat para fornecer interações contínuas e envolventes de vários turnos para os usuários. Observe que este modelo de chatbot é o único que não é permitido para uso comercial.

Além disso, a camada de otimização do modelo MPT-7B inclui FlashAttention e norma de camada de baixa precisão, que são parte do motivo das velocidades de inferência mais rápidas do que outros 7 bilhões de modelos cerca de “ 1,5x-2x mais rápido ” no hub HuggingFace.

Aqui estão os recursos dos modelos MPT-7B com os quais você pode aprender:

Postagem no blog:https://www.mosaicml.com/blog/mpt-7b
Instruir Demonstração:https://huggingface.co/spaces/mosaicml/mpt-7b-instruct
Demonstração de bate-papo:https://huggingface.co/spaces/mosaicml/mpt-7b-chat

Embora um modelo seja tão adequado para uso comercial, a implantação fácil e barata deve ser uma de outras características críticas dele. Felizmente, o MPT-7B foi projetado para ser rápido, simples e acessível para implantar tarefas de inferência, graças à compatibilidade perfeita com a PreTrainedModelclasse base HuggingFace.

Criei um notebook do Google Colab para você consultar Se quiser implantar e executar o modelo MPT-7B-Instruct localmente: https://colab.research.google.com/drive/16D9tjggLukD38Un0hC-Gss3mrehPXng_?usp=sharing

Sinta-se à vontade para copiá-lo para o seu espaço, mas esteja ciente de que, para executar este modelo, você pode ter uma conta Colab Pro ou suporte a GPU local para ter recursos decentes que o pré-treinado requer, que precisa de um mínimo de GPU T4 de 15 GB e 22 GB de RAM MPT-7B-Instruct.

Vamos examinar o código no notebook.

a) Instalar os pacotes

!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, e END_KEYsão usados como chaves para identificar seções específicas do prompt. INTRO_BLURBé uma string que fornece algum texto introdutório para o prompt. PROMPT_FOR_GENERATION_FORMATé uma string que define o formato do prompt que é passado para o modelo de idioma.

Uma classe nomeada InstructionTextGenerationPipelineé definida para gerar texto dado uma instrução usando um modelo de linguagem transformador pré-treinado. A classe usa a transformersbiblioteca para carregar o modelo pré-treinado e o tokenizador e define um __call__método que usa uma string de instrução como entrada e gera uma string de resposta usando o modelo de linguagem.

d) Modelo de carga com tubulação

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

Agora, podemos chamar o process_stream() método com argumentos adequados para ver como o modelo responde às nossas instruções.

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

Resposta de MPT-7B-Instruct

Você pode tentar muito mais instruções para o modelo assim que seu Colab ou máquina local implantar o modelo com êxito e ajustar os parâmetros no código para ver diferentes comportamentos de acordo com sua perspectiva. Dos meus testes até agora, a conclusão do texto e do código é boa o suficiente, mas o raciocínio e a matemática ainda não amadureceram para executar qualquer tarefa de instrução comercial. No blog oficial da Mosaic, sabemos que eles estão tentando colocar mais dados de treinamento nesses modelos ajustados.

O modelo básico, o ajuste fino, os conjuntos de dados, o treinamento e a inferência do MPT-7B são todos de código aberto e sem comerciais, portanto, agora você pode começar a considerar o treinamento e o lançamento de seu próprio modelo privado para seus negócios de IA a um custo acessível.