Conoce la estructura Foundation Models

Hola, soy Erik. Y yo soy Yifei. Y hoy tenemos el privilegio de presentar la nueva estructura Foundation Models. La estructura Foundation Models te da acceso al modelo de lenguaje de gran tamaño en el dispositivo que impulsa Apple Intelligence, con una API Swift cómoda y potente. Está disponible en macOS, iOS, iPadOS y visionOS. Puedes utilizarla para mejorar funcionalidades existentes en tus apps, como ofrecer sugerencias de búsqueda personalizadas. O bien puedes crear funcionalidades completamente nuevas, como generar itinerarios en una app de viajes, todo en el dispositivo. Incluso puedes usarla para crear diálogos sobre la marcha para los personajes de un juego.

Se optimizó para generar contenidos, resumir textos, analizar las entradas de los usuarios y mucho más. Todo esto se ejecuta en el dispositivo, por lo que todos los datos que entran y salen del modelo permanecen privados. Eso también significa que puede funcionar sin conexión. Además, está integrada en el sistema operativo, por lo que no aumentará el tamaño de la app. Es un gran año, así que para ayudarte a aprovechar al máximo la estructura Foundation Models, preparamos una serie de videos. En este primer video, te daremos una descripción general de alto nivel de la estructura en su totalidad. Comenzaremos por los detalles del modelo. A continuación, presentaremos la generación guiada, que permite obtener output estructurado en Swift, y las potentes API de streaming, que convierten la latencia en deleite. También hablaremos de la llamada de herramientas, que permite al modelo ejecutar de forma autónoma el código que definas en tu app. Por último, explicaremos cómo proporcionamos soporte de varios turnos con sesiones con control de estado y cómo integramos perfectamente la estructura en el ecosistema de desarrolladores de Apple. La parte más importante de la estructura, por supuesto, es el modelo que la impulsa. La mejor manera de empezar a crear el modelo es entrar en Xcode. Una parte importante de la creación de modelos de lenguaje de gran tamaño consiste en probar una variedad de prompts para encontrar el que mejor funciona, y la nueva funcionalidad Playgrounds de Xcode es la mejor manera de hacerlo. Con unas pocas líneas de código, puedes empezar inmediatamente a crear el modelo en el dispositivo. Aquí le pediré que genere un título para un viaje a Japón, y el output del modelo aparecerá en el lienzo de la derecha. Ahora, quiero ver si este prompt funciona bien también para otro destino. En un #Playground, puedes acceder a los tipos definidos en tu app, así que crearé un bucle for sobre los puntos de referencia que aparecen en la mía. Ahora Xcode me mostrará la respuesta del modelo para todos los puntos de referencia.

El modelo en el dispositivo que acabamos de usar es un modelo de lenguaje de gran tamaño con 3,000 millones de parámetros, cada uno cuantificado a 2 bits. Es varios órdenes de magnitud superior a cualquier otro modelo que forme parte del sistema operativo.

Pero aun así, es importante tener en cuenta que el modelo en el dispositivo es un modelo a escala del dispositivo. Está optimizado para casos de uso como resúmenes, extracciones, clasificaciones y muchos más. No está diseñado para el conocimiento del mundo o el razonamiento avanzado, que son tareas para las que normalmente se utilizan los LLM a escala de servidor.

Los modelos a escala del dispositivo requieren que las tareas se dividan en partes más pequeñas. A medida que trabajes con el modelo, irás intuyendo sus puntos fuertes y débiles.

Para determinados casos de uso común, como el etiquetado de contenidos, también proporcionamos adaptadores especializados que maximizan la capacidad del modelo en dominios específicos.

También seguiremos mejorando nuestros modelos con el tiempo. Más adelante en este video hablaremos de cómo puedes contarnos cómo usas nuestros modelos, lo que nos ayudará a mejorarlos de la forma que más te interese.

Ahora que ya conocemos el modelo, la primera parada de nuestro viaje es la generación guiada. Gracias a la generación guiada es posible crear funcionalidades como las que acabas de ver, y es el alma de la estructura Foundation Models. Veamos un problema común y hablemos de cómo se resuelve con GuidedGeneration. Por defecto, los modelos de lenguaje producen como output un lenguaje natural no estructurado. Es fácil de leer para las personas, pero difícil de trasladar a las vistas de tu app.

