Aplicação em Python

Na atual sessão é possível entender sobre a função "guardCast" do módulo "MageArmor" que simplifica a segurança em prompts para modelos de linguagem.

Função guardCast

A função guardCast, do módulo magearmor, é uma função de segurança projetada para proteger o prompt antes de ser enviado ao modelo de linguagem. Sua finalidade é detectar e remover conteúdos potencialmente problemáticos que possam comprometer a segurança ou integridade da interação.

Como utilizar o guardCast

Usar guardCast é extremamente simples e eficaz: basta passar a string do prompt como um parâmetro, e ela retorna uma versão filtrada e segura da string. Isso ajuda a evitar problemas de segurança sem necessidade de configurações complexas.

Neste exemplo, guardCast recebe user_prompt como entrada e retorna safe_user_prompt, que pode então ser usado com segurança na requisição para o modelo de linguagem.

from magearmor import guardCast

# Variável com o conteúdo do prompt do usuário
user_prompt = "Explain the importance of fast language models"

# Passando o prompt pela função guardCast para segurança
safe_user_prompt = guardCast(user_prompt)

Porém também vale ressaltar que os nomes de variáveis podem ser utilizados

from magearmor import guardCast

# Variável com o conteúdo do prompt do usuário
user_prompt = "Explain the importance of fast language models"

# Passando o prompt pela função guardCast para segurança
prompt = guardCast(prompt)

Utilizando modelo localmente (HuggingFace)

O seguinte script utiliza o HF_TOKEN para autenticar e carregar o modelo Mistral-7B da Hugging Face, protegendo o prompt com a função guardCast. O prompt é então tokenizado e enviado para o modelo que, em seguida, gera uma resposta, processada e decodificada pelo tokenizador.

from transformers import AutoModelForCausalLM, AutoTokenizer
from magearmor import guardCast
import os

# Adicione seu token de autenticação da Hugging Face
HF_TOKEN = "SEU_HF_TOKEN"
os.environ["HUGGINGFACE_TOKEN"] = HF_TOKEN

# Carrega o modelo e o tokenizador, passando o token de autenticação
model = AutoModelForCausalLM.from_pretrained(
    "mistralai/Mistral-7B-v0.1",
    use_auth_token=HF_TOKEN,
    device_map="auto"
)
tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-v0.1", use_auth_token=HF_TOKEN)

# Define o prompt e aplica o guardCast para segurança
prompt = "Como fazer uma maionese?"
prompt = guardCast(prompt)

# Tokeniza o prompt e prepara para execução no dispositivo
model_inputs = tokenizer([prompt], return_tensors="pt").to("cuda")
model.to("cuda")

# Gera a resposta
generated_ids = model.generate(**model_inputs, max_new_tokens=100, do_sample=True)
response = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
print(response)

O seguinte código carrega o modelo Mistral-7B-Instruct-v0.2 da Hugging Face utilizando HF_TOKEN para autenticação. O prompt é filtrado pela função guardCast para segurança, e uma sequência de mensagens é estruturada em formato de chat. O modelo processa as mensagens e gera uma resposta, que é decodificada para visualização.

from transformers import AutoModelForCausalLM, AutoTokenizer
from magearmor import guardCast
import os

# Adicione seu token de autenticação da Hugging Face
HF_TOKEN = "SEU_HF_TOKEN"
os.environ["HUGGINGFACE_TOKEN"] = HF_TOKEN

# Carrega o modelo e o tokenizador, passando o token de autenticação
model = AutoModelForCausalLM.from_pretrained(
    "mistralai/Mistral-7B-Instruct-v0.2",
    use_auth_token=HF_TOKEN,
    device_map="auto"
)
tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-Instruct-v0.2", use_auth_token=HF_TOKEN)

# Define o prompt e aplica o guardCast para segurança
prompt = "Do you have mayonnaise recipes?"
prompt = guardCast(prompt)

