Construyendo una interfaz de chat bilingüe interactiva (árabe e inglesa) con código abierto Meraj-Mini por Arcee AI: Aprovechando la aceleración de GPU, Pytorch, Transformers, Acelerate, Bitsandbytes y Gradio

En este tutorial, implementamos un asistente de chat bilingüe impulsado por el modelo Meraj-Mini de Arcee, que se implementa sin problemas en Google Colab usando T4 GPU. Este tutorial muestra las capacidades de los modelos de lenguaje de código abierto al tiempo que proporciona una experiencia práctica y práctica en la implementación de soluciones de IA de última generación dentro de las limitaciones de recursos de nube gratuitos. Utilizaremos una poderosa pila de herramientas que incluyen:

1. Modelo Meraj-Mini de Arcee
2. Biblioteca de transformadores para la carga y tokenización del modelo
3. Acelerar y bitsandbytes para una cuantificación eficiente
4. Pytorch para aprendizaje profundo cálculos
5. Gradio para crear una interfaz web interactiva

# Enable GPU acceleration
!nvidia-smi --query-gpu=name,memory.total --format=csv


# Install dependencies
!pip install -qU transformers accelerate bitsandbytes
!pip install -q gradio

Primero habilitamos la aceleración de la GPU consultando el nombre de la GPU y la memoria total utilizando el comando nvidia-smi. Luego instala y actualiza las bibliotecas clave de Python, como transformadores, acelerar, bitsandbytes y gradio, para admitir aprendizaje automático tareas e implementar aplicaciones interactivas.

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline, BitsAndBytesConfig


quant_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_use_double_quant=True
)




model = AutoModelForCausalLM.from_pretrained(
    "arcee-ai/Meraj-Mini",
    quantization_config=quant_config,
    device_map="auto"
)
tokenizer = AutoTokenizer.from_pretrained("arcee-ai/Meraj-Mini")

Luego configuramos la configuración de cuantización de 4 bits utilizando bitsandbytesconfig para una carga de modelo eficiente, luego carga el modelo de lenguaje causal «Arcee-Ai/Meraj-Mini» junto con su tokenizador de abrazar la cara, mapeando automáticamente dispositivos para un rendimiento óptimo.

chat_pipeline = pipeline(
    "text-generation",
    model=model,
    tokenizer=tokenizer,
    max_new_tokens=512,
    temperature=0.7,
    top_p=0.9,
    repetition_penalty=1.1,
    do_sample=True
)

Aquí creamos una tubería de generación de texto adaptada para interacciones de chat utilizando la función de tubería de Hugging Face. Configura la multa máxima de tokens, temperatura, TOP_P y repetición máximos para equilibrar la diversidad y la coherencia durante la generación de texto.

def format_chat(messages):
    prompt = ""
    for msg in messages:
        prompt += f"<|im_start|>{msg['role']}n{msg['content']}<|im_end|>n"
    prompt += "<|im_start|>assistantn"
    return prompt


def generate_response(user_input, history=[]):
    history.append({"role": "user", "content": user_input})
    formatted_prompt = format_chat(history)
    output = chat_pipeline(formatted_prompt)[0]['generated_text']
    assistant_response = output.split("<|im_start|>assistantn")[-1].split("<|im_end|>")[0]
    history.append({"role": "assistant", "content": assistant_response})
    return assistant_response, history

Definimos dos funciones para facilitar una interfaz de conversación. La primera función formatea un historial de chat en un mensaje estructurado con delimitadores personalizados, mientras que la segunda agrega un nuevo mensaje de usuario, genera una respuesta utilizando la tubería de generación de texto y actualiza el historial de conversación en consecuencia.

import gradio as gr


with gr.Blocks() as demo:
    chatbot = gr.Chatbot()
    msg = gr.Textbox(label="Message")
    clear = gr.Button("Clear History")
   
    def respond(message, chat_history):
        response, _ = generate_response(message, chat_history.copy())
        return response, chat_history + [(message, response)]


    msg.submit(respond, [msg, chatbot], [msg, chatbot])
    clear.click(lambda: None, None, chatbot, queue=False)


demo.launch(share=True)

Finalmente, creamos una interfaz de chatbot basada en la web usando Gradio. Crea elementos de interfaz de usuario para el historial de chat, la entrada de mensajes y un botón de historial claro, y define una función de respuesta que se integra con la tubería de generación de texto para actualizar la conversación. Finalmente, la demostración se lanza con el intercambio habilitado para el acceso público.

Aquí está el Cuaderno de colab. Además, no olvides seguirnos Gorjeo y únete a nuestro Canal de telegrama y LinkedIn GRsalpicar. No olvides unirte a nuestro Subreddit de 80k+ ml.