Una solución común es indicar al modelo que produzca algo que sea fácil de analizar, como JSON o CSV.

Sin embargo, esto se convierte rápidamente en un juego inútil. Tienes que agregar instrucciones cada vez más específicas sobre lo que se supone que debe y no debe hacer… A menudo eso no funciona bien… Así que terminas escribiendo alteraciones para extraer y corregir el contenido. Esto no es seguro porque el modelo es probabilístico y existe una probabilidad de errores estructurales superior a cero. GuidedGeneration ofrece una solución fundamental a este problema.

Al importar Foundation Models, se obtiene acceso a dos nuevas macros, @Generable y @Guide. Generable te permite describir un tipo del que quieres que el modelo genere una instancia. Además, Guides te permite proporcionar descripciones en lenguaje natural de las propiedades y controlar mediante programación los valores que se pueden generar para esas propiedades.

Una vez que definas un tipo Generable, puedes hacer que el modelo responda a los prompts generando una instancia de tu tipo. Esto es muy potente. Observa cómo nuestro prompt ya no necesita especificar el formato de output. De eso se encarga la estructura.

La parte más importante, por supuesto, es que ahora obtenemos un objeto Swift enriquecido que podemos trasladar fácilmente a una vista atractiva.

Los tipos generables pueden construirse utilizando primitivas, como cadenas, enteros, dobles, flotantes y decimales, y valores booleanos. Los arrays también son generables. Y los tipos Generable también se pueden componer. Generable incluso admite tipos recursivos, que tienen potentes aplicaciones en dominios como las interfaces de usuario generativas. Lo más importante que hay que entender sobre la generación guiada es que garantiza fundamentalmente la corrección estructural mediante una técnica llamada decodificación restringida. Al utilizar GuidedGeneration, los prompts pueden ser más sencillos y centrarse en el comportamiento deseado en lugar del formato. Además, GuidedGeneration tiende a mejorar la precisión del modelo. Y, al mismo tiempo, nos permite realizar optimizaciones que aceleran la inferencia. Todo esto es posible gracias a la integración cuidadosamente coordinada de los sistemas operativos de Apple, las herramientas para desarrolladores y el entrenamiento de nuestros modelos fundacionales. Todavía hay mucho más que cubrir sobre la generación guiada, como la creación de esquemas dinámicos en tiempo de ejecución, así que echa un vistazo a nuestro video de análisis profundo para obtener más detalles. De este modo concluye GuidedGeneration: vimos cómo el potente sistema de tipos de Swift aumenta los prompts en lenguaje natural para permitir un output estructurado fiable. Nuestro siguiente tema es el streaming, y todo se basa en la macro @Generable que ya conoces. Si trabajaste con modelos de lenguaje de gran tamaño, es posible que sepas que generan texto como grupos breves de caracteres llamados tokens. Por lo general, cuando se hace streaming de output, los tokens se entregan en lo que se llama un delta, pero la estructura Foundation Models en realidad adopta un enfoque diferente, y quiero mostrarte por qué.

A medida que se producen deltas, la responsabilidad de acumularlos suele recaer en el desarrollador. Agregas cada delta a medida que llegan. Y la respuesta crece a medida que lo haces. Pero la cosa se complica cuando el resultado tiene estructura. Si quieres mostrar la cadena de saludo después de cada delta, tienes que analizarla a partir de la acumulación, y eso no es trivial, especialmente para estructuras complicadas. El streaming delta no es la fórmula adecuada cuando se trabaja con output estructurado. Y como ya sabes, el output estructurado es el núcleo de la estructura Foundation Models, por lo que desarrollamos un enfoque diferente. En lugar de deltas sin procesar, transmitimos instantáneas.

A medida que el modelo produce deltas, la estructura los transforma en instantáneas. Las instantáneas representan respuestas generadas parcialmente. Las propiedades son todas opcionales. Se van rellenando a medida que el modelo produce más respuestas. Las instantáneas son una representación práctica y eficaz del streaming de output estructurado.

Ya conoces la macro @Generable, y resulta que también es de donde salen las definiciones de los tipos parcialmente generados. Si expandes la macro, descubrirás que produce un tipo llamado PartiallyGenerated. Se trata de un espejo de la estructura exterior, con la diferencia de que todas las propiedades son opcionales.

