Clasificar texto con la API de decisiones

La API de decisiones es una API web experimental que le permite clasificar texto, haciendo preguntas sobre el texto y obteniendo respuestas estructuradas, a partir del código JavaScript de su sitio web o extensión del navegador. La API usa un modelo integrado en Microsoft Edge que se ejecuta en el dispositivo.

Contenido detallado:

Introducción

Use la API de decisiones para tomar decisiones rápidamente sobre texto no estructurado, como:

  • Descripción de la intención del usuario:

    • ¿Significa esta búsqueda que el usuario quiere comprar algo?
    • ¿Qué característica está intentando encontrar el usuario?
  • Ordenar y enrutar contenido:

    • ¿Qué equipo debe controlar esta solicitud?
    • ¿De qué tema trata este artículo?
    • ¿Es este mensaje una pregunta, una queja o un comentario?
  • Puntuación y clasificación:

    • ¿Qué relevancia tiene este resultado para la búsqueda del usuario?
    • ¿Qué tan urgente es este mensaje?
    • ¿Qué tan positiva es esta revisión?
  • Comprobación de la calidad del contenido:

    • ¿Este informe de errores incluye pasos para reproducir el error?
    • ¿Esta reseña es sobre el producto o la entrega del producto?
    • ¿Faltan detalles clave en esta entrada del formulario?

A diferencia de los modelos de lenguaje que generan texto, la API de decisiones puntúa las respuestas que proporciona y devuelve la respuesta más probable junto con la probabilidad de cada respuesta y un valor de confianza. El resultado siempre coincide con la estructura de las preguntas que ha definido.

Para obtener información introductoria sobre la API de Decisiones, consulte Explicación de la API de Decisiones.

Disponibilidad de la API de decisiones

La API de decisiones está disponible como versión preliminar para desarrolladores en Microsoft Edge Canary mediante la configuración de una marca.

La API de decisiones está optimizada para tomar decisiones estructuradas sobre el texto, con un conjunto predefinido de posibles respuestas. Para obtener más información sobre las alternativas para escenarios de ingeniería de mensajes más personalizados a los que esta API podría no atender, consulte Prompt a built-in language model with the Prompt API.

El diseño de la API de decisiones aún está evolucionando y la API puede cambiar antes de su lanzamiento.

Alternativas y ventajas de la API de decisiones

Para aprovechar las capacidades de IA en sitios web y extensiones de explorador, también puede usar los métodos siguientes:

La API de Decisions usa un modelo que se ejecuta localmente, en el mismo dispositivo donde se usan las entradas y salidas del modelo. Esto tiene las siguientes ventajas en comparación con las soluciones basadas en la nube:

  • Costo reducido: No hay ningún costo asociado al uso de un servicio de inteligencia artificial en la nube.

  • Independencia de la red: Más allá de la descarga inicial del modelo, no hay latencia de red al tomar decisiones y la API también se puede usar cuando el dispositivo está sin conexión.

  • Privacidad mejorada: Los datos que se introducen en el modelo nunca abandonan el dispositivo y no se recopilan (por ejemplo, para entrenar modelos de inteligencia artificial).

La API de decisiones usa un modelo proporcionado por Microsoft Edge e integrado en el explorador, lo que ofrece ventajas adicionales sobre las soluciones locales personalizadas, como las basadas en WebGPU, WebNN o WebAssembly:

  • Costo pago único compartido: El modelo proporcionado por el explorador se descarga cuando se usa la API por primera vez y, a continuación, el modelo se comparte en todos los sitios web que se ejecutan en el explorador, lo que reduce los costos de red para desarrolladores y usuarios.

  • Uso simplificado para desarrolladores web: El modelo integrado se puede ejecutar mediante una API web directa y no requiere conocimientos de IA/ML ni el uso de marcos de terceros.

