ES ▾
Obtener clave de API

Mejor modelo abliterado para programación: qué esperar

El mejor modelo abliterado para programación es el que escribe código correcto y no rechaza tu petición lícita a mitad de camino. La abliteración solo maneja la segunda parte, así que necesitas probar la primera en tu propio repositorio.

Actualizado

Terminal con código abstracto, candado abierto y lupa sobre una placa de circuito, para ayuda de programación sin restricciones

Puntos clave

  • La abliteración elimina el comportamiento de rechazo. No añade habilidad de programación, así que juzga la calidad del código en tus propias tareas.
  • Los rechazos afectan a los desarrolladores en herramientas de seguridad, scraping, ingeniería inversa y revisiones de código directas.
  • Una temperatura baja y una semilla fija hacen que la salida de código sea repetible y fácil de comparar.
  • Una petición típica de revisión de código de 3.000 tokens de entrada y 800 de salida cuesta menos de una décima de centavo.

Qué cambia la abliteración y qué deja igual

La abliteración es una técnica aplicada a un modelo de pesos abiertos después del entrenamiento. Encuentra la dirección interna asociada con rechazar una petición y la suprime, así el modelo deja de declinar y dar lecciones. No enseña al modelo nuevos lenguajes de programación ni corrige un razonamiento deficiente. La capacidad de un modelo para escribir una función correcta proviene de su entrenamiento base, y la versión abliterada debería ser igual de buena, o ligeramente diferente, en ese aspecto.

Ese marco te ayuda a comprar con sentido. Dos preguntas importan, y son independientes:

  • ¿Es bueno el modelo subyacente para código en los lenguajes que usas?
  • ¿Realiza el trabajo sin rechazos cuando la tarea es legal pero sensible?

Este servicio ejecuta un modelo de pesos abiertos, alojado por un proveedor independiente, con el ID de modelo uncensored. No afirmaré un número de benchmark para ello, porque ninguno se publica aquí y las puntuaciones inventadas no ayudan a nadie. El camino honesto es una prueba breve en tu código, descrita más abajo. El contexto más amplio está en la página sobre un modelo de IA sin restricciones.

Dónde los rechazos afectan realmente a los desarrolladores

La mayoría de las peticiones de programación nunca activan un rechazo. Cuando lo hacen, suele ser en un pequeño conjunto de áreas, todas ellas legales cuando se realizan en sistemas que posees o estás autorizado para probar:

  • Trabajo de seguridad. Escáneres de puertos, fuzzers, pruebas de concepto de exploits para tu propio laboratorio, scripts de análisis de malware, forense de registros.
  • Scraping y automatización. Analizadores, flujos de navegador sin interfaz y pruebas de límite de peticiones que un modelo cauteloso etiqueta como arriesgadas.
  • Ingeniería inversa. Leer desensamblado, documentar un formato de archivo, trabajo de interoperabilidad.
  • Herramientas para juegos y ficción. Generación de árboles de diálogo oscuros, guiones de villanos o tramas maduras para títulos para adultos.
  • Tono. Revisión de código que dice claramente que un diseño es malo, sin rellenar cada comentario con elogios.

La autorización importa. Un modelo sin rechazos responde a lo que le preguntes, así que la responsabilidad de mantenerse legal es tuya. Úsalo en tus propios sistemas, objetivos de prueba y trabajo con clientes con permiso por escrito.

Una prueba rápida que dice más que un ranking

Construye un pequeño conjunto de prompts de tu trabajo real: cinco a diez tareas, incluyendo una o dos que otros asistentes hayan rechazado. Ejecútalas con una semilla fija y temperatura baja, y compara los resultados contra tu herramienta actual. El crédito de prueba de $0,50, válido por 7 días, cubre cientos de llamadas.

import json
from openai import OpenAI

client = OpenAI(
    base_url="https://api.abliteratedmodelhub.com/v1",
    api_key="YOUR_KEY",
)