El tipo parcialmente generado entra en juego cuando invocas el método streamResponse en tu sesión.

streamResponse genera una secuencia asíncrona. Los elementos de esa secuencia son instancias de un tipo parcialmente generado. Cada elemento de la secuencia contendrá una instantánea actualizada.

Estas instantáneas funcionan muy bien con estructuras declarativas como SwiftUI. En primer lugar, crea un estado que contenga un tipo parcialmente generado. A continuación, solo tienes que iterar sobre un stream de respuesta, almacenar sus elementos y ver cómo la interfaz de usuario cobra vida.

Para terminar, repasemos algunas de las prácticas recomendadas para el streaming.

Primero, sé creativo con las animaciones y transiciones de SwiftUI para ocultar la latencia. Tienes la oportunidad de convertir un momento de espera en uno de deleite. Segundo, tendrás que considerar cuidadosamente la identidad de las vistas en SwiftUI, especialmente cuando generes arrays. Por último, ten en cuenta que las propiedades se generan en el orden en que se declaran en tu estructura de Swift. Esto es importante tanto para las animaciones como para la calidad del output del modelo. Por ejemplo, es posible que descubras que el modelo produce los mejores resúmenes cuando son la última propiedad de la estructura.

Hay mucho que analizar aquí, por lo que asegúrate de ver nuestro video sobre la integración de Foundation Models en apps con SwiftUI para obtener más detalles. Con esto concluimos el streaming con Foundation Models. A continuación, Yifei te contará todo sobre la llamada de herramientas. ¡Gracias, Erik! La llamada de herramientas es otra de nuestras funcionalidades clave. Permite que el modelo ejecute el código que definas en tu app. Esta funcionalidad es especialmente importante para aprovechar al máximo nuestro modelo, ya que la llamada de herramientas dota al modelo de muchas capacidades adicionales. Permite al modelo identificar que una tarea puede requerir información o acciones adicionales y tomar decisiones de forma autónoma sobre qué herramienta utilizar y cuándo, siempre que sea difícil decidirlo programáticamente. La información que proporcionas al modelo puede ser conocimiento del mundo, acontecimientos recientes o datos personales. Por ejemplo, en nuestra app de viajes, proporciona información sobre varios lugares desde MapKit. Esto también permite al modelo citar fuentes de información veraz, lo que elimina las alucinaciones y permite comprobar el output del modelo. Por último, permite que el modelo realice acciones reales, ya sea en la app, en el sistema o en el mundo real. Integrar varias fuentes de información en la app es una estrategia eficaz para crear experiencias atractivas. Ahora que ya sabes por qué la llamada de herramientas es muy útil, veamos cómo funciona. A la izquierda tenemos una transcripción que refleja todo lo que ha sucedido hasta ahora. Si proporcionaste herramientas a la sesión, esta las presentará al modelo junto con las instrucciones. A continuación viene el prompt, donde le indicamos al modelo qué destino queremos visitar. Ahora bien, si el modelo considera que la llamada de una herramienta puede mejorar la respuesta, producirá una o varias llamadas de herramientas. En este ejemplo, el modelo produce dos llamadas de herramientas: consulta de restaurantes y hoteles. En esta fase, la estructura Foundation Models llamará automáticamente al código que escribiste para estas herramientas. A continuación, la estructura inserta automáticamente el output de la herramienta en la transcripción. Por último, el modelo incorporará el output de la herramienta junto con todo lo demás de la transcripción para proporcionar la respuesta final.

Ahora que ya tenemos una idea general de la llamada de herramientas, definamos una herramienta.

Aquí estamos definiendo una simple herramienta meteorológica, que se ajusta al protocolo Tool. La herramienta meteorológica se convirtió de hecho en el primer programa a crear de las llamadas de herramientas, y es una buena manera de empezar.

El protocolo requiere en primer lugar que se especifique un nombre y una descripción en lenguaje natural de la herramienta.

La estructura los proporcionará automáticamente al modelo para ayudarlo a comprender cuándo debe llamar a la herramienta.

Cuando el modelo llame a tu herramienta, ejecutará el método de llamada que definas.

El argumento del método de llamada puede ser de cualquier tipo Generable.