En comparación con el uso de Prompt API para clasificar texto, la API de Decisions tiene las siguientes ventajas:

  • Tipo de seguridad: El modelo puntúa las respuestas que proporciona, en lugar de generar texto. El modelo no puede devolver una etiqueta que no haya definido y no es necesario analizar el resultado.

  • Probabilidades y confianza: El resultado incluye la probabilidad de cada respuesta posible y un valor de confianza, para que el código pueda actuar automáticamente cuando el modelo tenga confianza y preguntar al usuario cuando no lo esté.

  • Velocidad: El modelo responde a todas las preguntas sobre una entrada en un solo paso, en lugar de generar texto token por token.

Modelo de API de decisiones

La API de Decisiones utiliza el modelo de lenguaje pequeño Aion Instruct. Para obtener más información sobre Aion Instruct y los requisitos de hardware, consulte El modelo de instrucción de Aion en Prompt, un modelo de lenguaje integrado con la API Prompt.

Aviso de declinación de responsabilidades

Al igual que otros modelos de aprendizaje automático, el modelo que usa la API de decisiones puede producir resultados inexactos, injustos o poco confiables. El valor de confianza refleja la certeza del modelo, pero no es una garantía de que la respuesta sea correcta.

No confíe solo en el modelo para tomar decisiones de altas consecuencias o para realizar acciones que cambien el estado. Pida al usuario que confirme estas acciones, independientemente del valor de confianza.

Disponibilidad de modelos

Se requiere una descarga inicial del modelo la primera vez que un sitio web llama a una API de IA integrada. Para supervisar la descarga del modelo, use la monitor opción al crear una nueva sesión de la API de decisiones. Consulte Supervisar el progreso de la descarga del modelo, a continuación.

Debido a la naturaleza experimental de la API de Decisions, es posible que observe problemas en configuraciones de hardware específicas. Si observa algún problema, infórmelo en el repositorio.

Habilitar la API de decisiones

Para usar la API de decisiones en Microsoft Edge:

  1. Asegúrese de que usa la versión más reciente de Microsoft Edge Canary. Consulta Conviértete en un participante de Microsoft Edge Insider.

  2. En Microsoft Edge Canary, abra una pestaña o ventana nueva y, a continuación, vaya a edge://flags.

  3. En el cuadro de búsqueda, en la parte superior de la página, escriba Decisions API.

    La página se filtra para mostrar la bandera coincidente.

  4. Seleccione Habilitado junto al indicador de API de decisiones .

  5. Reinicie Microsoft Edge Canary.

    La página edge://flags que muestra el marcador de API de decisiones habilitado.

Vea un ejemplo práctico

Para ver la API de Decisions en acción y revisar el código existente que usa la API:

  1. Habilite la API de decisiones, como se describe anteriormente.

  2. En Microsoft Edge Canary, abra una nueva pestaña o ventana y, a continuación, vaya al área de juegos de la API de decisiones.

  3. En el banner de información en la parte superior, compruebe el estado. Si el modelo aún no se ha descargado, el banner indica que el modelo se descargará la primera vez que se use la API.

    Si el modelo no inicia la descarga, reinicia Microsoft Edge y vuelve a intentarlo.

  4. Opcionalmente, puede cambiar el contenido de los cuadros de texto Texto para clasificar, Contexto o Preguntas (JSON).

  5. Haz clic en el botón Decidir , en la parte inferior de la página.

    Para cada pregunta, la salida muestra la respuesta, con la probabilidad de cada opción. Para ver el objeto resultante completo, expanda JSON sin formato.

    La respuesta

    • Se rellenan los cuadros de texto de entrada Texto para clasificar, Contexto y Preguntas .
    • El botón Decidir está resaltado.
    • La sección de salida (a la derecha) muestra los resultados, incluidos los datos JSON sin procesar que devuelve la API.

Vea también:

  • /built-in-ai/ - Léame y código fuente para la demostración de áreas de juego de IA integrada.

Usar la API de decisiones

Compruebe si la API está habilitada

Antes de usar la API de Decisions en el código de tu sitio web, confirma que la API está habilitada probando la DecisionModel presencia del objeto:

if (!window.DecisionModel) {
  // The Decisions API is not available.
}

Definir las preguntas

Para usar la API de decisiones, primero defina las preguntas que quiere que el modelo responda sobre un fragmento de texto. Cada pregunta es un objeto que tiene las siguientes propiedades:

Propiedad Descripción
id Cadena que identifica la pregunta. El resultado de la API está codificado por pregunta id, por lo que cada una id debe ser única.
prompt Cadena que describe la pregunta que se va a responder.
type El tipo de pregunta: "boolean", "choice"o "score".
options Una matriz de las posibles respuestas. Cada opción es un objeto que tiene una label cadena y una cadena opcional description . Requerido para "choice" preguntas, opcional para "score" preguntas (consulte Preguntas de puntuación) y no utilizado para "boolean" preguntas.

Las options descripciones ayudan al modelo a comprender lo que significa cada opción.

Pase una matriz de preguntas a la API al comprobar la disponibilidad y al crear una sesión, mediante la questions opción del create() método.

Preguntas booleanas

Use una boolean pregunta para comprobar si se cumple una condición. Las posibles respuestas son "true" y "false":

const questions = [
  {
    id: "urgent",
    type: "boolean",
    prompt: "Does this support ticket require urgent escalation?"
  }
];
Preguntas de elección

Usa una choice pregunta para asignar el texto a una de varias categorías. Proporcione las categorías mediante la options propiedad:

const questions = [
  {
    id: "category",
    type: "choice",
    prompt: "Which category best describes the issue?",
    options: [
      { label: "bug", description: "Crash, freeze, or broken functionality" },
      { label: "billing", description: "Duplicate charge, invoice, or payment issue" },
      { label: "feature", description: "Request for new capability" },
      { label: "account", description: "Password reset or login help" }
    ]
  }
];

La API de decisiones funciona mejor con un número limitado de opciones por pregunta. Para administrar un conjunto más grande de categorías, considere la posibilidad de organizarlas en una jerarquía y usar la API de decisiones en varias etapas. Para controlar las entradas que no coinciden con ninguna categoría, incluya una opción general, como "other" o "none".

Puntuar preguntas

Use una score pregunta para calificar el texto según una escala ordenada. Proporcione la escala mediante la options propiedad, ordenada del valor más bajo al más alto. En el ejemplo siguiente se proporciona una escala personalizada:

const questions = [
  {
    id: "severity",
    type: "score",
    prompt: "Rate the customer impact from 1 (minimal) to 5 (critical).",
    options: [
      { label: "1", description: "Minimal impact" },
      { label: "2", description: "Low impact" },
      { label: "3", description: "Moderate impact" },
      { label: "4", description: "High impact" },
      { label: "5", description: "Critical impact" }
    ]
  }
];

Cuando todas las etiquetas de opción son números, la puntuación resultante se calcula a partir de las etiquetas numéricas. De lo contrario, la puntuación resultante se calcula a partir de la posición de las opciones en la escala, comenzando en 1.

Las options descripciones de las propiedades y las opciones son opcionales para score las preguntas. El explorador rellena lo que falta:

  • Si omite options, el navegador crea una escala de 5 puntos, etiquetada "1" a través "5"de , que va desde "muy bajo, fuertemente negativo" ("1"), pasando por "moderado, medio, neutral" ("3"), hasta "muy alto, fuertemente positivo" ("5").

  • Si proporciona options etiquetas numéricas, pero no description valores, el explorador asigna una descripción integrada a cada opción, en función de la posición de la opción en la escala. Las descripciones van desde bajas y negativas hasta altas y positivas. Las escalas que tienen un número impar de opciones obtienen un punto medio neutro. Por ejemplo, para una escala de 7 puntos, las descripciones van desde "muy bajo, fuertemente negativo" para la primera opción, hasta "moderado, medio, neutral" para la cuarta opción, hasta "muy alto, fuertemente positivo" para la última opción. Las descripciones integradas están disponibles para escalas de 2 a 11 opciones.

