Inicio rápido del decodificador

Esta guía rápida usa un bucle de entrenamiento personalizado para entrenar modelos Nemotron o Qwen mientras tu aplicación controla el muestreo, las recompensas y las actualizaciones del modelo. Para ajustar un codificador GLiNER con entrenamiento gestionado, consulta el inicio rápido del codificador.

1. Autentícate

Crea una cuenta de Fastino.
Abre Claves de API.
Crea una clave y cópiala cuando se muestre.

Guarda la clave en una variable de entorno:

export FASTINO_API_KEY="fast_sk_..."

$env:FASTINO_API_KEY = "fast_sk_..."

Envía esta clave como X-API-Key: $FASTINO_API_KEY. Consulta Autenticación para ver el contrato de autenticación completo. Elige una interfaz compatible:

Los clientes JSON nativos llaman a POST /v1/training/jobs/create-model, encolan operaciones del modelo bajo /v1/training/jobs/{job_id} y consultan cada future_id devuelto hasta que esté completed, failed o cancelled.
Los programas Tinker existentes mantienen tinker==0.32.0; consulta Migrar desde Tinker para configurar el SDK.

Los clientes nativos no envían seq_id ni latidos. El servidor asigna el orden de las operaciones y mantiene activa la sesión interna. Una solicitud con wait=true espera como máximo 25 segundos. Por tanto, el cliente debe seguir consultando una operación no terminal. Después de este inicio rápido, consulta Construye un bucle de entrenamiento personalizado para añadir recompensas, rollouts repetidos y recuperación. El ejemplo REST nativo requiere Python 3.11 o posterior. Para configurar el SDK de Tinker, consulta Migrar desde Tinker.

2. Instala las bibliotecas cliente

Necesitas Python 3.11 o posterior. transformers aporta el tokenizador del modelo; el entrenamiento se ejecuta en Fastino.

uv init fastino-training
cd fastino-training
uv add requests transformers

mkdir fastino-training && cd fastino-training
python -m venv .venv
source .venv/bin/activate
pip install requests transformers

mkdir fastino-training
cd fastino-training
py -m venv .venv
.\.venv\Scripts\Activate.ps1
pip install requests transformers

3. Elige un modelo

ID del modelo	Longitud de contexto (tokens)
`nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-BF16`	65,536
`nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16`	32,768
`Qwen/Qwen3.6-35B-A3B`	32,768

Se admiten rangos LoRA de 1 a 32; el valor por defecto es 32.

export FASTINO_TRAINING_MODEL="nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16"

$env:FASTINO_TRAINING_MODEL = "nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16"

4. Crea el trabajo

curl -X POST "https://api.fastino.ai/v1/training/jobs/create-model" \
  -H "X-API-Key: $FASTINO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"base_model": "nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16", "lora_config": {"rank": 32}}'

La respuesta contiene un job_id y el future_id del future create del trabajo:

{
  "job_id": "SESSION_ID:train:0",
  "type": "interactive",
  "base_model": "nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16",
  "future_id": "FUTURE_ID",
  "load_future_id": null
}

Cada llamada que hace trabajo devuelve un future. Léelo hasta que status sea completed. Con wait=true, la solicitud espera hasta 25 segundos:

curl "https://api.fastino.ai/v1/training/jobs/$TRAINING_JOB_ID/futures/$FUTURE_ID?wait=true" \
  -H "X-API-Key: $FASTINO_API_KEY"

5. Entrena, guarda y muestrea

El script siguiente ejecuta el bucle completo: crea un trabajo, ejecuta tres pasadas forward-backward y pasos del optimizador, guarda un checkpoint sampler, muestrea desde él y detiene el trabajo. Crea quickstart.py:

import os

import requests
from transformers import AutoTokenizer

API = "https://api.fastino.ai"
MODEL = os.environ["FASTINO_TRAINING_MODEL"]

session = requests.Session()
session.headers["X-API-Key"] = os.environ["FASTINO_API_KEY"]


def call(method, path, body=None):
    response = session.request(method, API + path, json=body, timeout=60)
    response.raise_for_status()
    return response.json() if response.content else None


def wait(job_id, future_id):
    path = f"/v1/training/jobs/{job_id}/futures/{future_id}?wait=true"
    while True:
        future = call("GET", path)
        if future["status"] == "completed":
            return future["result"]
        if future["status"] in ("failed", "cancelled"):
            raise RuntimeError(future["error"])


def datum(prompt_tokens, completion_tokens):
    tokens = prompt_tokens + completion_tokens
    weights = [0.0] * (len(prompt_tokens) - 1) + [1.0] * len(completion_tokens)
    return {
        "model_input": {"chunks": [{"type": "encoded_text", "tokens": tokens[:-1]}]},
        "loss_fn_inputs": {
            "target_tokens": {"data": tokens[1:], "dtype": "int64"},
            "weights": {"data": weights, "dtype": "float32"},
        },
    }