La razón por la que tus argumentos deben ser generables es porque la llamada de herramientas se basa en la generación guiada para garantizar que el modelo nunca producirá nombres de herramientas o argumentos no válidos. Después de definir el tipo de argumentos, ya puedes escribir lo que quieras en el cuerpo de tu método. Aquí estamos usando CoreLocation y WeatherKit para encontrar la temperatura de una ciudad determinada. El output se representa utilizando el tipo ToolOutput, que puede crearse a partir de GeneratedContent para representar datos estructurados. O a partir de una cadena si el output de la herramienta es lenguaje natural. Ahora que definimos una herramienta, debemos asegurarnos de que el modelo tenga acceso. Para ello, introduce la herramienta en el inicializador de sesión. Las herramientas deben adjuntarse en la inicialización de la sesión y estarán disponibles para el modelo durante toda la duración de la sesión.

Después de crear una sesión con herramientas, solo tienes que crear el modelo como lo harías normalmente. Las llamadas de herramientas se producirán de forma transparente y autónoma, y el modelo incorporará los outputs de las herramientas a su respuesta final. Los ejemplos que acabo de mostrar ilustran cómo definir herramientas de tipo seguro durante la compilación, lo que es ideal para la gran mayoría de los casos de uso. Las herramientas también pueden ser dinámicas en todos los sentidos. Por ejemplo, puedes definir los argumentos y comportamientos de una herramienta en tiempo de ejecución utilizando esquemas de generación dinámicos. Si tienes curiosidad al respecto, no dudes en echar un vistazo a nuestro video de análisis profundo para obtener más información. Concluimos la llamada de herramientas. Aprendimos por qué es útil llamar a las herramientas y cómo aplicarlas para ampliar las capacidades del modelo. A continuación, hablemos de las sesiones con control de estado. Ya viste muchas veces la palabra sesión en este video. La estructura Foundation Models se basa en la noción de sesión con control de estado. Por defecto, cuando se crea una sesión, se solicita el modelo de propósito general en el dispositivo. Y puede proporcionar instrucciones personalizadas. Las instrucciones son una oportunidad para indicarle al modelo cuál es su papel y orientarlo sobre cómo debe responder. Por ejemplo, puedes especificar cosas como el estilo y la verbosidad. Recuerda que proporcionar instrucciones personalizadas es opcional, y que se utilizarán instrucciones predeterminadas razonables si no especificas ninguna.

Si decides proporcionar instrucciones personalizadas, es importante que entiendas la diferencia entre instrucciones y prompts. Las instrucciones deben venir de ti, el desarrollador, mientras que los prompts pueden venir del usuario. Esto se debe a que el modelo está entrenado para obedecer instrucciones en lugar de prompts. Esto ayuda a proteger contra ataques de inyección de prompt, pero no es una solución infalible. Por regla general, las instrucciones son en su mayoría estáticas, y es mejor no interpolar en ellas entradas de usuario que no sean de confianza. Este es un repaso básico sobre cómo formular las instrucciones y los prompts de la mejor manera posible. Para descubrir aún más prácticas recomendadas, consulta nuestro video sobre diseño y seguridad de los prompts. Ahora que ya inicializaste una sesión, vamos a hablar de las interacciones de varios turnos. Al usar los métodos respond o streamResponse de los que hablamos antes, cada interacción con el modelo se conserva como contexto en una transcripción, de modo que el modelo podrá referirse a interacciones pasadas de varios turnos y comprenderlas dentro de una misma sesión. Por ejemplo, aquí el modelo es capaz de entender cuando decimos “haz otro”, que nos estamos refiriendo a escribir un haiku.

Y la propiedad transcript del objeto de sesión te permitirá inspeccionar interacciones anteriores o dibujar vistas de interfaz de usuario para representarlas.

