DCLM-7B da Apple: Configuração, exemplo de uso, ajuste fino

DCLM-7B: Principais recursos e capacidades

A mais recente contribuição da Apple, o modelo básico DCLM-7B (DataComp for Language Models), destaca-se como uma adição notável ao campo do LLM. Vamos explorar seus principais recursos.

Transformador somente para decodificador

O modelo DCLM-7B utiliza uma arquitetura de transformador somente de decodificador arquitetura de transformadorque é um projeto em que o modelo prevê um token por vez, e cada token gerado é alimentado novamente no modelo para gerar o próximo.

Essa arquitetura é otimizada para gerar textos coerentes e contextualmente relevantes, o que a torna ideal para vários tipos de processamento de linguagem natural natural. É a mesma arquitetura usada em modelos de última geração, como o ChatGPT e GPT-4odemonstrando sua eficácia na compreensão e geração de texto semelhante ao humano.

Código aberto

O modelo DCLM-7B está disponível para pesquisa e desenvolvimento sob a Licença de código de amostra da Apple. Essa abordagem de código aberto incentiva o uso generalizado e a colaboração na comunidade de IA.

Ao tornar esse modelo acessível, a Apple apoia a democratização da IA, permitindo que pesquisadores e desenvolvedores de todo o mundo façam experiências e desenvolvam o modelo básico.

7 bilhões de parâmetros

Com 7 bilhões de parâmetros, o modelo DCLM-7B atinge um equilíbrio entre desempenho e eficiência computacional.

Esse tamanho permite que você execute o modelo na maioria das plataformas de nuvem e plataformas de alta RAM/VRAM, tornando-o versátil e acessível para vários aplicativos. O número considerável de parâmetros permite que o modelo capture padrões complexos de linguagem, aumentando sua capacidade de executar uma ampla gama de tarefas.

Treinado em um grande conjunto de dados

O modelo foi treinado em um extenso conjunto de dados de 2,5 trilhões de tokens, fornecendo uma base sólida para lidar com uma ampla variedade de tarefas linguísticas. Isso permite que o modelo DCLM-7B compreenda e gere texto com um alto grau de precisão e relevância. Além disso, isso torna o modelo uma boa opção para ajuste fino específico da tarefaespecífico da tarefa, pois ele tem um entendimento básico robusto do idioma inglês.

Janela de contexto

O modelo básico DCLM-7B tem uma janela de contexto de 2048 tokens, o que permite processar sequências de texto relativamente longas. Embora isso seja relativamente pequeno para os padrões atuais, a Apple também lançou o lançou uma variante com uma janela de contexto de token de 8K.

Essa janela de contexto estendida oferece ainda mais flexibilidade para lidar com entradas mais longas, tornando o modelo adequado para aplicativos que exigem o processamento de textos ou documentos extensos, como Retrieval Augmented Generation (RAG).

Primeiros passos com o DCLM-7B

A Apple tornou o modelo DCLM-7B compatível com Hugging Facetransformers, tornando-o fácil de acessar e usar.

Você pode encontrar a página da web da modelo em Hugging Facee você pode conferir o repositório do GitHub para obter mais detalhes. Para usar e acessar o modelo, você precisará instalar a biblioteca transformers:

pip install transformers

Além disso, precisaremos instalar a estrutura open_lm:

pip install git+https://github.com/mlfoundations/open_lm.git

O modelo DCLM-7B com precisão total é bastante grande, com aproximadamente 27,5 GB, exigindo uma quantidade significativa de RAM ou VRAM para ser executado. Você precisará de um computador de última geração ou de algum tipo de ambiente de nuvem. Usarei o notebook de assinatura premium do Google Colab com 50 GB de RAM e uma GPU L4.

Com todas as bibliotecas necessárias instaladas, estamos prontos para começar a usar o modelo!

DCLM-7B: Exemplo de uso

Para o exemplo, executarei um exemplo básico fornecido na página da Web do modelo Huggingface. Primeiro, importamos todas as bibliotecas necessárias:

from open_lm.hf import *
from transformers import AutoTokenizer, AutoModelForCausalLM

Em seguida, precisamos baixar e inicializar o tokenizador e o modelo (observe que, neste exemplo, estamos executando o modelo com valores flutuantes de precisão total em uma CPU):

tokenizer = AutoTokenizer.from_pretrained("apple/DCLM-Baseline-7B")
model = AutoModelForCausalLM.from_pretrained("apple/DCLM-Baseline-7B")

E, por fim, executamos o prompt de exemplo:

inputs = tokenizer(["Machine learning is"], return_tensors="pt")
gen_kwargs = {"max_new_tokens": 50, "top_p": 0.8, "temperature": 0.8, "do_sample": True, "repetition_penalty": 1.1}
output = model.generate(inputs['input_ids'], **gen_kwargs)
output = tokenizer.decode(output[0].tolist(), skip_special_tokens=True)

Obtive o seguinte resultado:

[Machine learning is not the solution to everything, it just enables you to solve a problem that otherwise would have been impossible. The biggest challenge for me as a manager of an AI team was to identify those problems where machine learning can really add value and be successful.]

Uso avançado e ajuste fino

O ajuste fino do modelo DCLM-7B pode ajudar a adaptá-lo a tarefas específicas, melhorando seu desempenho em suas aplicações. Infelizmente, o modelo DCLM-7B não é compatível com a biblioteca peft da Huggingface e, portanto, precisamos usar a biblioteca transformers para fazer o ajuste fino.

Sem ferramentas como o LoRAo ajuste fino de um modelo tão grande requer imensos recursos, pois é basicamente o mesmo que treiná-lo do zero. Portanto, vou apenas descrever o processo de ajuste fino aqui, sem executá-lo de fato para ver os resultados.

Preparando o conjunto de dados

Para fazer download e usar um conjunto de dados disponível abertamente, usaremos a biblioteca datasets da Hugging Face. Nós o instalamos com o seguinte comando:

pip install datasets

Depois de instalado, você pode importar e usar a função load_dataset. Neste exemplo, usarei o conjunto de dados wikitext:

from datasets import load_dataset
dataset = load_dataset('wikitext', 'wikitext-2-raw-v1')

Agora, precisamos tokenizar o conjunto de dados:

def tokenize_function(examples):
	return tokenizer(examples['text'], padding='max_length', truncation=True, max_length=512)
tokenized_datasets = dataset.map(tokenize_function, batched=True)

Agora, estamos prontos para começar a fazer o ajuste fino!

Ajuste fino

Para fazer o ajuste fino, precisamos importar e inicializar os objetos TrainingArguments e Trainer e, em seguida, executar a função train().

from transformers import TrainingArguments, Trainer
training_args = TrainingArguments(
	    report_to = "none",
	    output_dir="./results",
	    evaluation_strategy="epoch",
	    learning_rate=2e-5,  # Controls how much to change the model weights during training
	    per_device_train_batch_size=2,  # Number of samples per batch per device during training
	    per_device_eval_batch_size=2,  # Number of samples per batch per device during evaluation
	    num_train_epochs=3,  # Number of times the entire training dataset will be passed through the model
	    weight_decay=0.01,  # Regularization technique to prevent overfitting
	)
trainer = Trainer(
	    model=model,
	    args=training_args,
	    train_dataset=tokenized_datasets['train'],
	    eval_dataset=tokenized_datasets['test'],
	    data_collator=data_collator,
	    tokenizer=tokenizer,
	)
trainer.train()

Conclusão

Em geral, o DCLM-7B da Apple é um acréscimo significativo ao cenário de modelos de linguagem de código aberto, oferecendo aos pesquisadores e desenvolvedores uma ferramenta avançada para várias tarefas de PNL.

Como um modelo de transformador somente de decodificador, ele é otimizado para geração de textofornecendo resultados coerentes e contextualmente relevantes. A disponibilidade do modelo sob o Contrato de Licença de Software Acadêmico da Apple incentiva ainda mais a colaboração e a inovação na comunidade de IA.