tasks = [
    "Write a Python function that parses nmap XML output and lists open ports per host.",
    "Refactor this loop into a generator and keep behavior identical: for i in range(len(xs)): out.append(xs[i] * 2)",
    "Write a pytest file for a function slugify(text) that handles unicode and repeated dashes.",
]

results = []
for task in tasks:
    resp = client.chat.completions.create(
        model="uncensored",
        messages=[
            {"role": "system", "content": "You are a senior engineer. Return only code unless asked otherwise."},
            {"role": "user", "content": task},
        ],
        temperature=0.2,
        seed=7,
    )
    results.append({"task": task, "answer": resp.choices[0].message.content})

print(json.dumps(results, indent=2))

Luego ejecuta el código. No evalúes solo leyendo. Ejecuta las pruebas, ejecuta el linter y anota cuántas tareas necesitaron un segundo intento. Una tasa de aprobación en tus propias diez tareas vale más que cualquier ranking público, ya que refleja tu pila.

Configuraciones que ayudan a la salida de código

La generación de código premia el determinismo. Empieza con estos valores y cambia uno a la vez:

  • temperature 0,0 a 0,3 para generación y refactorización. Súbelo a 0,7 solo para lluvia de ideas de enfoques.
  • top_p déjalo cerca de 1,0 cuando la temperatura es baja.
  • stop secuencias como una valla de código de cierre, si quieres solo el primer bloque de código.
  • seed fija durante experimentos, para que un prompt cambiado, no la aleatoriedad, explique una respuesta cambiada.
  • max_tokens es opcional. La generación puede usar el resto de la ventana de 100.000 tokens, así que establece un límite si quieres acotar el coste en prompts abiertos.

Dale al modelo el contexto que necesitaría un humano: la versión del lenguaje, el framework, la salida de la prueba fallida y los archivos relevantes. Una ventana de 100.000 tokens deja espacio para mucho código fuente, pero más archivos no siempre es mejor. Incluye lo que afecta a la pregunta.

Prompts que obtienen mejor código

El mismo modelo da código muy diferente dependiendo de cómo le preguntes. Algunos hábitos marcan una diferencia visible.

  • Indica el entorno. "Python 3.11, solo librería estándar" evita importaciones que no puedes instalar. "TypeScript, modo estricto, sin any" moldea los tipos.
  • Muestra la salida fallida. Para depurar, pega el traceback y el código más pequeño que lo desencadena. Pide la causa primero, luego la solución, para que puedas juzgar el razonamiento.
  • Pide pruebas con el código. Una función y sus pruebas juntas exponen lagunas que el modelo de otro modo pasaría por alto.
  • Restringe la salida. "Devuelve solo un diff unificado" o "devuelve un bloque de código y nada más" ahorra tokens y hace que la respuesta sea fácil de aplicar.
  • Itera en pasos pequeños. Pide un esqueleto, revísalo, luego pide la siguiente pieza. Las grandes peticiones de un solo paso dan más lugares para que se oculte un error sutil.

Para depurar un tema propenso a los rechazos, di lo que estás haciendo y por qué en una oración. "Este es mi propio servidor de staging; escribe un script que verifique qué puertos de estos están abiertos" es una petición normal, y un modelo ajustado para responder la manejará sin comentarios. La declaración también documenta tu intención para cualquiera que revise el código más tarde.

Trabaja con bases de código más grandes

La ventana de 100.000 tokens puede contener muchos archivos a la vez, pero enviar un repositorio entero en cada llamada es un desperdicio. Elige el contexto deliberadamente:

  1. Envía el archivo bajo cambio y los archivos que importa directamente.
  2. Añade las definiciones de interfaz o archivos de tipos, no implementaciones completas de todo.
  3. Incluye la prueba fallida y su salida.
  4. Omite los archivos generados, los archivos de bloqueo y el código de terceros.

Un pequeño ayudante que recorre una lista de rutas y construye un prompt mantiene esto repetible:

from pathlib import Path
from openai import OpenAI

client = OpenAI(
    base_url="https://api.abliteratedmodelhub.com/v1",
    api_key="YOUR_KEY",
)