Una cosa más importante a saber es que mientras el modelo está produciendo output, la propiedad isResponding se convertirá en true. Es posible que tengas que observar esta propiedad y asegurarte de no enviar otro prompt hasta que el modelo termine de responder. Más allá del modelo por defecto, también ofrecemos casos de uso especializados incorporados adicionales que están respaldados por adaptadores. Si encuentras un caso de uso incorporado que se ajuste a tus necesidades, puedes pasarlo al inicializador de SystemLanguageModel. Para saber qué casos de uso incorporados están disponibles y cómo aprovecharlos mejor, consulta nuestra documentación en el sitio web para desarrolladores. Un adaptador especializado del que quiero hablar más hoy es el adaptador de etiquetado de contenidos. El adaptador de etiquetado de contenidos ofrece soportes de primera clase para la generación de etiquetas, la extracción de entidades y la detección de temas. Por defecto, el adaptador está preparado para emitir etiquetas de temas y se integra con la generación guiada desde el primer momento. Por lo tanto, puedes simplemente definir una estructura con nuestra macro Generable, y pasar el input del usuario para extraer temas de ella.

Pero aún hay más. Al proporcionarle instrucciones personalizadas y un tipo de output Generable personalizado, incluso puedes usarlo para detectar cosas como acciones y emociones. Antes de crear una sesión, también debes comprobar la disponibilidad, ya que el modelo solo puede ejecutarse en dispositivos compatibles con Apple Intelligence en las regiones admitidas. Para comprobar si el modelo está disponible actualmente, puedes acceder a la propiedad availability de SystemLanguageModel.

La disponibilidad es un enum de dos casos que está disponible o no disponible. Si no está disponible, también recibirás un motivo para que puedas ajustar tu interfaz en consecuencia.

Por último, es posible que se produzcan errores al llamar al modelo. Estos errores pueden incluir una infracción de las normas de seguridad, idioma no admitido o ventana de contexto superada. Para ofrecer la mejor experiencia de usuario, debes abordarlos adecuadamente, y obtendrás más información en el video de análisis profundo. Es todo para las sesiones con control de estado de varios turnos. Aprendimos a crear una sesión y a utilizarla, así como la forma en que nuestro modelo realiza un seguimiento de tu contexto. Ahora que ya conoces todas las funcionalidades interesantes de la estructura, hablemos de las herramientas y la experiencia del desarrollador. Para empezar, puedes abrir cualquier archivo Swift de tu proyecto y usar la nueva macro playground para crear el modelo.

Los playgrounds son potentes porque te permiten iterar rápidamente sobre tus prompt sin tener que volver a compilar y ejecutar toda la app. En un playground, tu código puede acceder a todos los tipos de tu proyecto, como los tipos generables que ya están potenciando tu interfaz de usuario.

A continuación, sabemos que cuando se trata de crear experiencias de app basadas en modelos de lenguaje de gran tamaño, es importante comprender toda la latencia que hay detrás, ya que los modelos de lenguaje de gran tamaño tardan más en ejecutarse que los modelos de aprendizaje automático tradicionales. Entender dónde se produce la latencia puede ayudarte a ajustar la verbosidad de tus prompts, o a determinar cuándo llamar a API útiles, como el precalentamiento.

Y nuestra nueva plantilla de perfiles de app de Instruments se creó exactamente para eso. Puedes perfilar la latencia de una solicitud de modelo, observar las áreas de optimización y cuantificar las mejoras.

Ahora, mientras desarrollas tu app, puedes tener comentarios que nos ayuden a mejorar nuestros modelos y nuestras API.

Te animamos a que nos envíes tus comentarios a través de Feedback Assistant. Incluso proporcionamos una estructura de datos codificable para adjuntar comentarios que puedes adjuntar como archivo a tus comentarios.

Por último, si eres un profesional de aprendizaje automático con un caso de uso muy especializado y un conjunto de datos personalizado, también puedes entrenar tus adaptadores personalizados utilizando nuestro kit de herramientas de entrenamiento de adaptadores. Pero ten en cuenta que esto conlleva importantes responsabilidades, ya que tienes que volver a entrenarlo a medida que Apple mejora el modelo con el tiempo. Para más información, visita el sitio web para desarrolladores. Ahora que ya conoces muchas de las funcionalidades de la nueva estructura Foundation Models, no podemos esperar a ver todas las cosas increíbles que vas a construir con ella. Para descubrir aún más sobre cómo integrar la IA generativa en tu app, cómo funcionan tecnologías como la generación guiada y cómo crear los mejores prompts, tenemos toda una serie de videos y artículos maravillosos para ti. Muchas gracias por acompañarnos hoy. ¡Feliz generación!