Grandes clústeres para modelos pequeños — Daniel Svonava, Superlinked
AAI Engineer
Computing/SoftwareSmall Business/StartupsInternet Technology
Transcript
00:00:00Revisor: Denise RQ
00:00:12Muy bien.
00:00:14Creo que me escuchan.
00:00:15Yo desde luego me escucho.
00:00:19Quien se acerque más se lleva una camiseta.
00:00:21Lo digo en serio.
00:00:22Hay como una bolsa llena de camisetas por aquí.
00:00:25Y también para las preguntas.
00:00:26Quizás haya algunas preguntas al final.
00:00:28Si haces una pregunta, también te llevarás la camiseta.
00:00:31Y si adivinas qué hay en el fondo de esta diapositiva,
00:00:35también te llevas la camiseta.
00:00:39¿Alguna suposición?
00:00:42¿Qué visualiza eso?
00:00:44Esta imagen del fondo.
00:00:49¿Nadie?
00:00:50¿Alguien ha visto un modelo de transformador?
00:00:55Sí, codificación posicional.
00:00:57Muy bien.
00:00:58Se lleva la camiseta, caballero.
00:00:59Muy bien.
00:01:00Así que hoy hablaremos básicamente de los modelos pequeños de código abierto, de lo buenos que son ahora y de cómo plantean desafíos únicos cuando quieres alojar varios de ellos en tu propia nube.
00:01:15Todo de lo que hablaremos es más o menos de código abierto.
00:01:19Hazlo tú mismo.
00:01:20Este es el tipo de cosas en las que puedes, ya sabes, ejecutar un comando y dominar la infraestructura.
00:01:26Así que aquí no hay piezas propietarias del puzle, ya sabes.
00:01:31Pongamos esto en marcha.
00:01:33De acuerdo.
00:01:34Bien.
00:01:35Esto funciona.
00:01:36Bien.
00:01:37Hablemos de modelos pequeños.
00:01:38¿A qué nos referimos con modelos pequeños?
00:01:40Ya sabes, a quien le preguntes, la forma en que lo veo es básicamente en modelos que puedes ejecutar en hardware de NVIDIA de dos o tres generaciones de antigüedad.
00:01:49Todo el modelo cabe en una sola GPU y, por lo tanto, son fáciles de alojar.
00:01:56Esas GPU están disponibles y también son asequibles.
00:02:01Y la mayoría piensa: vale, con los modelos pequeños habrá algún tipo de compromiso en cuanto a la calidad de los resultados.
00:02:10Y espero poder hacer un buen trabajo en esta charla para convencerles de que, en realidad, para tareas específicas, se puede alcanzar un rendimiento de vanguardia o superior y obtener todos los demás beneficios obvios, ¿verdad?
00:02:22Órdenes de magnitud de ahorro de costes y, por supuesto, mejoras potencialmente bastante grandes en la latencia o el rendimiento.
00:02:35Así que este es uno de los gráficos que nos gusta mostrar.
00:02:38Este es el índice de inteligencia de análisis artificial a lo largo del tiempo.
00:02:42Y lo que normalmente no te muestran es que hay un desglose de los modelos de código abierto a tener en cuenta, ¿verdad?
00:02:49Están el GLM 5.2 y demás, esos modelos de código abierto punteros con, digamos, 750 mil millones de parámetros.
00:02:57Pero luego están los modelos pequeños de código abierto que van a la zaga de los grandes y de la vanguardia.
00:03:04Puedes ver que la vanguardia está obteniendo rendimientos decrecientes estos días y los modelos pequeños se están poniendo al día, ¿verdad?
00:03:10Así que ves este tipo de convergencia, saturación en la parte superior y un crecimiento de los modelos pequeños.
00:03:16Y, ya sabes, digamos que el QN 36 de 27B tiene un rendimiento cercano al de GPT 5.1.
00:03:23Así que si tienes un flujo de trabajo, si tienes una canalización que puede ejecutarse con GPT 5.1,
00:03:29ahora puedes trasladarla a un modelo pequeño y obtener todos los beneficios que comentamos.
00:03:35Así que los modelos pequeños ya no están descartados.
00:03:38Ahora bien, también se trata de cómo usas los modelos pequeños, ¿verdad?
00:03:44Así que no puedes simplemente considerar ese QN 36 de 27 mil millones de parámetros como tu modelo totalmente generalizado al que le puedes pedir cualquier cosa.
00:03:53No, necesitas adoptar el enfoque de identificar porciones de tareas de la carga de trabajo del modelo generalizado.
00:04:00Y luego, para cada tarea, averiguar qué modelo de código abierto se adapta mejor.
00:04:05Ejecutas algunas evaluaciones, tal vez algo de adaptación de la que hablaremos.
00:04:08Y así es como alcanzas la calidad adecuada para llevar esto a producción.
00:04:15Aquí tienes un ejemplo de un agente de revisión de contratos que utiliza nueve modelos diferentes.
00:04:20Esta es la forma que verás en tus cargas de trabajo y tus agentes a medida que pases a usar modelos pequeños para tu configuración.
00:04:28Empezarás a notar que, en lugar de bombardear una API con un montón de solicitudes diferentes o un solo modelo,
00:04:36preferirás usar una flota de modelos.
00:04:38Y entonces tu problema es: ¿cómo alojo todas estas cosas diferentes sin que el personal de infraestructura se vuelva loco, verdad?
00:04:45Y este es solo uno de los agentes que podrías estar ejecutando.
00:04:48Y puede haber 10 de estos en tu empresa.
00:04:51Así que, ¿cómo abordamos esa ampliación del alcance de la infraestructura, por así decirlo?
00:04:57Ahora bien, para todas esas tareas diferentes que mencioné, hay un modelo de código abierto esperando a ser utilizado.
00:05:05Desde reconocimiento óptico de caracteres (OCR) hasta responder preguntas sobre documentos, etiquetar imágenes, generar SQL o revisar código.
00:05:14Hay modelos de código abierto ajustados y entrenados para esas tareas.
00:05:19Ya sabes, si usas un modelo de código abierto entrenado para hacer OCR en recibos en vietnamita, ese proyecto ha visto la mayor cantidad de recibos en vietnamita, ¿verdad?
00:05:28Hay alguien que se tomó el tiempo de recopilar la mayor cantidad de datos posible.
00:05:32Y en esa tarea, ese modelo superará prácticamente a cualquier otro.
00:05:35Y hay cientos de miles de modelos en Hugging Face que son así, ¿verdad?
00:05:41Así que todo está ahí y es gratis, básicamente, con licencias bastante permisivas.
00:05:46Los modelos existen, ese no es el cuelloella de botella.
00:05:50Y hemos estado hablando de la IA de código abierto desde 2024.
00:05:56Y hasta ahora sigue sin suceder realmente.
00:05:59Y en la medida en que ocurre en las empresas, básicamente equivale a la IA de código abierto de AWS Bedrock.
00:06:05Excepto que, al mirar el catálogo de modelos en Bedrock, está muy limitado en cuanto a los tipos de modelos disponibles.
00:06:14Estos modelos son antiguos, a menudo dos o tres años por detrás del estado del arte.
00:06:19Y cuando haces cualquier tipo de ajuste en Bedrock, en realidad no eres dueño de los artefactos ajustados o entrenados.
00:06:25Así que no puedes usarlo como una ventaja real en tu negocio.
00:06:29Sigue alojándose desde la infraestructura de Bedrock.
00:06:32En cuanto a lo propietario, si alojas modelos pequeños en infraestructura de código abierto (VLLM, SGLang u otras soluciones),
00:06:41ten en cuenta que estas herramientas no están optimizadas para ningún modelo o combinación de hardware específica.
00:06:48Tendrás que hacer la optimización tú mismo; de esto trata el «hazlo tú mismo».
00:06:51Todas estas herramientas incluyen guías sobre cómo realizar la optimización, el análisis de parámetros, la adaptación a tu tráfico, etc.
00:07:00Este es un proyecto de investigación abierto cada vez que intentas adoptar una de estas herramientas.
00:07:05Así que no es realmente algo que tomas y dices «es un proyecto de ingeniería,
00:07:10y una semana después tengo una infraestructura de servicio de alto rendimiento».
00:07:14No funciona así.
00:07:15Y ese es el problema típico de las herramientas de código abierto, ¿verdad?
00:07:19Es como un exceso de «hazlo tú mismo».
00:07:21Además de no estar preoptimizado para modelos pequeños, las cargas de trabajo de estos modelos y el tráfico que utiliza varios modelos diferentes
00:07:32le dan la vuelta a la ecuación de los clústeres de inferencia, ¿no?
00:07:37Normalmente, al intentar alojar un modelo grande, tus problemas son: ¿cómo comparto ese modelo entre múltiples GPU?
00:07:44¿Cómo tengo un enrutador en la parte superior que entienda el estado de todos estos trabajadores, el estado de la caché de claves y valores (KVCache), etc.,
00:07:51y luego tome una decisión de enrutamiento de arriba a abajo sobre si esta solicitud va a este trabajador o a este grupo de trabajadores, por ejemplo?
00:07:59Es una configuración muy jerárquica.
00:08:01Pero si tienes solicitudes pequeñas y rápidas, y muchas de ellas, este enrutamiento de arriba a abajo se convierte en el cuello de botella, ¿verdad?
00:08:09Porque el enrutador tiene una versión algo obsoleta del estado del trabajador, y es muy difícil saturar a los trabajadores
00:08:16si tienes esa clase de decisión inicial arriba que tiene que acertar perfectamente al equilibrar las colas locales en cada uno de estos trabajadores.
00:08:26Porque hay muchas solicitudes pequeñas, ¿ves?
00:08:29Y hemos experimentado con los enrutadores VLLM y SGLang para modelos pequeños y este tipo de tráfico,
00:08:37y es muy difícil llevar la utilización de la GPU más allá del 20% o 30% bajo carga constante.
00:08:44El problema es que esos lotes simplemente no están dimensionados correctamente debido a ese cuello de botella en el enrutamiento.
00:08:51Y el tercer problema es que, con los modelos pequeños, te beneficias mucho de LoRA y de la adaptación de modelos en general.
00:08:57Por lo tanto, el tráfico que debes atender contiene personas que se acercan y dicen:
00:09:03«Oye, tengo 10 adaptadores LoRA. ¿Cómo uso esto con nuestra pila de servicio?»
00:09:08O: «Tengo este ajuste personalizado que hice anoche. Quiero ponerlo en producción».
00:09:14Y esta conversación entre el ingeniero de IA y el de infraestructura para subir esos adaptadores LoRA,
00:09:21esos modelos personalizados, es lo que lleva tiempo.
00:09:24Básicamente, el mayor obstáculo para la velocidad organizativa es la comunicación, ¿no?
00:09:30Idealmente, querrías que los ingenieros de infraestructura hicieran su trabajo y que los ingenieros de IA hicieran el suyo.
00:09:37Y que no tengan que hablar en su día a día.
00:09:41De modo que no se bloqueen mutuamente.
00:09:45Y este deseo de adaptación de modelos con modelos pequeños rompe eso y crea muchas idas y venidas.
00:09:51¿Y eso es un problema, verdad?
00:09:54Así que estos son algunos de los desafíos relacionados con, de acuerdo, tenemos un montón de modelos pequeños.
00:09:58¿Cómo armamos un clúster? ¿Cómo servimos esto de manera eficiente?
00:10:02Llevamos un tiempo jugando con este problema.
00:10:05De hecho, soy Daniel, de Superlinked. Me salté un poco la presentación.
00:10:09Somos una empresa respaldada por capital de riesgo de San Francisco.
00:10:13Y hemos estado construyendo sistemas de búsqueda, procesamiento de documentos y agentes impulsados por IA durante los últimos años.
00:10:20Y nuestro principal problema siempre ha sido la inferencia, específicamente estos problemas que he descrito.
00:10:26Así que hemos iterado e iterado y explorado diferentes topologías de clústeres para ejecutar flotas grandes y amplias de modelos pequeños en diferentes entornos.
00:10:37Porque a veces necesitas desplegar junto con alguna plataforma en un entorno donde quién sabe qué hay disponible.
00:10:44Los modelos pequeños lo hacen más fácil porque en cualquier entorno puedes conseguir L4 o alguna cuota de GPU pequeña con mucha más facilidad.
00:10:52Así que esto es un poco... Describiré un poco la topología del clúster a la que hemos convergido.
00:10:58Y por cierto, todo esto es Apache 2.0, completamente de código abierto.
00:11:03Pueden simplemente tomarlo, empaquetarlo y ya son una startup de inferencia.
00:11:08Esto es código abierto desde el plano de control hasta lo que se ejecuta en la GPU.
00:11:14Así que no nos guardamos nada.
00:11:18Y la topología consiste básicamente en que hay una pasarela.
00:11:21Y en lugar de tener un enrutador que decida de antemano qué va a dónde, hay una pasarela que analiza algunas solicitudes y les adjunta metadatos.
00:11:30Inserta esa solicitud en una cola compartida y en algunos canales secundarios.
00:11:36Profundizaré un poco en eso.
00:11:37Y luego los trabajadores extraen de esa cola centralizada en lugar de empujar los datos hacia los trabajadores.
00:11:44Y de esta manera pueden saturarse mejor.
00:11:47Y luego la configuración de los trabajadores —creo que tengo una diapositiva para eso— describirá cómo absorbemos la complejidad de las diferentes arquitecturas de modelos
00:11:57en un conjunto coherente de trabajadores que no tengan requisitos de Python incompatibles y cosas por el estilo.
00:12:03Esa es más o menos la topología general.
00:12:06Y esto es más o menos la vida de una solicitud.
00:12:11Así que tal vez destaque un par de cosas de aquí.
00:12:15Una de las cosas que no nos gusta del estándar de API de OpenAI es el JSON codificado en base64.
00:12:25No es bueno para modelos pequeños, ni para un alto rendimiento.
00:12:28Por eso usamos MessagePack en todo momento, como un formato binario.
00:12:31De esta manera también podemos enviar todos los datos multimodales a través de la pasarela API real.
00:12:37Así que no hay de que los datos binarios vayan por un lado y la solicitud por otro.
00:12:42Y luego el clúster necesita acceso a tu almacenamiento en la nube para empezar a cargar datos binarios, imágenes o vídeos.
00:12:48Lo codificamos todo y lo enviamos a través de la pasarela.
00:12:53Y la pasarela separa algunas de estas piezas más pesadas para no saturar la cola interna y las delega al almacenamiento en la nube en segundo plano mientras la solicitud está en cola.
00:13:02Así que divide algunas de estas solicitudes que superan, digamos, un megabyte y luego usa el almacenamiento en la nube en el backend.
00:13:09Pero como usuario, envías todos tus bits y bytes a la capa de API y, debido a eso, es una interfaz limpia.
00:13:19Básicamente, todo el sistema es REST: la pasarela es REST, el trabajador es REST y luego, a través de un socket, localmente, se conecta a diferentes entornos de ejecución.
00:13:30Y tenemos básicamente a PyTorch, Candle y SGLang como entornos de ejecución.
00:13:35Y cuando hacemos la optimización —profundizaré en eso—, nos aseguramos de que el entorno de ejecución que estemos usando
00:13:43y el código que se ejecuta en él sean lo más eficientes posibles.
00:13:47Para eso tenemos un bucle de auto-investigación, básicamente.
00:13:50Pero sí, la vida de una solicitud se ve más o menos así.
00:13:54Y un detalle importante es que realmente quieres asegurarte de que la pasarela, que es lo primero que recibe la solicitud, no haga demasiado trabajo.
00:14:05Porque entonces se convierte en un cuello de botella, ¿verdad?
00:14:07Así que ni siquiera quieres analizar toda la solicitud.
00:14:09Quieres poder mirar los paquetes y deducir la forma general de lo que viene, hacer la anotación,
00:14:16y luego tienes a los trabajadores —tantos como tengas, cientos de GPUs— observando el estado de la cola y extrayendo de allí.
00:14:25Y la cola utiliza NATS Jetstream, y eso puede procesar, ya sabes, un millón de solicitudes por segundo.
00:14:32Es muy difícil que eso se convierta en un cuello de botella.
00:14:35Así que, idealmente, no quieres serializar y deserializar a medida que pasas por todos estos componentes diferentes.
00:14:42Eso es básicamente lo obvio.
00:14:45Esta es una pequeña animación que muestra la idea detrás de la cola centralizada, ¿verdad?
00:14:51Así que en lugar de que el enrutador de arriba hacia abajo intente rellenar las colas locales a la perfección, lo cual es básicamente imposible,
00:15:01la idea principal es: ¿podemos centralizar de alguna manera el encolamiento y pueden los trabajadores encargarse de armar sus propios lotes
00:15:09con su propia predicción del coste del lote y así volverse mucho más eficientes?
00:15:15Ahora bien, un detalle y nota al margen: una vez que empiezas a trabajar en estas cosas, te das cuenta de que es muy difícil predecir cuántos elementos extraer de la cola compartida para que el lote tenga realmente un tamaño óptimo.
00:15:30Por lo que querrías algún mecanismo que te permita devolver algunas cosas a la cola
00:15:35si descubres que sacaste un poco de más.
00:15:37Y eso es tráfico de red, ¿verdad?
00:15:39Así que eso es un problema.
00:15:40Y tenemos una optimización especial para eso en máquinas que tienen varias GPUs localmente, ¿no?
00:15:46Así que hay un elemento adicional de encolamiento local en la máquina que aprovecha el hecho de que los procesos locales que se ejecutan en las múltiples GPUs de una máquina pueden negociar con la cola de ida y vuelta,
00:15:59lo cual, a través de la red, añadiría milisegundos adicionales.
00:16:03Por eso no lo hacemos a través de la red, sino solo cuando ubicamos conjuntamente a los trabajadores en máquinas con múltiples GPUs.
00:16:11Y no estamos hablando de diferencias del 5% aquí, ¿verdad?
00:16:16Así que centralizas la cola y ahora obtienes el doble de rendimiento en el clúster.
00:16:19Por lo tanto, esto es significativo.
00:16:22Mencioné tres entornos de ejecución diferentes.
00:16:25Básicamente, escribimos el código de PyTorch, por ejemplo, para modelos que son exclusivamente codificadores.
00:16:33Y lo optimizamos, y tenemos un bucle de auto-investigación que lo optimiza.
00:16:38Lo mismo para Candle.
00:16:39Empezamos a experimentar con Candle no hace mucho.
00:16:42Todavía no logramos que su rendimiento se acerque al de PyTorch.
00:16:45Así que es más bien un proyecto de investigación.
00:16:47Es solo la dependencia: la imagen de Docker del trabajador con PyTorch pesa unos 12 gigabytes.
00:16:54Y el binario del trabajador, un binario vinculado estáticamente con Candle, pesa tal vez un 10% de eso, ¿verdad?
00:17:01Y si te importa reactivarte desde un estado frío y cargar estas imágenes en un montón de máquinas diferentes,
00:17:08pasar de 12 gigas a un gigabyte o algo así marca una gran diferencia.
00:17:13Esa es un poco la motivación detrás de Candle.
00:17:15Lo difícil es conseguir el mismo rendimiento que con PyTorch.
00:17:20Y luego tenemos a SG-Lang como una referencia predeterminada.
00:17:25Deberíamos rendir al menos tan bien como SG-Lang con la sintonización óptima de todos esos parámetros que mencioné que hay que ajustar.
00:17:34Aquí hay algunas cifras.
00:17:37Por ejemplo, cuando envolvemos SG-Lang con el socket y con nuestro sidecar en Rust,
00:17:43de hecho podemos mejorar el rendimiento del SG-Lang básico simplemente porque hacemos algo en el procesamiento por lotes que SG-Lang no hace de forma nativa.
00:17:54Y probablemente se pueda hacer para que lo haga.
00:17:57Si desarrollas complementos personalizados en SG-Lang y cosas así,
00:18:00probablemente puedas igualar nuestro rendimiento porque, ya sabes,
00:18:04puedes simplemente integrar la misma lógica en el servidor principal de SG-Lang.
00:18:07Pero ahora estás desarrollando código personalizado que solo funciona con SG-Lang.
00:18:11Y la gran lección aquí con los modelos pequeños es que los entornos de ejecución son súper diversos, ¿verdad?
00:18:16No quieres casarte necesariamente con un entorno de ejecución en particular porque
00:18:22tenemos, creo, alrededor de 50 adaptadores diferentes ahora parametrizados para los distintos modelos.
00:18:28Y de algún modo tienes que lidiar con esta complejidad subyacente.
00:18:32Y probablemente no sea construyendo un montón de complementos para un entorno específico.
00:18:36Probablemente sea algún tipo de abstracción, que en nuestro caso es este concepto de sidecar en Rust y el socket.
00:18:47Ahora hablaré de un par de cifras diferentes, pero en cuanto a la jerga sobre pruebas de rendimiento,
00:18:53el punto de inflexión es este concepto de cuando aumentas el tráfico en el servidor,
00:18:57cuando le pides cada vez más rendimiento,
00:19:01y te da cada vez más rendimiento, es cuando sube de forma lineal.
00:19:05Y luego, en algún momento, llegas a este punto en el que pides más y más y ya no responde.
00:19:09Así que se nivela y la latencia aumenta.
00:19:12A eso lo llamamos el punto de inflexión y es un concepto útil en las pruebas de rendimiento,
00:19:17porque es el punto de saturación, ¿no?
00:19:20Ese es el rendimiento máximo sin perjudicar la latencia.
00:19:23Para darte una idea de lo que es posible en hardware relativamente pequeño, claro.
00:19:32Y diferentes tipos de modelos pequeños.
00:19:34Esto está medido en la RTX Pro 6000.
00:19:37Trabajamos con NVIDIA L4, A100, RTX Pro 6000, H100, más o menos ese rango.
00:19:46Repito, esas GPUs son mucho más fáciles de conseguir bajo demanda en casi cualquier nube.
00:19:52La mayoría de los continentes tienen cuota, ya sabes.
00:19:56Y con este tipo de cosas puedes conseguir, para modelos de incrustación,
00:20:01incluso hasta cientos de millones de parámetros,
00:20:05puedes codificar cientos de miles de tokens por segundo en los embeddings, ¿verdad?
00:20:12Así que imagínate que estás sentado ahí usando la API de OpenAI para tus embeddings de texto.
00:20:17En su lugar, podrías tener una GPU y procesar medio millón de tokens por segundo para obtener los vectores.
00:20:26¿Verdad?
00:20:28O sea, ¿tiene sentido esto?
00:20:31Tienes medio millón de tokens que envías por segundo a una sola GPU que ni siquiera es tan grande,
00:20:38mientras obtienes embeddings vectoriales para tu sistema de búsqueda, en lugar de enviar todo eso a un endpoint gestionado y pagar muchísimo más dinero.
00:20:49¿No?
00:20:50Y puedes conseguir latencias de unas pocas decenas de milisegundos para estas llamadas, ¿sabes?
00:20:55Si usas las APIs de Cohere, OpenAI, etcétera, son cientos de milisegundos, ¿verdad?
00:21:02Y esto no es física cuántica.
00:21:03Ya sabes, puedes conseguir un ahorro de costes masivo, mejoras de latencia enormes y una operación relativamente sencilla con un puñado de GPUs y algo de infraestructura alrededor, ¿verdad?
00:21:17Así que esto es fruta al alcance de la mano; si vas a empezar con modelos de código abierto y pequeños, los embeddings son obvios, ¿verdad?
00:21:26Pero la cosa no acaba ahí.
00:21:27Digamos que quieres mirar el reconocimiento de entidades nombradas.
00:21:33Quieres ver, digamos, la búsqueda multivectorial, e incluso la generación de texto o salidas estructuradas, etc.
00:21:42Puedes obtener miles de tokens por segundo de salida de modelos generativos específicos para tareas, o digamos unos quinientos por segundo para una sola GPU ahí abajo.
00:21:58Así que digamos que estás generando datos sintéticos o anotaciones para tu ajuste fino o tus evaluaciones, no lo hagas en un endpoint gestionado.
00:22:11Es una tarea perfecta porque la tienes bajo control.
00:22:14Puedes supervisar la calidad.
00:22:16Es una tarea perfecta para un modelo de código abierto en tu propia infraestructura.
00:22:20Y luego, si la infraestructura que tienes alrededor de esas GPUs es razonable, obtendrás un escalado lineal con el número de esas GPUs.
00:22:31Ahora bien, otra idea si te dedicas al servicio de modelos pequeños, es que normalmente no tienes un grupo de trabajadores por modelo, ¿verdad?
00:22:44Tienes un conjunto de trabajadores, de nodos, tienen GPUs, los pones en marcha y precargas los modelos.
00:22:51Los modelos tardan decenas de minutos en cargarse porque tienen cientos de miles de millones de parámetros.
00:22:55Y te alegras, vale, por fin se han cargado, ahora tengo un grupo de trabajadores.
00:22:59Esta mentalidad no funciona muy bien con los modelos pequeños.
00:23:02Sí, sí, rápido.
00:23:04¿Cuánto, cuánto tiempo queda?
00:23:06Se han pasado seis minutos.
00:23:07Ah, ¿seis minutos pasados?
00:23:08De acuerdo.
00:23:09Muy bien.
00:23:10Así que empaquetar modelos en la misma GPU es más rápido.
00:23:12Esta es la historia de cómo aún quieres fijar algunos modelos, pero también quieres hacer carga diferida y desalojo en función de la presión de memoria.
00:23:26Quieres averiguar cómo combinar ambas cosas.
00:23:28Hay un poco sobre la auto-investigación.
00:23:32Tenemos bucles de auto-investigación para añadir soporte a nuevos modelos y mejorar su rendimiento.
00:23:39Construimos muchas herramientas internas para hacer las mediciones que alimentan esos bucles y así mejorar los resultados.
00:23:47Y quizás lo más importante, cuando lanzamos soporte para un modelo, ya viene totalmente optimizado, ¿verdad?
00:23:53Así que no hay de que hacer un barrido de parámetros.
00:23:55Básicamente empaquetamos una configuración integral para todo el clúster.
00:24:00Esta es la configuración para el bucle de auto-investigación.
00:24:03Hay un metametric bucle que construye la infraestructura que luego ejecuta el bucle.
00:24:08Y hay un panel de control encima que te ayuda a entender cómo funciona.
00:24:12Tenemos interfaces personalizadas para eso.
00:24:15Y uno de los resultados fue un LoRA que costó 80 centavos entrenar y que mejoró la calidad de recuperación en textos jurídicos alemanes como prueba de concepto en un 18%.
00:24:27Y eso es todo.
00:24:29Así que los modelos pequeños son buenos.
00:24:30Son relativamente fáciles de alojar.
00:24:32Son mucho más baratos y rápidos.
00:24:35Son inteligentes.
00:24:36Y ese código QR lleva al repositorio de GitHub de nuestro clúster que acabo de describir.
00:24:43Danos una estrella.
00:24:44Y feliz autoalojamiento.
00:24:45Gracias.
00:24:46Gracias.
00:24:47Gracias.
Community Posts
No posts yet. Be the first to write about this video!
Write about this video