Para controlar cómo interpreta el modelo cada valor de la escala, proporcione sus propias descripciones.

Comprobar si se puede usar el modelo

La API de decisiones solo se puede usar si el dispositivo admite la ejecución del modelo y después de que Microsoft Edge haya descargado el modelo y el tiempo de ejecución del modelo.

Para comprobar si se puede usar la API, use el DecisionModel.availability() método. Para validar también el esquema de sus preguntas, pase la questions opción:

const availability = await DecisionModel.availability({ questions });

if (availability == "unavailable") {
  // The model is not available.
}

if (availability == "downloadable" || availability == "downloading") {
  // The model can be used, but it needs to be downloaded first.
}

if (availability == "available") {
  // The model is available and can be used.
}

También puede llamar availability() sin argumentos.

Crear una sesión nueva

Al crear una sesión, el explorador carga el modelo en la memoria para que se pueda usar. Antes de que pueda tomar decisiones sobre el texto, cree una nueva sesión mediante el DecisionModel.create() método, usando la questions opción para pasar las preguntas que ha definido:

// Create a DecisionModel session.
const session = await DecisionModel.create({ questions });

El DecisionModel.create() método toma las siguientes opciones:

Opción Descripción
questions Una serie de preguntas que el modelo responde sobre el texto. Consulte Definir las preguntas, arriba.
context Una cadena que contiene instrucciones que se aplican a todas las preguntas. Consulte Proporcionar contexto al modelo a continuación.
monitor Función que se usa para supervisar el progreso de la descarga del modelo. Consulte Supervisar el progreso de la descarga del modelo, a continuación.
signal Y AbortSignal que se usa para cancelar la creación de la sesión o para destruir la sesión una vez creada. Consulte Destruir una sesión con un AbortController a continuación.
Supervisar el progreso de la descarga del modelo

Para seguir el progreso de la descarga del modelo, use la monitor opción del DecisionModel.create() método. Esto es útil cuando el modelo aún no se ha descargado completamente en el dispositivo en el que se utilizará, para informar a los usuarios de su sitio web que deben esperar.

// Create a DecisionModel session with the monitor option to monitor the model
// download.
const session = await DecisionModel.create({
  questions,
  monitor: m => {
    // Use the monitor object argument to add a listener for the
    // downloadprogress event.
    m.addEventListener("downloadprogress", event => {
      // The event is an object with the loaded and total properties.
      if (event.loaded == event.total) {
        // The model is fully downloaded.
      } else {
        // The model is still downloading.
        const percentageComplete = (event.loaded / event.total) * 100;
      }
    });
  }
});
Proporcionar contexto al modelo

Para darle al modelo instrucciones para usar al responder todas las preguntas, use la context opción del DecisionModel.create() método. Esto es útil para explicar la situación en la que se evalúa el texto o para definir qué significan las opciones para su caso de uso:

const session = await DecisionModel.create({
  questions,
  context: "You are triaging incoming browser support tickets. Treat production outages, crashes, and duplicate billing charges as urgent."
});

Ejecutar la API de decisiones

Para tomar decisiones sobre un elemento de texto, después de haber creado la sesión de modelo correspondiente, use el session.decide() método. Este método devuelve una promesa que se resuelve después de que el modelo haya respondido a todas las preguntas sobre el texto.

El modelo responde todas las preguntas en una sola pasada.

// Create a DecisionModel session.
const session = await DecisionModel.create({ questions });

// Make decisions about the text and wait for the result.
const result = await session.decide(
  "Every time I click Pay Now on the checkout page, the tab freezes and I was billed twice on my credit card."
);

// Use the result.
console.log(result);

Para cancelar una llamada de decisión que está en curso, pase un AbortSignal mediante la signal opción del session.decide() método. Cancelar una llamada de decisión no destruye la sesión.

const controller = new AbortController();

const resultPromise = session.decide(ticketText, { signal: controller.signal });

