Como acessar o Llama3 com Flask?

Introdução

O mundo da IA ​​ficou muito mais emocionante com o lançamento do Llama3! Este poderoso modelo de linguagem de código aberto, criado pela Meta, está agitando as coisas. Llama3, disponível em variantes 8B e 70B pré-treinadas e ajustadas por instrução, oferece uma ampla gama de aplicações. Neste guia, exploraremos os recursos do Llama3 e como acessar o Llama3 com Frasco, concentrando-se no seu potencial para revolucionar a IA generativa.

Objetivos de aprendizagem

• Explore a arquitetura e as metodologias de treinamento por trás do Llama3, descobrindo seus inovadores dados de pré-treinamento e afinação técnicas, essenciais para compreender seu desempenho excepcional.
• Experimente a implementação prática do Llama3 por meio do Flask, dominando a arte da geração de texto usando transformadores e, ao mesmo tempo, obtendo insights sobre os aspectos críticos dos testes e ajustes de segurança.
• Analise as capacidades impressionantes do Llama3, incluindo sua maior precisão, adaptabilidade e escalabilidade robusta, ao mesmo tempo que reconhece suas limitações e riscos potenciais, cruciais para o uso e desenvolvimento responsáveis.
• Envolva-se com exemplos do mundo real e casos de uso do Llama3, capacitando-o a aproveitar seu poder de forma eficaz em diversos aplicativos e cenários, liberando assim todo o seu potencial no domínio da IA ​​generativa.

Este artigo foi publicado como parte do Blogatona de Ciência de Dados.

Arquitetura e Treinamento Llama3

Lhama3 é um modelo de linguagem auto-regressivo que aproveita uma arquitetura de transformador otimizada. Sim, o transformador normal, mas com uma abordagem atualizada. As versões ajustadas empregam ajuste fino supervisionado (SFT) e aprendizagem por reforço com feedback humano (RLHF) para se alinhar às preferências humanas de utilidade e segurança. O modelo foi pré-treinado em um extenso corpus de mais de 15 trilhões de tokens de dados de fontes disponíveis publicamente, com um ponto de corte de março de 2023 para o modelo 8B e dezembro de 2023 para o modelo 70B, respectivamente. Os dados de ajuste fino incorporam conjuntos de dados de instruções disponíveis publicamente, bem como mais de 10 milhões de exemplos anotados por humanos.

Capacidades impressionantes do Llama3

Como observamos anteriormente, o Llama3 possui um design de transformador otimizado e vem em dois tamanhos, parâmetros 8B e 70B, em versões pré-treinadas e ajustadas por instrução. O tokenizer do modelo possui um vocabulário de token de 128K. Sequências de 8,192 tokens foram utilizadas para treinar os modelos. Llama3 provou ser notavelmente capaz do seguinte:

• Precisão aprimorada: Llama3 mostrou melhor desempenho em várias tarefas de processamento de linguagem natural.
• Adaptabilidade: A capacidade do modelo de se adaptar a diversos contextos e tarefas o torna a escolha ideal para uma ampla gama de aplicações.
• Escalabilidade robusta: A escalabilidade do Llama3 permite lidar com grandes volumes de dados e tarefas complexas com facilidade.
• Capacidades de codificação: A capacidade de codificação do Llama3 é considerada nada menos que notável, com incríveis mais de 250 tokens por segundo. Em vez das GPUs douradas, a eficiência das LPUs é incomparável, tornando-as a escolha superior para executar modelos de linguagens grandes.

A vantagem mais significativa do Llama3 é sua natureza de código aberto e gratuita, tornando-o acessível aos desenvolvedores sem gastar muito.

Variantes e recursos do Llama3

Conforme mencionado anteriormente, o Llama3 oferece duas variantes principais, cada uma atendendo a diferentes casos de uso com dois tamanhos de 8B e 70B:

• Modelos pré-treinados: Adequado para tarefas de geração de linguagem natural. Um pouco mais geral no desempenho.
• Modelos ajustados por instrução: Otimizado para casos de uso de diálogo, superando muitos modelos de chat de código aberto em benchmarks do setor.

Dados de treinamento e benchmarks do Llama3

O Llama3 foi pré-treinado em um extenso corpus de mais de 15 trilhões de tokens de dados disponíveis publicamente, com limite de março de 2023 para o modelo 8B e dezembro de 2023 para o modelo 70B. Os dados de ajuste fino incorporam conjuntos de dados de instruções disponíveis publicamente e mais de 10 milhões de exemplos anotados por humanos (você ouviu certo!). O modelo alcançou resultados impressionantes em benchmarks automáticos padrão, incluindo MMLU, AGIEval English, CommonSenseQA e muito mais.

