Una guía de codificación paso a paso para ajustar eficientemente QWEN3-14B usando AI no eterno en Google Colab con conjuntos de datos mixtos y optimización de Lora

Los LLM de ajuste fino a menudo requieren recursos extensos, tiempo y memoria, desafíos que pueden obstaculizar la rápida experimentación y la implementación. AI nocturno Revoluciona este proceso al permitir modelos rápidos y eficientes de vanguardia de última generación como QWEN3-14B con memoria de GPU mínima, aprovechando técnicas avanzadas como cuantización de 4 bits y Lora (adaptación de bajo rango). En este tutorial, atravesamos una implementación práctica en Google Colab para ajustar QWEN3-14B utilizando una combinación de razonamiento y conjuntos de datos con instrucciones, combinando las utilidades de FastLanguageModel de FastLanguageModel con TRL.Sfttrainer pueden lograr un poderoso rendimiento de ajuste con solo hardware de origen de consumo.

%%capture
import os
if "COLAB_" not in "".join(os.environ.keys()):
    !pip install unsloth
else:
    !pip install --no-deps bitsandbytes accelerate xformers==0.0.29.post3 peft trl==0.15.2 triton cut_cross_entropy unsloth_zoo
    !pip install sentencepiece protobuf "datasets>=3.4.1" huggingface_hub hf_transfer
    !pip install --no-deps unsloth

Instalamos todas las bibliotecas esenciales necesarias para ajustar el modelo QWEN3 utilizando AI no placentera. Instala condicionalmente dependencias en función del entorno, utilizando un enfoque ligero de Colab para garantizar la compatibilidad y reducir la sobrecarga. Se incluyen componentes clave como Bitsandbytes, TRL, Xformers y Unsloth_zoo para habilitar el entrenamiento cuantificado de 4 bits y la optimización basada en Lora.

from unsloth import FastLanguageModel
import torch


model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "unsloth/Qwen3-14B",
    max_seq_length = 2048,
    load_in_4bit = True,
    load_in_8bit = False,
    full_finetuning = False,
)

Cargamos el modelo QWEN3-14B usando FastLanguageModel desde la biblioteca no respaldada, que está optimizado para un ajuste fino eficiente. Inicializa el modelo con una longitud de contexto de 2048 tokens y lo carga en precisión de 4 bits, lo que reduce significativamente el uso de la memoria. El ajuste completo está deshabilitado, lo que lo hace adecuado para técnicas de eficiencia de parámetros livianos como Lora.

model = FastLanguageModel.get_peft_model(
    model,
    r = 32,
    target_modules = ["q_proj", "k_proj", "v_proj", "o_proj",
                      "gate_proj", "up_proj", "down_proj"],
    lora_alpha = 32,
    lora_dropout = 0,
    bias = "none",
    use_gradient_checkpointing = "unsloth",
    random_state = 3407,
    use_rslora = False,
    loftq_config = None,
)

Aplicamos Lora (adaptación de bajo rango) al modelo QWEN3 usando FastLanguageModel.get_peft_model. Inyecta adaptadores capacitables en capas de transformador específicas (como Q_Proj, V_Proj, etc.) con un rango de 32, lo que permite un ajuste eficiente al tiempo que mantiene la mayoría de los pesos del modelo congelado. Usando el punto de control de gradiente “no superiores”, optimiza aún más el uso de la memoria, lo que lo hace adecuado para capacitar a modelos grandes en hardware limitado.

from datasets import load_dataset


reasoning_dataset = load_dataset("unsloth/OpenMathReasoning-mini", split="cot")
non_reasoning_dataset = load_dataset("mlabonne/FineTome-100k", split="train")

Cargamos dos conjuntos de datos precurados desde el concentrador facial de abrazos utilizando la biblioteca. El razonamiento_dataSet contiene problemas de cadena de pensamiento (cot) de OpenMathRasoning-Mini de Unsloth, diseñado para mejorar el razonamiento lógico en el modelo. El Non_Rasoning_DataSet extrae datos generales de seguimiento de instrucciones del Finetome-100k de Mlabonne, que ayuda al modelo a aprender habilidades más amplias conversacionales y orientadas a las tareas. Juntos, estos conjuntos de datos admiten un objetivo de ajuste fino bien redondeado.

def generate_conversation(examples):
    problems  = examples["problem"]
    solutions = examples["generated_solution"]
    conversations = []
    for problem, solution in zip(problems, solutions):
        conversations.append([
            {"role": "user", "content": problem},
            {"role": "assistant", "content": solution},
        ])
    return {"conversations": conversations}

Esta función, Generate_Conversation, transforma los pares de preguntas en bruto-respuesta del conjunto de datos de razonamiento en un formato de estilo de chat adecuado para ajustar. Para cada problema y su solución generada correspondiente, se realiza una conversación en la que el usuario hace una pregunta y el asistente proporciona la respuesta. La salida es una lista de diccionarios que siguen la estructura esperada por los modelos de lenguaje basados ​​en chat, preparando los datos para la tokenización con una plantilla de chat.

