En este artículo, aprenderá cómo ajustar modelos de lenguajes grandes de código abierto para atención al cliente utilizando Unsloth y QLoRA, desde la preparación de conjuntos de datos hasta la capacitación, las pruebas y la comparación.
Los temas que cubriremos incluyen:
Configurar un entorno Colab e instalar las bibliotecas necesarias. Preparar y formatear un conjunto de datos de atención al cliente para ajustar las instrucciones. Entrenamiento con adaptadores LoRA, guardado, prueba y comparación con un modelo base.
Vayamos a ello.
Cómo ajustar un modelo local Mistral/Llama 3 en su propio conjunto de datos
Introducción
Los modelos de lenguajes grandes (LLM) como Mistral 7B y Llama 3 8B han sacudido el campo de la IA, pero su naturaleza amplia limita su aplicación a áreas especializadas. El ajuste fino transforma estos modelos de propósito general en expertos en un dominio específico. Para la atención al cliente, esto significa una reducción del 85 % en el tiempo de respuesta, una voz de marca consistente y disponibilidad 24 horas al día, 7 días a la semana. Ajustar los LLM para dominios específicos, como la atención al cliente, puede mejorar drásticamente su desempeño en tareas específicas de la industria.
En este tutorial, aprenderemos cómo ajustar dos potentes modelos de código abierto, Mistral 7B y Llama 3 8B, utilizando un conjunto de datos de preguntas y respuestas de atención al cliente. Al final de este tutorial, aprenderá cómo:
Configurar un entorno de capacitación basado en la nube usando Google Colab Preparar y formatear conjuntos de datos de atención al cliente Ajustar Mistral 7B y Llama 3 8B usando la Adaptación cuantificada de bajo rango (QLoRA) Evaluar el rendimiento del modelo Guardar e implementar sus modelos personalizados
Requisitos previos
Esto es lo que necesitará para aprovechar al máximo este tutorial.
Una cuenta de Google para acceder a Google Colab. Puede consultar Colab aquí para ver si está listo para acceder. Una cuenta de Hugging Face para acceder a modelos y conjuntos de datos. Puedes registrarte aquí.
Después de tener acceso a Hugging Face, deberá solicitar acceso a estos 2 modelos privados:
Mistral: Mistral-7B-Instruct-v0.3 Llama 3: Meta-Llama-3-8B-Instruct
Y en cuanto a los conocimientos necesarios que debes tener antes de empezar, aquí tienes un resumen conciso:
Programación básica en Python Familiarizarse con los cuadernos de Jupyter Comprensión de los conceptos de aprendizaje automático (útil pero no obligatorio) Conocimiento básico de la línea de comandos
Ahora debería estar listo para comenzar.
El proceso de ajuste
El ajuste adapta un LLM previamente capacitado a tareas específicas mediante la capacitación continua sobre datos específicos del dominio. A diferencia de la ingeniería rápida, el ajuste fino en realidad modifica los pesos del modelo.
Paso 1: Introducción a Google Colab
Visite Google Colab Cree una nueva libreta: Archivo → Nueva libreta Asígnele un nombre preferido Establezca GPU: Tiempo de ejecución → Cambiar tipo de tiempo de ejecución → GPU T4
Paso 2: instale Unsloth (ejecute esto primero)
Aquí instalaremos Unsloth y sus dependencias. Unsloth maneja la configuración de CUDA automáticamente.
!pip install “unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git”
!pip install –no-deps xformers trl peft accelerate bitsandbytes
print(“Unsloth installed successfully!”)
! pip install “unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git”
! pip install — no – deps xformers trl peft accelerate bitsandbytes
print ( “Unsloth installed successfully!” )
Paso 3: Importar Unsloth y configurar
El siguiente paso es importar Unsloth y realizar comprobaciones básicas.
from unsloth import FastLanguageModel
import torch
from trl import SFTTrainer
from transformers import TrainingArguments
from datasets import Dataset
import pandas as pd
import numpy as np
print(“Unsloth loaded successfully!”)
print(f”PyTorch: {torch.__version__}”)
print(f”CUDA: {torch.cuda.is_available()}”)
print(f”GPU: {torch.cuda.get_device_name(0) if torch.cuda.is_available() else ‘None’}”)
from unsloth import FastLanguageModel
import torch
from trl import SFTTrainer
from transformers import TrainingArguments
from datasets import Dataset
import pandas as pd
import numpy as np
print ( “Unsloth loaded successfully!” )
print ( f “PyTorch: {torch.__version__}” )
print ( f “CUDA: {torch.cuda.is_available()}” )
print ( f “GPU: {torch.cuda.get_device_name(0) if torch.cuda.is_available() else ‘None’}” )
Paso 4: crear un conjunto de datos de atención al cliente
Proporcionaremos datos realistas de atención al cliente en esta sección con el fin de ajustar el modelo.
print(“Creating customer support Q&A dataset…”)
# Create realistic customer support data
customer_support_data = [
{
“instruction”: “You are a helpful customer support agent. Answer clearly and professionally.”,
“input”: “How do I reset my password?”,
“output”: “To reset your password: 1) Click ‘Forgot Password’ on the login page 2) Enter your registered email 3) Check your inbox for the reset link 4) Click the link and create a new password. Check your spam folder if not received within 5 minutes.”
},
{
“instruction”: “You are a helpful customer support agent. Answer clearly and professionally.”,
“input”: “My payment was declined, what should I do?”,
“output”: “Common solutions: 1) Check that the card has sufficient funds 2) Ensure the card is not expired 3) Contact your bank to unblock the transaction 4) Try an alternative payment method like PayPal 5) Wait 24 hours before retrying.”
},
{
“instruction”: “You are a helpful customer support agent. Answer clearly and professionally.”,
“input”: “How do I cancel my subscription?”,
“output”: “To cancel: 1) Log in to your account 2) Go to ‘Billing & Subscriptions’ 3) Click ‘Cancel Subscription’ 4) Confirm cancellation. Your access continues until the end of the billing period. No partial refunds.”
},
{
“instruction”: “You are a helpful customer support agent. Answer clearly and professionally.”,
“input”: “The app keeps crashing on startup”,
“output”: “Troubleshooting steps: 1) Update the app to the latest version 2) Restart your device 3) Clear the app cache/data 4) Reinstall the app 5) Ensure 500MB free storage 6) Update your device OS. If it persists, contact support with error logs.”
},
{
“instruction”: “You are a helpful customer support agent. Answer clearly and professionally.”,
“input”: “Where is my order tracking information?”,
“output”: “You can find tracking: 1) Check the confirmation email 2) Log into your account > Orders 3) Click the tracking number. Standard shipping: 3-5 business days. Contact the carrier with the tracking number for the exact location.”
},
{
“instruction”: “You are a helpful customer support agent. Answer clearly and professionally.”,
“input”: “How do I contact customer support?”,
“output”: “Support options: 1) Live chat: Mon–Fri 9AM–6PM EST 2) Email: support@company.com (response within 24h) 3) Phone: 1-800-123-4567 4) Twitter: @CompanySupport. Please have your account email ready.”
},
{
“instruction”: “You are a helpful customer support agent. Answer clearly and professionally.”,
“input”: “Can I get a refund?”,
“output”: “Refund policy: 1) Digital products: Refund within 14 days if not used 2) Subscriptions: No refunds for partial months 3) Physical goods: Return within 30 days with receipt. Contact billing@company.com with your order ID.”
},
{
“instruction”: “You are a helpful customer support agent. Answer clearly and professionally.”,
“input”: “How do I change my email address?”,
“output”: “To change your email: 1) Log in to your account 2) Go to Account Settings 3) Click ‘Change Email’ 4) Enter the new email 5) Verify via the confirmation email sent to the new address. The update takes effect immediately.”
},
{
“instruction”: “You are a helpful customer support agent. Answer clearly and professionally.”,
“input”: “Is my data secure?”,
“output”: “Yes, we use: 1) AES-256 encryption 2) SSL/TLS for all connections 3) Regular security audits 4) GDPR compliance 5) Data is never sold to third parties. Read our privacy policy for details.”
},
{
“instruction”: “You are a helpful customer support agent. Answer clearly and professionally.”,
“input”: “Do you offer student discounts?”,
“output”: “Yes! Student discount: 50% off. Requirements: 1) Valid .edu email OR 2) Student ID photo. Apply: Email student@company.com with proof. The discount is applied after verification.”
},
]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
print(“Creating customer support Q&A dataset…”)
# Create realistic customer support data
customer_support_data = [
{
“instruction”: “You are a helpful customer support agent. Answer clearly and professionally.”,
“input”: “How do I reset my password?”,
“output”: “To reset your password: 1) Click ‘Forgot Password’ on the login page 2) Enter your registered email 3) Check your inbox for the reset link 4) Click the link and create a new password. Check your spam folder if not received within 5 minutes.”
},
{
“instruction”: “You are a helpful customer support agent. Answer clearly and professionally.”,
“input”: “My payment was declined, what should I do?”,
“output”: “Common solutions: 1) Check that the card has sufficient funds 2) Ensure the card is not expired 3) Contact your bank to unblock the transaction 4) Try an alternative payment method like PayPal 5) Wait 24 hours before retrying.”
},
{
“instruction”: “You are a helpful customer support agent. Answer clearly and professionally.”,
“input”: “How do I cancel my subscription?”,
“output”: “To cancel: 1) Log in to your account 2) Go to ‘Billing & Subscriptions’ 3) Click ‘Cancel Subscription’ 4) Confirm cancellation. Your access continues until the end of the billing period. No partial refunds.”
},
{
“instruction”: “You are a helpful customer support agent. Answer clearly and professionally.”,
“input”: “The app keeps crashing on startup”,
“output”: “Troubleshooting steps: 1) Update the app to the latest version 2) Restart your device 3) Clear the app cache/data 4) Reinstall the app 5) Ensure 500MB free storage 6) Update your device OS. If it persists, contact support with error logs.”
},
{
“instruction”: “You are a helpful customer support agent. Answer clearly and professionally.”,
"aporte" : "¿Dónde está la información de seguimiento de mi pedido?" ,
"producción" : "Puede encontrar seguimiento: 1) Consulte el correo electrónico de confirmación 2) Inicie sesión en su cuenta > Pedidos 3) Haga clic en el número de seguimiento. Envío estándar: 3-5 días hábiles. Comuníquese con el transportista con el número de seguimiento para la ubicación exacta".
} ,
{
"instrucción" : "Usted es un agente de atención al cliente útil. Responda de forma clara y profesional". ,
"aporte" : "¿Cómo me comunico con atención al cliente?" ,
"producción" : "Opciones de soporte: 1) Chat en vivo: lunes a viernes de 9 a. m. a 6 p. m. EST 2) Correo electrónico: support@company.com (respuesta dentro de las 24 horas) 3) Teléfono: 1-800-123-4567 4) Twitter: @CompanySupport. Tenga a mano el correo electrónico de su cuenta".
} ,
{
"instrucción" : "Usted es un agente de atención al cliente útil. Responda de forma clara y profesional". ,
"aporte" : "¿Puedo obtener un reembolso?" ,
"producción" : "Política de reembolso: 1) Productos digitales: Reembolso dentro de los 14 días si no se usan 2) Suscripciones: No hay reembolsos por meses parciales 3) Productos físicos: Devolución dentro de los 30 días posteriores al recibo. Comuníquese con billing@company.com con su ID de pedido".
} ,
{
"instrucción" : "Usted es un agente de atención al cliente útil. Responda de forma clara y profesional". ,
"aporte" : "¿Cómo cambio mi dirección de correo electrónico?" ,
"producción" : "Para cambiar su correo electrónico: 1) Inicie sesión en su cuenta 2) Vaya a Configuración de la cuenta 3) Haga clic en 'Cambiar correo electrónico' 4) Ingrese el nuevo correo electrónico 5) Verifique a través del correo electrónico de confirmación enviado a la nueva dirección. La actualización entra en vigor inmediatamente."
} ,
{
"instrucción" : "Usted es un agente de atención al cliente útil. Responda de forma clara y profesional". ,
"aporte" : "¿Mis datos están seguros?" ,
"producción" : "Sí, utilizamos: 1) cifrado AES-256 2) SSL/TLS para todas las conexiones 3) auditorías de seguridad periódicas 4) cumplimiento del RGPD 5) los datos nunca se venden a terceros. Lea nuestra política de privacidad para obtener más detalles".
} ,
{
"instrucción" : "Usted es un agente de atención al cliente útil. Responda de forma clara y profesional". ,
"aporte" : "¿Ofrecen descuentos para estudiantes?" ,
"producción" : "¡Sí! Descuento para estudiantes: 50 % de descuento. Requisitos: 1) Correo electrónico .edu válido O 2) Foto de identificación de estudiante. Solicite: envíe un correo electrónico a estudiante@company.com con un comprobante. El descuento se aplica después de la verificación".
} ,
]
También puedes crear más muestras duplicándolas y variando.
expanded_data =[]para el artículo en customer_support_data * 30: # Crea 300 muestras expanded_data.append(item.copy())
datos_expandidos = [ ]
para artículo en datos_de_asistencia_cliente * 30 : # Crea 300 muestras
datos_expandidos . agregar ( elemento . copiar ( ) )
Ahora, podemos convertir a un conjunto de datos:
# Convert to dataset
dataset = Dataset.from_pandas(pd.DataFrame(expanded_data))
print(f”Dataset created: {len(dataset)} samples”)
print(f”Sample:n{dataset[0]}")
# Convertir a conjunto de datos
conjunto de datos = Conjunto de datos . from_pandas ( pd . DataFrame ( datos_expandidos ) )
print ( f "Conjunto de datos creado: {len(conjunto de datos)} muestras" )
print ( f "Muestra:n{conjunto de datos[0]}" )
Paso 5: elige tu modelo (Mistral o Llama 3)
Usaremos Mistral 7B para este tutorial.
model_name = “unsloth/mistral-7b”
print(f”Selected: {model_name}”)
print(“Loading model (takes 2-5 minutes)…”)
nombre_modelo = "perezoso/mistral-7b"
imprimir ( f "Seleccionado: {nombre_modelo}" )
print ( "Cargando modelo (tarda entre 2 y 5 minutos)…" )
Paso 6: Cargue el modelo con Unsloth (¡4 veces más rápido!)
max_seq_length = 1024
dtype = torch.float16
load_in_4bit = True
max_seq_length = 1024
dtype = torch . float16
load_in_4bit = True
Cargue el modelo con optimización Unsloth y use el token = “hf_…” si tiene modelos cerrados como Llama 3.
model, tokenizer = FastLanguageModel.from_pretrained(
model_name=model_name,
max_seq_length=max_seq_length,
dtype=dtype,
load_in_4bit=load_in_4bit,
)
print(“Model loaded successfully!”)
if torch.cuda.is_available():
print(f”Memory used: {torch.cuda.memory_allocated() / 1e9:.2f} GB”)
model , tokenizer = FastLanguageModel . from_pretrained (
model_name = model_name ,
max_seq_length = max_seq_length ,
dtype = dtype ,
load_in_4bit = load_in_4bit ,
)
print ( “Model loaded successfully!” )
if torch . cuda . is_available ( ) :
print ( f “Memory used: {torch.cuda.memory_allocated() / 1e9:.2f} GB” )
La cuantificación load_in_4bit ahorra memoria. Utilice float16 para un entrenamiento más rápido y puede aumentar max_seq_length a 2048 para obtener respuestas más largas.
Paso 7: agregue adaptadores LoRA (optimizados para Unsloth)
Se recomienda LoRA para la mayoría de los casos de uso porque es rápido y eficiente en memoria:
model = FastLanguageModel.get_peft_model(
model,
r=16,
target_modules=[“q_proj”, “k_proj”, “v_proj”, “o_proj”,
“gate_proj”, “up_proj”, “down_proj”],
lora_alpha=16,
lora_dropout=0,
bias=”none”,
use_gradient_checkpointing=”unsloth”,
random_state=3407,
use_rslora=False,
loftq_config=None,
)
print(“LoRA adapters added!”)
print(“Trainable parameters added: Only ~1% of total parameters!”)
model = FastLanguageModel . get_peft_model (
model ,
r = 16 ,
target_modules = [ “q_proj” , “k_proj” , “v_proj” , “o_proj” ,
“gate_proj” , “up_proj” , “down_proj” ] ,
lora_alpha = 16 ,
lora_dropout = 0 ,
bias = “none” ,
use_gradient_checkpointing = “unsloth” ,
random_state = 3407 ,
use_rslora = False ,
loftq_config = None ,
)
print ( “LoRA adapters added!” )
print ( “Trainable parameters added: Only ~1% of total parameters!” )
target_modules: Qué capas adaptar (atención + MLP) r=16: Mayor = más adaptable, pero más parámetros lora_alpha=16: Factor de escala para pesos LoRA
Paso 8: Formatear el conjunto de datos para la capacitación
def formatting_prompts_func(examples):
“””Format dataset for instruction fine-tuning.”””
if “mistral” in model_name.lower():
texts =[]para instrucción, texto_entrada, salida en zip( ejemplos["instrucción"], ejemplos["entrada"], ejemplos["salida"] ): texto = f"[INST] {instrucción}nn{entrada_texto} [/INST] {salida}" texts.append(texto) return {"text": textos} elif "llama" en model_name.lower(): textos =[]para instrucción, texto_entrada, salida en zip( ejemplos["instrucción"], ejemplos["entrada"], ejemplos["salida"]): texto = f"""sistema {instrucción} usuario {entrada_texto} asistente {salida}""" textos.append(texto) return {"texto": textos} else: textos =[]para instrucción, texto_entrada, salida en zip( ejemplos["instrucción"], ejemplos["entrada"], ejemplos["salida"] ): texto = f"""### Instrucción: {instrucción} ### Entrada: {entrada_texto} ### Respuesta: {salida}""" texts.append(text) return {"text": texts} print("Formateando conjunto de datos…") conjunto de datos = dataset.map(formatting_prompts_func, lotes=True) print(f"Conjunto de datos formateado: {len(conjunto de datos)} muestras")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
def formatting_prompts_func ( ejemplos ) :
"" "Dar formato al conjunto de datos para ajustar las instrucciones." ""
si "mistral" en nombre_modelo . más bajo ( ) :
textos = [ ]
para instrucción , texto_entrada , salida en cremallera (
ejemplos [ "instrucción" ] ,
ejemplos [ "entrada" ] ,
ejemplos [ "salida" ]
) :
texto = f "[INST] {instrucción}nn{input_text} [/INST] {salida}"
textos . añadir ( texto )
devolver { "texto" : textos }
elif "llama" en nombre_modelo . más bajo ( ) :
textos = [ ]
para instrucción , texto_entrada , salida en cremallera (
ejemplos [ "instrucción" ] ,
ejemplos [ "entrada" ] ,
ejemplos [ "salida" ]
) :
texto = f "" "sistema
{instrucción}
usuario
{texto_entrada}
asistente
{producción}" ""
textos . añadir ( texto )
devolver { "texto" : textos }
demás :
textos = [ ]
para instrucción , texto_entrada , salida en cremallera (
ejemplos [ "instrucción" ] ,
ejemplos [ "entrada" ] ,
ejemplos [ "salida" ]
) :
texto = f "" "### Instrucción:
{instrucción}
### Aporte:
{texto_entrada}
### Respuesta:
{producción}" ""
textos . añadir ( texto )
devolver { "texto" : textos }
print ( "Formateando conjunto de datos…" )
conjunto de datos = conjunto de datos . mapa ( formatting_prompts_func , por lotes = Verdadero )
print ( f "Conjunto de datos formateado: {len(conjunto de datos)} muestras" )
Producción:
Paso 9: Configurar el entrenamiento (optimizado por Unsloth)
trainer = SFTTrainer(
model=model,
tokenizer=tokenizer,
train_dataset=dataset,
dataset_text_field=”text”,
max_seq_length=max_seq_length,
args=TrainingArguments(
per_device_train_batch_size=2,
gradient_accumulation_steps=4,
warmup_steps=5,
max_steps=60,
learning_rate=2e-4,
fp16=not torch.cuda.is_bf16_supported(),
bf16=torch.cuda.is_bf16_supported(),
logging_steps=1,
optim=”adamw_8bit”,
weight_decay=0.01,
lr_scheduler_type=”linear”,
seed=3407,
output_dir=”outputs”,
report_to=”none”,
),
)
print(“Trainer configured!”)
print(“Training will be 2x faster with Unsloth!”)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
trainer = SFTTrainer (
model = model ,
tokenizer = tokenizer ,
train_dataset = dataset ,
dataset_text_field = “text” ,
max_seq_length = max_seq_length ,
args = TrainingArguments (
per_device_train_batch_size = 2 ,
gradient_accumulation_steps = 4 ,
warmup_steps = 5 ,
max_steps = 60 ,
learning_rate = 2e – 4 ,
fp16 = not torch . cuda . is_bf16_supported ( ) ,
bf16 = torch . cuda . is_bf16_supported ( ) ,
logging_steps = 1 ,
optim = “adamw_8bit” ,
weight_decay = 0.01 ,
lr_scheduler_type = “linear” ,
seed = 3407 ,
output_dir = “outputs” ,
report_to = “none” ,
) ,
)
print ( “Trainer configured!” )
print ( “Training will be 2x faster with Unsloth!” )
Paso 10: Entrena el modelo más rápido con Unsloth
trainer_stats = trainer.train()
print(“Training complete!”)
print(f”Training time: {trainer_stats.metrics[‘train_runtime’]:.2f} seconds”)
print(f”Samples per second: {trainer_stats.metrics[‘train_samples_per_second’]:.2f}”)
trainer_stats = trainer . train ( )
print ( “Training complete!” )
print ( f “Training time: {trainer_stats.metrics[‘train_runtime’]:.2f} seconds” )
print ( f "Muestras por segundo: {trainer_stats.metrics['train_samples_per_segundo']:.2f}" )
Producción:
Paso 11: guarde el modelo ajustado
Guarde el modelo ajustado en su Google Drive.
print(“Saving model…”)
# Save locally and to Drive
model.save_pretrained(“customer_support_model”)
tokenizer.save_pretrained(“customer_support_model”)
# If using Google Drive (mounted at /content/drive)
model.save_pretrained(“/content/drive/MyDrive/customer_support_model”)
tokenizer.save_pretrained(“/content/drive/MyDrive/customer_support_model”)
print(“Model saved!”)
print(“Local: ./customer_support_model”)
print(“Drive: /content/drive/MyDrive/customer_support_model”)
print ( “Saving model…” )
# Save locally and to Drive
model . save_pretrained ( “customer_support_model” )
tokenizer . save_pretrained ( “customer_support_model” )
# If using Google Drive (mounted at /content/drive)
model . save_pretrained ( “/content/drive/MyDrive/customer_support_model” )
tokenizer . save_pretrained ( “/content/drive/MyDrive/customer_support_model” )
print ( “Model saved!” )
print ( “Local: ./customer_support_model” )
print ( “Drive: /content/drive/MyDrive/customer_support_model” )
Paso 12: Pruebe su modelo perfeccionado
Cargue el modelo guardado y genere respuestas.
model, tokenizer = FastLanguageModel.from_pretrained(
model_name=”customer_support_model”,
max_seq_length=max_seq_length,
dtype=dtype,
load_in_4bit=load_in_4bit,
)
# Enable inference mode
FastLanguageModel.for_inference(model)
def ask_question(question):
“””Generate response to a customer question.”””
if “mistral” in model_name.lower():
prompt = f”[INST] You are a helpful customer support agent. Answer clearly and professionally.nn{question} [/INST]”
elif “llama” in model_name.lower():
prompt = f”””system
You are a helpful customer support agent. Answer clearly and professionally.
user
{question}
assistant”””
else:
prompt = (
“### Instruction:nYou are a helpful customer support agent. “
“Answer clearly and professionally.nn### Input:n”
f”{question}nn### Response:”
)
inputs = tokenizer([prompt], return_tensors=”pt”)
if torch.cuda.is_available():
inputs = {k: v.to(“cuda”) for k, v in inputs.items()}
outputs = model.generate(
**inputs,
max_new_tokens=128,
temperature=0.7,
do_sample=True,
)
response = tokenizer.decode(outputs[0], skip_special_tokens=True) # Extrae solo el texto de respuesta si "[/INST]" en respuesta: respuesta = respuesta.split("[/INST]")[-1].strip() elif "asistente" en respuesta: respuesta = respuesta.split("asistente")[-1].strip() elif "### Respuesta:" en respuesta: respuesta = respuesta.split("### Respuesta:")[-1].strip() devuelve respuesta
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
modelo , tokenizador = Modelo de lenguaje rápido . from_pretrained (
nombre_modelo = "modelo_soporte_cliente" ,
max_seq_length = max_seq_length ,
tipod = tipod ,
cargar_en_4bit = cargar_en_4bit ,
)
# Habilitar el modo de inferencia
Modelo de lenguaje rápido . para_inferencia ( modelo )
def preguntar_pregunta ( pregunta ) :
"" "Generar respuesta a la pregunta de un cliente." ""
si "mistral" en nombre_modelo . más bajo ( ) :
inmediato = f "[INST] Eres un agente de atención al cliente útil. Responde de forma clara y profesional.nn{pregunta} [/INST]"
elif "llama" en nombre_modelo . más bajo ( ) :
inmediato = f "" "sistema
Eres un útil agente de atención al cliente. Responda de forma clara y profesional.
usuario
{pregunta}
asistente" ""
demás :
inmediato = (
"### Instrucción:nEres un útil agente de atención al cliente. "
"Responda clara y profesionalmente.nn### Entrada:n"
f "{pregunta}nn### Respuesta:"
)
entradas = tokenizador ( [ solicitud ] , return_tensors = "pt" )
si antorcha . cuda . está_disponible ( ) :
entradas = { k : v . a ( "cuda" ) para k , v en entradas . elementos ( ) }
salidas = modelo . generar (
* * entradas ,
max_new_tokens = 128 ,
temperatura = 0,7 ,
do_sample = Verdadero ,
)
respuesta = tokenizador . decodificar ( salidas [ 0 ] , skip_special_tokens = Verdadero )
# Extrae solo el texto de la respuesta
si "[/INST]" en respuesta :
respuesta = respuesta . dividir ( "[/INST]" ) [ – 1 ] . banda ( )
elif "asistente" en respuesta :
respuesta = respuesta . dividir ( "asistente" ) [ – 1 ] . banda ( )
elif "### Respuesta:" en respuesta :
respuesta = respuesta . dividir ( "### Respuesta: " ) [ – 1 ] . banda ( )
devolver respuesta
Preguntas de prueba
test_questions = [
“How do I reset my password?”,
“My payment was declined”,
“How do I cancel my subscription?”,
“The app keeps crashing”,
“Where is my order?”,
“Do you offer student discounts?”
]
print(“n” + “=”*60)
print(“CUSTOMER SUPPORT AGENT TEST”)
print(“=”*60)
for i, question in enumerate(test_questions, 1):
print(f”n Customer {i}: {question}”)
answer = ask_question(question)
print(f”Support Agent: {answer}”)
print(“-” * 60)
print(“nTesting complete!”)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
test_questions = [
“How do I reset my password?” ,
“My payment was declined” ,
“How do I cancel my subscription?” ,
“The app keeps crashing” ,
“Where is my order?” ,
“Do you offer student discounts?”
]
print ( “n” + “=” * 60 )
print ( “CUSTOMER SUPPORT AGENT TEST” )
print ( “=” * 60 )
para i , pregunta en enumerar ( test_questions , 1 ) :
print ( f "n Cliente {i}: {pregunta}" )
respuesta = preguntar_pregunta ( pregunta )
print ( f "Agente de soporte: {respuesta}" )
imprimir ( "-" * 60 )
print ( "¡nPrueba completada!" )
Producción:
Paso 13: Comparar con el modelo base
Modelo base de carga
base_model, base_tokenizer = FastLanguageModel.from_pretrained(
model_name=model_name,
max_seq_length=max_seq_length,
dtype=dtype,
load_in_4bit=load_in_4bit,
)
FastLanguageModel.for_inference(base_model)
base_model , base_tokenizer = FastLanguageModel . from_pretrained (
model_name = model_name ,
max_seq_length = max_seq_length ,
dtype = dtype ,
load_in_4bit = load_in_4bit ,
)
FastLanguageModel . for_inference ( base_model )
Prueba la misma pregunta
question = “How do I reset my password?”
question = “How do I reset my password?”
Respuesta del modelo base
if “mistral” in model_name.lower():
base_prompt = f”[INST] {question} [/INST]”
else:
base_prompt = f”### Instruction:nAnswer the question.nn### Input:n{question}nn### Response:”
base_inputs = base_tokenizer([base_prompt], return_tensors=”pt”)
if torch.cuda.is_available():
base_inputs = {k: v.to(“cuda”) for k, v in base_inputs.items()}
base_outputs = base_model.generate(**base_inputs, max_new_tokens=128)
base_response = base_tokenizer.decode(base_outputs[0], skip_special_tokens=Verdadero)
si "mistral" en nombre_modelo . más bajo ( ) :
base_prompt = f "[INST] {pregunta} [/INST]"
demás :
base_prompt = f "### Instrucción:nResponda la pregunta.nn### Entrada:n{pregunta}nn### Respuesta:"
entradas_base = base_tokenizer ( [ base_prompt ] , return_tensors = "pt" )
si antorcha . cuda . está_disponible ( ) :
entradas_base = { k : v . a ( "cuda" ) para k , v en entradas_base . elementos ( ) }
salidas_base = modelo_base . generar ( * * base_inputs , max_new_tokens = 128 )
respuesta_base = token_base . decodificar ( base_outputs [ 0 ] , skip_special_tokens = Verdadero )
Respuesta afinada
ft_response = ask_question(question)
print(f”nQuestion: {question}”)
print(f”nBASE MODEL:n{base_response}”)
print(f”nFINE-TUNED MODEL:n{ft_response}”)
print(“nSee the improvement in response quality!”)
ft_response = ask_question ( question )
print ( f “nQuestion: {question}” )
print ( f “nBASE MODEL:n{base_response}” )
print ( f “nFINE-TUNED MODEL:n{ft_response}” )
print ( “nSee the improvement in response quality!” )
Producción:
Conclusión
En este tutorial, ha aprendido a ajustar los modelos de IA. También has visto que hacer que los modelos aprendan tus tareas específicas no tiene por qué ser complicado ni costoso. La herramienta Unsloth hace que todo sea más fácil: el entrenamiento puede ser hasta cuatro veces más rápido usando mucha menos memoria, por lo que puedes hacerlo incluso en una computadora básica.
El modelo Mistral 7B suele ser una buena opción porque es eficiente y ofrece excelentes resultados. Recuerde siempre que su conjunto de datos enseña el modelo: quinientos ejemplos claros y bien escritos son mejores que miles de ejemplos desordenados. No es necesario reconstruir todo el modelo; Puede ajustar piezas pequeñas con LoRA para obtener los resultados deseados.
Siempre prueba lo que has creado. Verifique tanto con números como leyendo las respuestas usted mismo para asegurarse de que su asistente sea realmente útil y preciso. Este proceso convierte a un modelo general en su experto personal, capaz de atender las preguntas de los clientes, escribir con la voz de su empresa y operar las 24 horas del día.
Recursos