tokenizer = AutoTokenizer.from_pretrained(MODEL)
prompt = tokenizer.apply_chat_template(
    [{"role": "user", "content": "What is the capital of France?"}],
    add_generation_prompt=True,
    enable_thinking=False,
    return_dict=False,
)
completion = tokenizer.encode("Paris.", add_special_tokens=False)
completion.append(tokenizer.eos_token_id)
batch = {"datums": [datum(prompt, completion)], "loss_fn": "cross_entropy"}

created = call(
    "POST",
    "/v1/training/jobs/create-model",
    {"base_model": MODEL, "lora_config": {"rank": 32}},
)
job_id = created["job_id"]
jobs = f"/v1/training/jobs/{job_id}"
print(f"TRAINING_JOB_ID={job_id}")

try:
    wait(job_id, created["future_id"])

    for step in range(3):
        backward = call("POST", f"{jobs}/forward-backward", batch)
        result = wait(job_id, backward["future_id"])
        update = call(
            "POST",
            f"{jobs}/optim-step",
            {"adam_params": {"learning_rate": 1e-4}},
        )
        wait(job_id, update["future_id"])
        print(f"step {step}: loss {result['metrics']['loss:sum']:.4f}")

    saved = call(
        "POST",
        f"{jobs}/save-weights-for-sampler",
        {"name": "quickstart", "ttl_seconds": 24 * 60 * 60},
    )
    wait(job_id, saved["future_id"])

    sample = call(
        "POST",
        f"{jobs}/sample",
        {
            "checkpoint": "quickstart",
            "prompt_tokens": prompt,
            "sampling_params": {"max_tokens": 32},
        },
    )
    sequence = wait(job_id, sample["future_id"])["sequences"][0]
    print(tokenizer.decode(sequence["tokens"]))
finally:
    call("POST", f"{jobs}/stop")

El script espera a que forward-backward termine correctamente antes de enviar el paso del optimizador. Si un future falla o se cancela, wait genera un error y no se envía la operación dependiente. enable_thinking=False cierra el bloque de razonamiento del modelo antes de que empiece la respuesta supervisada. Es un argumento de la plantilla del tokenizer, no un campo de solicitud de la API de entrenamiento. Ejecuta el script:

python quickstart.py

Copia el valor que aparece después de TRAINING_JOB_ID=.

Un trabajo interactivo sin llamadas durante 30 minutos se libera. Sus checkpoints se conservan. Detenerlo responde de inmediato e impide llamadas nuevas, pero las operaciones ya encoladas pueden terminar antes de que se liberen los recursos. El uso puede continuar hasta esa liberación. Aún puedes muestrear y descargar sus checkpoints sampler.

6. Verifica el trabajo canónico

export TRAINING_JOB_ID="<ID printed by quickstart.py>"
curl --fail-with-body \
  -H "X-API-Key: $FASTINO_API_KEY" \
  "https://api.fastino.ai/v1/training/jobs/$TRAINING_JOB_ID"

$env:TRAINING_JOB_ID = "<ID printed by quickstart.py>"
Invoke-RestMethod `
  -Headers @{ "X-API-Key" = "$env:FASTINO_API_KEY" } `
  -Uri "https://api.fastino.ai/v1/training/jobs/$env:TRAINING_JOB_ID"

La respuesta describe el mismo trabajo creado mediante el endpoint REST nativo. Usa las páginas públicas de operaciones interactivas para las operaciones del modelo y la API canónica de trabajos para las lecturas documentadas.

Continúa

Inicio rápido del codificador

Ajusta un codificador GLiNER con entrenamiento gestionado.

Referencia de trabajos interactivos

Revisa cada solicitud y respuesta de los trabajos interactivos.

Bucle de entrenamiento

Añade recompensas, actualizaciones y recuperación a un bucle personalizado.

Empezar

Modelos de decisión

Entidades y clasificación

API de entrenamiento

API de inferencia

Solución de problemas

Integraciones SDK

Modelos

Cuenta

Inicio rápido del decodificador

1. Autentícate

2. Instala las bibliotecas cliente

3. Elige un modelo

4. Crea el trabajo

5. Entrena, guarda y muestrea

6. Verifica el trabajo canónico

Continúa

Inicio rápido del codificador

Referencia de trabajos interactivos

Bucle de entrenamiento

​1. Autentícate

​2. Instala las bibliotecas cliente

​3. Elige un modelo

​4. Crea el trabajo

​5. Entrena, guarda y muestrea

​6. Verifica el trabajo canónico

​Continúa

Inicio rápido del codificador

Referencia de trabajos interactivos

Bucle de entrenamiento

1. Autentícate

2. Instala las bibliotecas cliente

3. Elige un modelo

4. Crea el trabajo

5. Entrena, guarda y muestrea

6. Verifica el trabajo canónico

Continúa