reasoning_conversations = tokenizer.apply_chat_template(
    reasoning_dataset["conversations"],
    tokenize=False,
)


from unsloth.chat_templates import standardize_sharegpt
dataset = standardize_sharegpt(non_reasoning_dataset)


non_reasoning_conversations = tokenizer.apply_chat_template(
    dataset["conversations"],
    tokenize=False,
)


import pandas as pd


chat_percentage = 0.75
non_reasoning_subset = pd.Series(non_reasoning_conversations).sample(
    int(len(reasoning_conversations) * (1.0 - chat_percentage)),
    random_state=2407,
)


data = pd.concat([
    pd.Series(reasoning_conversations),
    pd.Series(non_reasoning_subset)
])
data.name = "text"

Preparamos el conjunto de datos de ajuste fino al convertir los conjuntos de datos de razonamiento e instrucciones en un formato de chat consistente y luego combinándolos. Primero aplica el tokenizer Apply_chat_template para convertir conversaciones estructuradas en cadenas tokenizables. La función Standardize_Sharegpt normaliza el conjunto de datos de instrucciones en una estructura compatible. Luego, se crea una mezcla 75-25 muestreando el 25% de las conversaciones no de condensación (instrucción) y combinándolas con los datos de razonamiento. Esta combinación asegura que el modelo esté expuesto al razonamiento lógico y tareas generales de seguimiento de instrucciones, mejorando su versatilidad durante la capacitación. Los datos combinados finales se almacenan como una serie Pandas de una sola columna llamada “Texto”.

from datasets import Dataset


combined_dataset = Dataset.from_pandas(pd.DataFrame(data))
combined_dataset = combined_dataset.shuffle(seed=3407)


from trl import SFTTrainer, SFTConfig


trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=combined_dataset,
    eval_dataset=None,  
    args=SFTConfig(
        dataset_text_field="text",
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,
        warmup_steps=5,
        max_steps=30,
        learning_rate=2e-4,
        logging_steps=1,
        optim="adamw_8bit",
        weight_decay=0.01,
        lr_scheduler_type="linear",
        seed=3407,
        report_to="none",
    )
)

Tomamos las conversaciones preprocesadas, las envolvemos en un conjunto de datos facial de abrazos (asegurando que los datos estén en un formato consistente) y baraja el conjunto de datos con una semilla fija para la reproducibilidad. Luego, el entrenador de ajuste fino se inicializa utilizando SFTTrainer y SftConfig de TRL. El entrenador está configurado para usar el conjunto de datos combinado (con el campo de columna de texto llamado “texto”) y define hiperparámetros de entrenamiento como tamaño de lote, acumulación de gradiente, número de pasos de calentamiento y entrenamiento, tasa de aprendizaje, parámetros de optimizador y un programador de tasas de aprendizaje lineal. Esta configuración está orientada a un ajuste fino eficiente mientras se mantiene la reproducibilidad y el registro de detalles mínimos (con Report_TO = “Ninguno”).

Trainer.train () comienza el proceso de ajuste fino para el modelo QWEN3-14B utilizando el SFTTrainer. Entrena el modelo en el conjunto de datos mixtos preparado de razonamiento y conversaciones de seguimiento de instrucciones, optimizando solo los parámetros adaptados a Lora gracias a la configuración no capacitada subyacente. La capacitación procederá de acuerdo con la configuración especificada anteriormente (por ejemplo, max_steps = 30, batch_size = 2, lr = 2e-4), y el progreso se imprimirá en cada paso de registro. Este comando final inicia la adaptación del modelo real en función de sus datos personalizados.

model.save_pretrained("qwen3-finetuned-colab")
tokenizer.save_pretrained("qwen3-finetuned-colab")

Guardamos el modelo y el tokenizador ajustados localmente al directorio “QWEN3-Finetuned-Colab”. Al llamar a Save_PreTrained (), los pesos adaptados y la configuración del tokenizer se pueden recargar más tarde para inferencia o entrenamiento adicional, localmente o para cargarlo al concentrador de cara.

En conclusión, con la ayuda de AI insignia, el ajuste de LLM masivo como QWEN3-14B se vuelve factible, utilizando recursos limitados y es altamente eficiente y accesible. Este tutorial demostró cómo cargar una versión cuantificada de 4 bits del modelo, aplicar plantillas de chat estructuradas, mezclar múltiples conjuntos de datos para una mejor generalización y entrenar utilizando SFTTrainer de TRL. Ya sea que esté construyendo asistentes personalizados o modelos de dominio especializados, las herramientas de falta de falta reducen drásticamente la barrera para ajustar a escala. A medida que evolucionan los ecosistemas de ajuste de código abierto, Soctah continúa liderando el camino para hacer que el entrenamiento de LLM sea más rápido, más barato y más práctico para todos.

Mira el Cuaderno de colab. Todo el crédito por esta investigación va a los investigadores de este proyecto. Además, siéntete libre de seguirnos Gorjeo Y no olvides unirte a nuestro 95k+ ml de subreddit y suscribirse a Nuestro boletín.