Casos de uso e exemplos do Llama3

Lhama pode ser usada como outras Família lhama modelos que também tornaram seu uso muito fácil. Basicamente precisamos instalar o transformador e acelerar. Veremos um script wrapper nesta seção. Você pode encontrar todos os trechos de código e o notebook para rodar com GPU Aqui. Adicionei o notebook, um aplicativo flask e um script de modo interativo para testar o comportamento do modelo. Aqui está um exemplo de uso do Llama3 com pipeline:

Como acessar o Llama3 com Flask?

Vamos agora explorar as etapas para acessar o Llama3 com Flask.

Etapa 1: configurar o ambiente Python

Crie um ambiente virtual (opcional, mas recomendado):

$ python -m venv env
$ source env/bin/activate   # On Windows use `.envScriptsactivate`

Instale os pacotes necessários:

Instalamos o transformador e aceleramos, mas como o Llama3 é novo, continuamos instalando diretamente do Git Hub.

(env) $ pip install -q git+https://github.com/huggingface/transformers.git
(env) $ pip install -q flask transformers torch accelerate # datasets peft bitsandbytes

Etapa 2: preparar o arquivo principal do aplicativo

Crie um novo arquivo Python chamado main.py. Dentro dele, cole o seguinte código.

from flask import Flask, request, jsonify
import transformers
import torch

app = Flask(__name__)

# Initialize the model and pipeline outside of the function to avoid unnecessary reloading
model_id = "meta-llama/Meta-Llama-3-8B-Instruct"
pipeline = transformers.pipeline(
    "text-generation",
    model=model_id,
    model_kwargs={"torch_dtype": torch.bfloat16},
    device_map="auto",
)


@app.route('/generate', methods=['POST'])
def generate():
    data = request.get_json()
    user_message = data.get('message')

    if not user_message:
        return jsonify({'error': 'No message provided.'}), 400

    # Create system message
    messages = [{"role": "system", "content": "You are a pirate chatbot who always responds in pirate speak!"}]

    # Add user message
    messages.append({"role": "user", "content": user_message})

    prompt = pipeline.tokenizer.apply_chat_template(
        messages,
        tokenize=False,
        add_generation_prompt=True
    )

    terminators = [
        pipeline.tokenizer.eos_token_id,
        pipeline.tokenizer.convert_tokens_to_ids("<|eot_id|>")
    ]

    outputs = pipeline(
        prompt,
        max_new_tokens=256,
        eos_token_id=terminators,
        do_sample=True,
        temperature=0.6,
        top_p=0.9,
    )

    generated_text = outputs[0]['generated_text'][len(prompt):].strip()
    response = {
        'message': generated_text
    }

    return jsonify(response), 200


if __name__ == '__main__':
    app.run(debug=True)

O código acima inicializa um servidor web Flask com uma única rota, /gerar, responsável por receber e processar mensagens de usuários e retornar respostas geradas por IA.

Etapa 3: execute o aplicativo Flask

Execute o aplicativo Flask executando o seguinte comando:

(env) $ export FLASK_APP=main.py
(env) $ flask run --port=5000

Agora, você deve ter o aplicativo Flask rodando em http://localhost:5000. Você pode testar a API por meio de ferramentas como Postman ou CURL, ou até mesmo escrever uma página HTML simples.

Modo interativo usando transformadores AutoModelForCausalLM

Para consultar interativamente o modelo no Jupyter Notebook, cole-o em uma célula e execute:

import requests
import sys
sys.path.insert(0,'..')
import torch

from transformers import AutoTokenizer, AutoModelForCausalLM

MODEL_NAME ='meta-llama/Meta-Llama-3-8B-Instruct'

class InteractivePirateChatbot:
    def __init__(self):
        self._tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, padding_side='left')
        self._tokenizer.pad_token = self._tokenizer.eos_token
        self._model = AutoModelForCausalLM.from_pretrained(MODEL_NAME, torch_dtype=torch.bfloat16, device_map="auto", offload_buffers=True)
        
    def _prepare_inputs(self, messages):
        try:
            inputs = self._tokenizer([message['content'] for message in messages], padding='longest', truncation=True, max_length=512, return_tensors='pt')
            input_ids = inputs.input_ids.to(self._model.device)
            attention_mask = inputs.attention_mask.to(self._model.device)
            return {'input_ids': input_ids, 'attention_mask': attention_mask}
        except Exception as e:
            print(f"Error preparing inputs: {e}")
            return None

    def ask(self, question):
        try:
            messages = [
                {"role": "system", "content": "You are a pirate chatbot who always responds in pirate speak!"},
                {"role": "user", "content": question}
            ]

            prepared_data = self._prepare_inputs(messages)
            if prepared_data is None:
                print("Error preparing inputs. Skipping...")
                return

            output = self._model.generate(**prepared_data, max_length=512, num_beams=5, early_stopping=True)

            answer = self._tokenizer.decode(output[0], skip_special_tokens=True)
            print("Pirate:", answer)
        except Exception as e:
            print(f"Error generating response: {e}")

