Transformers documentation
Inferencia en servidor web
Inferencia en servidor web
Un servidor web es un sistema que espera solicitudes y las atiende a medida que llegan. Esto significa que puede usar Pipeline como motor de inferencia en un servidor web, ya que puede usar un iterador (de manera similar a como se recorre un conjunto de datos) para manejar cada solicitud entrante.
Diseñar un servidor web con Pipeline es único, ya que son fundamentalmente diferentes. Los servidores web son multiplexados (multihilo, asíncrono, etc.) para manejar múltiples solicitudes de forma concurrente. Por otro lado, Pipeline y su modelo subyacente no están diseñados para la paralelización, ya que consumen mucha memoria. Lo mejor es asignar a un Pipeline todos los recursos disponibles cuando está en ejecución o para una tarea intensiva en cómputo.
Esta guía muestra cómo sortear esta diferencia mediante el uso de un servidor web para gestionar la carga más ligera de recibir y enviar solicitudes, y un solo hilo para gestionar la carga más pesada de ejecutar Pipeline.
Crear un servidor
Starlette es un framework ligero para construir servidores web. Puedes usar cualquier otro framework que prefieras, pero es posible que tengas que realizar algunos cambios en el código siguiente.
Antes de comenzar, asegúrate de que Starlette y uvicorn estén instalados.
!pip install starlette uvicorn
Ahora puedes crear un servidor web simple en un archivo server.py. La clave es cargar el modelo solo una vez para evitar que copias innecesarias de este consuman memoria.
Cree un pipeline para completar el token enmascarado, [MASK].
from starlette.applications import Starlette
from starlette.responses import JSONResponse
from starlette.routing import Route
from transformers import pipeline
import asyncio
async def homepage(request):
payload = await request.body()
string = payload.decode("utf-8")
response_q = asyncio.Queue()
await request.app.model_queue.put((string, response_q))
output = await response_q.get()
return JSONResponse(output)
async def server_loop(q):
pipe = pipeline(task="fill-mask",model="google-bert/bert-base-uncased")
while True:
(string, response_q) = await q.get()
out = pipe(string)
await response_q.put(out)
app = Starlette(
routes=[
Route("/", homepage, methods=["POST"]),
],
)
@app.on_event("startup")
async def startup_event():
q = asyncio.Queue()
app.model_queue = q
asyncio.create_task(server_loop(q))Inicie el servidor con el siguiente comando.
uvicorn server:app
Realiza una solicitud POST al servidor.
curl -X POST -d "Paris is the [MASK] of France." http://localhost:8000/Esto debería devolver la siguiente salida.
[{'score': 0.9969332218170166,
'token': 3007,
'token_str': 'capital',
'sequence': 'paris is the capital of france.'},
{'score': 0.0005914849461987615,
'token': 2540,
'token_str': 'heart',
'sequence': 'paris is the heart of france.'},
{'score': 0.00043787318281829357,
'token': 2415,
'token_str': 'center',
'sequence': 'paris is the center of france.'},
{'score': 0.0003378340043127537,
'token': 2803,
'token_str': 'centre',
'sequence': 'paris is the centre of france.'},
{'score': 0.00026995912776328623,
'token': 2103,
'token_str': 'city',
'sequence': 'paris is the city of france.'}]Colas de solicitudes
El mecanismo de encolado del servidor puede utilizarse en algunas aplicaciones interesantes, como el loteo dinámico. El loteo dinámico acumula varias solicitudes antes de procesarlas con Pipeline.
El siguiente ejemplo está escrito en pseudocódigo por legibilidad y no por rendimiento; en particular, notará que:
No hay ningún límite de tamaño de lote.
El tiempo de espera se restablece en cada extracción de la cola, por lo que es posible que termine esperando mucho más tiempo que el valor de
timeoutantes de procesar una solicitud. Esto también retrasaría la primera solicitud de inferencia en esa misma cantidad de tiempo. El servidor web siempre espera 1 ms, incluso si la cola está vacía, lo cual es ineficiente, ya que ese tiempo podría utilizarse para iniciar la inferencia. Sin embargo, podría tener sentido si el agrupamiento (batching) es esencial para su caso de uso.Sería mejor tener un único plazo de 1 ms, en lugar de restablecerlo en cada fetch, como se muestra a continuación.
async def server_loop(q):
pipe = pipeline(task="fill-mask", model="google-bert/bert-base-uncased")
while True:
(string, rq) = await q.get()
strings = []
queues = []
strings.append(string)
queues.append(rq)
while True:
try:
(string, rq) = await asyncio.wait_for(q.get(), timeout=1)
except asyncio.exceptions.TimeoutError:
break
strings.append(string)
queues.append(rq)
outs = pipe(strings, batch_size=len(strings))
for rq, out in zip(queues, outs):
await rq.put(out)Verificación de errores
Hay muchas cosas que pueden salir mal en producción. Es posible agotar la memoria, quedarse sin espacio, fallar al cargar un modelo, tener una configuración de modelo incorrecta, realizar una consulta incorrecta, y mucho más.
Agregar declaraciones try...except es útil para devolver estos errores al usuario con fines de depuración. Tenga en cuenta que esto podría suponer un riesgo de seguridad si no debe revelar cierta información.
Corte de circuitos
Intente devolver un error 503 o 504 cuando el servidor esté sobrecargado, en lugar de obligar al usuario a esperar indefinidamente.
Es relativamente sencillo implementar estos tipos de error, ya que solo se trata de una única cola. Observa el tamaño de la cola para determinar cuándo comenzar a devolver errores antes de que tu servidor falle bajo carga.
Bloquear el hilo principal
PyTorch no es consciente de la asincronía, por lo que el cálculo bloqueará la ejecución del hilo principal.
Por esta razón, es mejor ejecutar PyTorch en su propio hilo o proceso independiente. Cuando la inferencia de una sola solicitud es especialmente larga (más de 1 s), es aún más importante, ya que significa que cada consulta durante la inferencia debe esperar 1 s antes de recibir siquiera un error.
Loteo dinámico
El loteo dinámico puede ser muy eficaz cuando se utiliza en el contexto adecuado, pero no es necesario si solo se envía 1 solicitud a la vez (consulte inferencia por lotes para más detalles).
Update on GitHub