// Later, cancel this decision call only.
controller.abort();

Usar el resultado de la API de decisiones

El session.decide() método devuelve una promesa que se resuelve en un objeto que tiene una propiedad por pregunta. El nombre de cada propiedad es el de la id pregunta. Cada propiedad es un objeto que tiene las siguientes propiedades:

Propiedad Descripción
id El id de la pregunta.
label La label de la opción más probable. Para boolean preguntas, este es "true" o "false".
probabilities Un objeto que contiene la probabilidad de cada opción, entre 0 y 1, tecleada por opción label.
confidence Un número entre 0 y 1 que indica la confianza del modelo en la respuesta. Use este valor para decidir si el código debe actuar sobre la respuesta.
expectedScore Un número que solo está presente para score preguntas. Es el promedio de los puntajes de las opciones, ponderado por la probabilidad de cada opción. Úselo para obtener un valor más preciso que el más probable label.

Por ejemplo, el resultado de las preguntas anteriores podría ser:

{
  "urgent": {
    "id": "urgent",
    "label": "true",
    "confidence": 0.97,
    "probabilities": { "true": 0.97, "false": 0.03 }
  },
  "category": {
    "id": "category",
    "label": "billing",
    "confidence": 0.62,
    "probabilities": { "bug": 0.35, "billing": 0.62, "feature": 0.01, "account": 0.02 }
  },
  "severity": {
    "id": "severity",
    "label": "5",
    "expectedScore": 4.8,
    "confidence": 0.84,
    "probabilities": { "1": 0.0, "2": 0.01, "3": 0.04, "4": 0.11, "5": 0.84 }
  }
}

Los valores anteriores son solo ilustrativos.

El siguiente ejemplo:

  • Usa el resultado para tomar decisiones con confianza.
  • Pregunta al usuario, cuando el modelo no está seguro.
const { urgent, category } = await session.decide(ticketText);

// Act automatically when the model is confident.
if (urgent.label === "true" && urgent.confidence > 0.85) {
  escalateTicket();
}

if (category.confidence > 0.85) {
  setCategory(category.label);
} else {
  // Otherwise, let the user choose, and show the most likely options first.
  showSuggestedCategories(category.probabilities);
}

Destruir una sesión

Para que el explorador sepa que el modelo ya no es necesario y se puede descargar de la memoria, destruya la sesión.

Puede destruir una sesión de cualquiera de las siguientes maneras:

  • Mediante el session.destroy() método.
  • Mediante el uso de un AbortController objeto.

Los detalles están a continuación.

Destruir una sesión mediante el método destroy()

Para destruir una DecisionModel sesión, puede usar el session.destroy() método:

const session = await DecisionModel.create({ questions });

// Later, destroy the session by using the destroy method.
session.destroy();
Destruir una sesión con un AbortController

Como alternativa, para destruir una DecisionModel sesión, puede crear un AbortController objeto, crear una DecisionModel sesión y, a continuación, llamar a abort():

// Create an AbortController object.
const controller = new AbortController();

// Create a DecisionModel session and pass the
// AbortController signal object by using the signal option.
const session = await DecisionModel.create({
  questions,
  signal: controller.signal
});

// Later, such as when the user interacts with the UI, destroy the session by
// calling the abort() function of the AbortController object.
controller.abort();

Para cancelar una sola llamada de decisión sin destruir la sesión, use la signal opción del session.decide() método:

const controller = new AbortController();

const resultPromise = session.decide(ticketText, { signal: controller.signal });

// Later, cancel this decision call only.
controller.abort();

Enviar comentarios

Nos interesa obtener información sobre:

  • Escenarios para los que desea usar la API de Decisiones.
  • Si el diseño de la API satisface sus necesidades.
  • Problemas con la API.
  • Problemas con el modelo.

Si observa algún problema al usar la API, notifíquelo en el repositorio.

También puede contribuir a la discusión sobre el diseño de la API de decisiones en el repositorio explicativo de la API de decisiones.

Vea también