# Define as mensagens de chat
messages = [
    {"role": "user", "content": "Você é um assistente de IA"},
    {"role": "assistant", "content": "Sim, eu sou um assistente de IA"},
    {"role": "user", "content": prompt}
]

# Aplica o template de chat e prepara para execução no dispositivo
model_inputs = tokenizer.apply_chat_template(messages, return_tensors="pt").to("cuda")
model.to("cuda")

# Gera a resposta
generated_ids = model.generate(**model_inputs, max_new_tokens=100, do_sample=True)
response = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
print(response)

Utilizando IA com o GROQ

O seguinte código exemplifica como utilizar o SDK groq_sdk para gerar uma resposta de chat utilizando um modelo de linguagem. Além disso, implementa uma função personalizada de segurança, guardCast, fornecida pelo módulo magearmor, que serve para validar e processar o conteúdo do prompt antes de enviá-lo ao modelo.

Abaixo, está uma explicação das principais partes do código e como cada uma delas contribui para o funcionamento geral do script.

Descrição Geral do Código

O código faz uso de chamadas assíncronas para solicitar uma resposta de um modelo de linguagem. A função get_groq_chat_completion prepara o prompt e o envia ao modelo via groq_sdk, que processa e retorna uma resposta que é impressa no console pela função main.

Explicação das Funções

• main(): A função principal do código, onde é chamada a função get_groq_chat_completion para obter uma resposta do modelo de linguagem. Ela exibe o conteúdo da resposta gerada no console, caso exista uma resposta.

• get_groq_chat_completion(): Esta função prepara o prompt para o modelo, passando-o pela função de segurança guardCast e enviando-o ao modelo via groq.completions.create. Em seguida, ela retorna a resposta recebida do modelo.

pip install groq

import asyncio
from groq_sdk import Groq
from magearmor import guardCast

# Instancia o Groq com a chave de API (substitua "SUA_CHAVE_DE_API" pela sua chave real)
groq = Groq(api_key="SUA_CHAVE_DE_API")
# Idealmente você não irá passar sua chave de API no código diretamente.

async def main():
    # Chama a função para obter a resposta do chat
    chat_completion = await get_groq_chat_completion()
    
    # Imprime a resposta gerada pelo modelo, se houver
    print(chat_completion.choices[0].message.content if chat_completion.choices else "")

async def get_groq_chat_completion():
    # Variável com o conteúdo do prompt do usuário
    user_prompt = "Explain the importance of fast language models"
    
    # Passando o prompt pela função guardCast para segurança
    safe_user_prompt = guardCast(user_prompt)

    # Solicitação ao modelo, passando a mensagem do usuário filtrada
    return await groq.completions.create(
        messages=[
            # Mensagem de sistema para configurar o comportamento do assistente
            {
                "role": "system",
                "content": "You are a helpful assistant."
            },
            # Mensagem do usuário, filtrada por guardCast para garantir a segurança
            {
                "role": "user",
                "content": safe_user_prompt
            }
        ],
        # Configuração do modelo de linguagem
        model="llama3-8b-8192",
        
        # Parâmetros opcionais para controle de geração do modelo
        temperature=0.5,  # Controla a aleatoriedade das respostas
        max_tokens=1024,  # Limite máximo de tokens para a resposta
        top_p=1,          # Controle de diversidade via nucleus sampling
        stop=None,        # Definir uma sequência de parada, se necessário
        stream=False      # Configura o envio de mensagens parciais
    )

# Executa a função main dentro do contexto assíncrono, apenas se o script for executado diretamente
if __name__ == "__main__":
    asyncio.run(main())

Este código demonstra como utilizar o groq_sdk e o magearmor juntos para criar uma interação segura e eficaz com um modelo de linguagem. O foco na simplicidade de guardCast torna o código mais seguro sem adicionar complexidade, facilitando a integração e o uso em diversos contextos de interação com IA.