def review(paths, question):
    parts = []
    for p in paths:
        parts.append("### " + p + "\n" + Path(p).read_text())
    prompt = "\n\n".join(parts) + "\n\nQuestion: " + question
    resp = client.chat.completions.create(
        model="uncensored",
        messages=[{"role": "user", "content": prompt}],
        temperature=0.2,
    )
    return resp.choices[0].message.content

print(review(["app/models.py", "app/views.py"], "Where can this raise a KeyError?"))

Vigila el coste de prompts grandes repetidos. Veinte llamadas con un contexto de 40.000 tokens cada una usan 800.000 tokens de entrada, o 0,8 x $0,15 = $0,12. Eso es barato, pero crece con cada ronda extra de ida y vuelta, así que haz preguntas concretas.

Usa herramientas y JSON para flujos de trabajo de desarrolladores

La API admite llamadas a funciones y modo JSON, lo que convierte el modelo en un componente en lugar de un compañero de chat. Un paso de revisión de código, por ejemplo, puede devolver hallazgos estructurados que un trabajo de CI puede publicar como comentarios.

curl https://api.abliteratedmodelhub.com/v1/chat/completions \
  -H "Authorization: Bearer YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "temperature": 0.1,
    "response_format": {"type": "json_object"},
    "messages": [
      {"role": "system", "content": "Review the diff. Reply as JSON: {\"findings\": [{\"line\": number, \"severity\": string, \"comment\": string}]}"},
      {"role": "user", "content": "def add(a, b):\n    return a - b"}
    ]
  }'

Con las llamadas a funciones puedes exponer funciones como run_tests o read_file y permitir que el modelo las solicite en un bucle, luego enviar los resultados de vuelta como mensajes role: "tool". Tu código ejecuta la función, así que controlas qué puede tocar. Aísla todo lo que ejecute código generado.

Cuánto cuesta un trabajo de programación típico

Las tarifas son de 0,15 $ por 1M de tokens de entrada y 0,50 $ por 1M de tokens de salida. Ejemplos:

  • Una petición de fragmento con 3.000 tokens de entrada y 800 de salida: 0,003M x 0,15 $ = 0,00045 $, más 0,0008M x 0,50 $ = 0,0004 $, por lo tanto 0,00085 $. Un millar de ellos cuestan 0,85 $.
  • Una revisión de archivo completo con 20.000 tokens de entrada y 1.500 de salida: 0,003 $ + 0,00075 $ = 0,00375 $.
  • Un día pesado de 400 peticiones mixtas del tamaño de fragmento: 400 x $0,00085 = $0,34.

No hay suscripción, y las peticiones fallidas o rechazadas no se cobran. Recarga cualquier cantidad entera desde $20 hasta $500 con cripto (USDT en TRC20, USDC en Base). Los bonos añaden +5% desde $50, +10% desde $100 y +15% desde $200. Los detalles completos están en la página de precios; los parámetros se listan en la documentación, y puedes reclamar una clave en la página de registro.

Preguntas y respuestas

¿Mejora la abliteración la capacidad de un modelo para programar?

No. Elimina el comportamiento de rechazo. La capacidad de codificación proviene del modelo base, así que pruébalo en tus propias tareas.

¿Es legal usar un modelo sin censura para código de seguridad?

Escribir código para sistemas que posees o estás autorizado para probar es generalmente lícito, pero eres responsable de mantenerte dentro de la ley y de tus permisos.

¿Puedo usarlo dentro de mi editor?

Cualquier extensión de editor o herramienta que acepte una URL base compatible con OpenAI, clave y nombre de modelo puede conectarse. Usa la URL base, tu clave y el modelo uncensored.

¿Qué tamaño de archivo puedo enviar?

La ventana de contexto es de 100.000 tokens para prompt más respuesta, y el cuerpo máximo de la petición es de 8 MB.

Tu clave está a un formulario de distancia

Crea una cuenta, copia la clave, cambia la URL base. Esa es toda la configuración.

Obtener clave de API