En este tutorial, exploramos LitServe, un marco de servicio ligero y potente que nos permite implementar modelos de aprendizaje automático como API con un mínimo esfuerzo. Construimos y probamos múltiples puntos finales que demuestran funcionalidades del mundo real, como generación de texto, procesamiento por lotes, transmisión por secuencias, procesamiento multitarea y almacenamiento en caché, todos ejecutándose localmente sin depender de API externas. Al final, entendemos claramente cómo diseñar canales de servicio de ML escalables y flexibles que sean eficientes y fáciles de extender para aplicaciones de nivel de producción. Consulta los CÓDIGOS COMPLETOS aquí.
Comenzamos configurando nuestro entorno en Google Colab e instalando todas las dependencias necesarias, incluidos LitServe, PyTorch y Transformers. Luego importamos las bibliotecas y módulos esenciales que nos permitirán definir, servir y probar nuestras API de manera eficiente. Consulta los CÓDIGOS COMPLETOS aquí.
def predecir(self, solicitud): resultado = self.model(prompt, max_length=100, num_return_sequences=1, temperatura=0.8, do_sample=True) devuelve resultado[0][‘generated_text’]
def encode_response(self, salida): return {“generated_text”: salida, “model”: “distilgpt2”} clase BatchedSentimentAPI(ls.LitAPI): def setup(self, dispositivo): self.model = pipeline(“sentiment-analysis”, model=”distilbert-base-uncased-finetuned-sst-2-english”, dispositivo=0 si dispositivo == “cuda” y torch.cuda.is_available() else -1) def decode_request(self, request): solicitud de devolución[“text”]
def lote(self, entradas: Lista[str]) -> Lista[str]: devuelve entradas def predict(self, lote: Lista[str]): resultados = self.model(batch) devuelve resultados def unbatch(self, salida): devuelve salida def encode_response(self, salida): return {“etiqueta”: salida[“label”]”puntuación”: float(salida[“score”]), “por lotes”: Verdadero}
Aquí, creamos dos API de LitServe, una para la generación de texto utilizando un modelo DistilGPT2 local y otra para el análisis de sentimientos por lotes. Definimos cómo cada API decodifica las solicitudes entrantes, realiza inferencias y devuelve respuestas estructuradas, lo que demuestra lo fácil que es crear puntos finales de servicio de modelos escalables y reutilizables. Consulta los CÓDIGOS COMPLETOS aquí.
def predecir (yo, aviso): palabras = [“Once”, “upon”, “a”, “time”, “in”, “a”, “digital”, “world”]
para palabra en palabras: time.sleep(0.1) produce palabra + ” ” def encode_response(self, salida): para token en salida: produce {“token”: token}
En esta sección, diseñamos una API de generación de texto en streaming que emite tokens a medida que se generan. Simulamos la transmisión en tiempo real generando palabras una a la vez, demostrando cómo LitServe puede manejar la generación continua de tokens de manera eficiente. Consulta los CÓDIGOS COMPLETOS aquí.
texto = entradas[“text”]
si tarea == “sentimiento”: resultado = self.sentimiento (texto)[0]
return {“tarea”: ”sentimiento”, “resultado”: resultado} elif tarea == “resumir”: si len(text.split()) < 30: return {"tarea": "resumir", "resultado": {"summary_text": texto}} resultado = self.summarizer(texto, max_length=50, min_length=10)[0] return {"tarea": "resumir", "resultado": resultado} else: return {"tarea": "desconocida", "error": "Tarea no admitida"} def encode_response(self, salida): devolver salida
Ahora desarrollamos una API multitarea que maneja tanto el análisis de sentimientos como el resumen a través de un único punto final. Este fragmento demuestra cómo podemos administrar múltiples canalizaciones de modelos a través de una interfaz unificada, enrutando dinámicamente cada solicitud a la canalización adecuada según la tarea especificada. Consulta los CÓDIGOS COMPLETOS aquí.
def predecir(self, texto): si el texto está en self.cache: self.hits += 1 return self.cache[text]Verdadero self.misses += 1 resultado = self.model(texto)[0]
caché propio[text] = resultado devuelve resultado, False def encode_response(self, salida): resultado, from_cache = salida devuelve {“etiqueta”: resultado[“label”]”puntuación”: float(resultado[“score”]), “from_cache”: from_cache, “cache_stats”: {“hits”: self.hits, “misses”: self.misses}}
Implementamos una API que utiliza el almacenamiento en caché para almacenar resultados de inferencias anteriores, lo que reduce el cálculo redundante para solicitudes repetidas. Realizamos un seguimiento de los aciertos y errores de caché en tiempo real, lo que ilustra cómo mecanismos simples de almacenamiento en caché pueden mejorar drásticamente el rendimiento en escenarios de inferencia repetida. Consulta los CÓDIGOS COMPLETOS aquí.
lote_decodificado = [api2.decode_request({“text”: t}) for t in texts]
por lotes = api2.batch(decoded_batch) resultados = api2.predict(por lotes) sin lotes = api2.unbatch(resultados) para i, r en enumerar(sin lotes): codificado = api2.encode_response(r) print(f”✓ ‘{textos[i]}’ -> {codificado[‘label’]} ({codificado[‘score’]:.2f})”) api3 = MultiTaskAPI(); api3.setup(“cpu”) decodificado = api3.decode_request({“task”: “sentiment”, “text”: “¡Increíble tutorial!”}) resultado = api3.predict(decoded) print(f” ✓ Sentimiento: {resultado[‘result’]}”) api4 = CachedAPI(); api4.setup(“cpu”) test_text = “¡LitServe es increíble!” para i en el rango(3): decodificado = api4.decode_request({“text”: test_text}) resultado = api4.predict(decodificado) codificado = api4.encode_response(resultado) print(f”✓ Solicitud {i+1}: {codificado[‘label’]} (en caché: {codificado[‘from_cache’]})”) print(“=” * 70) print(“✅ ¡Todas las pruebas se completaron exitosamente!”) print(“=” * 70) test_apis_locally()
Probamos todas nuestras API localmente para verificar su corrección y rendimiento sin iniciar un servidor externo. Evaluamos secuencialmente la generación de texto, el análisis de opiniones por lotes, la multitarea y el almacenamiento en caché, asegurando que cada componente de nuestra configuración de LitServe funcione sin problemas y de manera eficiente.
En conclusión, creamos y ejecutamos diversas API que muestran la versatilidad del marco. Experimentamos con generación de texto, análisis de sentimientos, multitarea y almacenamiento en caché para experimentar la integración perfecta de LitServe con los canales de Hugging Face. A medida que completamos el tutorial, nos damos cuenta de cómo LitServe simplifica los flujos de trabajo de implementación de modelos, permitiéndonos ofrecer sistemas de aprendizaje automático inteligentes en solo unas pocas líneas de código Python y al mismo tiempo mantener la flexibilidad, el rendimiento y la simplicidad.
Consulta los CÓDIGOS COMPLETOS aquí. No dude en consultar nuestra página de GitHub para tutoriales, códigos y cuadernos. Además, no dude en seguirnos en Twitter y no olvide unirse a nuestro SubReddit de más de 100.000 ML y suscribirse a nuestro boletín. ¡Esperar! estas en telegrama? Ahora también puedes unirte a nosotros en Telegram.
Asif Razzaq es el director ejecutivo de Marktechpost Media Inc.. Como emprendedor e ingeniero visionario, Asif está comprometido a aprovechar el potencial de la inteligencia artificial para el bien social. Su esfuerzo más reciente es el lanzamiento de una plataforma de medios de inteligencia artificial, Marktechpost, que se destaca por su cobertura en profundidad del aprendizaje automático y las noticias sobre aprendizaje profundo que es técnicamente sólida y fácilmente comprensible para una amplia audiencia. La plataforma cuenta con más de 2 millones de visitas mensuales, lo que ilustra su popularidad entre el público.
🙌 Siga MARKTECHPOST: agréguenos como fuente preferida en Google.