generator = InteractivePirateChatbot()
while True:
    question = input("User: ")
    generator.ask(question)

O código acima permitirá que você interaja rapidamente e veja como o modelo funciona. Encontre o código inteiro SUA PARTICIPAÇÃO FAZ A DIFERENÇA.

User: "Who are you?"

Pirate: "Arrrr, me hearty! Me name be Captain Chat, the scurviest pirate chatbot to ever sail the Seven Seas! I be here to swab yer decks with me clever responses and me trusty parrot, Polly, perched on me shoulder. So hoist the colors, me matey, and let's set sail fer a swashbucklin' good time!"

Já que vimos como funciona o modelo, vamos ver alguns guias de segurança e responsabilidade.

Responsabilidade e Segurança

A Meta tomou uma série de medidas para garantir o desenvolvimento responsável da IA, incluindo a implementação de melhores práticas de segurança, fornecendo recursos como proteções Meta Llama Guard 2 e Code Shield e atualizando o Guia de Uso Responsável. Os desenvolvedores são incentivados a ajustar e implantar essas proteções de acordo com suas necessidades, avaliando os benefícios do alinhamento e da utilidade para seu caso de uso e público específicos. Todos esses links estão disponíveis no repositório Hugginface para Llama3.

Considerações e limitações éticas

Embora o Llama3 seja uma ferramenta poderosa, é essencial reconhecer suas limitações e riscos potenciais. O modelo pode produzir respostas imprecisas, tendenciosas ou questionáveis ​​às solicitações do usuário. Portanto, os desenvolvedores devem realizar testes de segurança e ajustes adaptados às aplicações específicas do modelo. Meta recomenda incorporar soluções Purple Llama em fluxos de trabalho, especificamente Llama Guard, que fornece um modelo básico para filtrar prompts de entrada e saída para colocar a segurança em nível de sistema sobre a segurança em nível de modelo.

Conclusão

A Meta remodelou o cenário da inteligência artificial com a introdução do Llama3, um potente modelo de linguagem de código aberto criado pela Meta. Com sua disponibilidade em versões 8B e 70B pré-treinadas e ajustadas para instrução, o Llama3 apresenta uma infinidade de possibilidades de inovação. Este guia forneceu uma exploração aprofundada dos recursos do Llama3 e como acessá-lo com Flask, enfatizando seu potencial para redefinir a IA generativa.

Principais lições

• A Meta desenvolveu o Llama3, um poderoso modelo de linguagem de código aberto disponível em versões 8B e 70B pré-treinadas e ajustadas para instrução.
• O Llama3 demonstrou capacidades impressionantes, incluindo maior precisão, adaptabilidade e escalabilidade robusta.
• O modelo é de código aberto e totalmente gratuito, tornando-o acessível a desenvolvedores e pesquisadores de baixo orçamento.
• Os usuários podem utilizar o Llama3 com transformadores, aproveitando a abstração do pipeline ou classes Auto com a função generate().
• Llama3 e Flask permitem que os desenvolvedores explorem novos horizontes em IA generativa, promovendo soluções inovadoras como chatbots e geração de conteúdo, ampliando os limites da interação homem-máquina.

Perguntas Frequentes

Ligações Úteis

A mídia mostrada neste artigo não é propriedade da Analytics Vidhya e é usada a critério do Autor.

• Conteúdo com tecnologia de SEO e distribuição de relações públicas. Seja amplificado hoje.
• PlatoData.Network Gerativa Vertical Ai. Capacite-se. Acesse aqui.
• PlatoAiStream. Inteligência Web3. Conhecimento Amplificado. Acesse aqui.
• PlatãoESG. Carbono Tecnologia Limpa, Energia, Ambiente, Solar, Gestão de resíduos. Acesse aqui.
• PlatoHealth. Inteligência em Biotecnologia e Ensaios Clínicos. Acesse aqui.
• Fonte: https://www.analyticsvidhya.com/blog/2024/04/how-to-access-llama3-with-flask/