LitServe: implantação rápida de serviços de inferência de modelos de IA de uso geral de nível empresarial

Introdução geral

A LitServe é relâmpago AI lançou um mecanismo de serviço de modelo de IA de código aberto, desenvolvido com base na FastAPI, com foco na implantação rápida de serviços de inferência para modelos de IA de uso geral. Ele é compatível com uma ampla variedade de cenários, desde modelos de linguagem grandes (LLMs), modelos visuais, modelos de áudio até modelos clássicos de aprendizado de máquina, e oferece processamento em lote, streaming e dimensionamento automático de GPU, com um aumento de desempenho de pelo menos duas vezes em relação ao FastAPI. O LitServe é fácil de usar e altamente flexível, e pode ser auto-hospedado ou totalmente hospedado via Lightning Studios. O LitServe é fácil de usar e altamente flexível, e pode ser auto-hospedado ou totalmente hospedado por meio do Lightning Studios, o que o torna ideal para pesquisadores, desenvolvedores e empresas criarem rapidamente APIs de inferência de modelos eficientes. Os funcionários enfatizam os recursos de classe empresarial, como segurança, escalabilidade e alta disponibilidade, para garantir que os ambientes de produção estejam prontos para sair da caixa.

Lista de funções

• Implementação rápida de serviços de inferênciaSuporte para conversão rápida de modelos de estruturas como PyTorch, JAX, TensorFlow, etc. para APIs.
• arquivo de loteMescle várias solicitações de inferência em um lote para melhorar o rendimento.
• transmissãoSuporte à saída de fluxo de resultados de inferência em tempo real, adequado para cenários de resposta contínua.
• Dimensionamento automático da GPUOtimiza o desempenho ajustando dinamicamente os recursos da GPU com base na carga de inferência.
• Sistema de IA compostoPermite que vários modelos raciocinem de forma colaborativa para criar serviços complexos.
• Hospedagem própria vs. hospedagem na nuvemSuporte à implementação local ou ao gerenciamento por meio da nuvem do Lightning Studios.
• Integração com o vLLMOtimização do desempenho da inferência para modelos de linguagem grandes.
• Compatível com OpenAPIGera automaticamente a documentação padrão da API para facilitar os testes e a integração.
• Suporte completo ao modeloCobertura das necessidades de inferência de vários modelos, como LLM, visão, áudio, incorporação, etc.
• Otimização do servidorProcessamento e inferência multiprocessos: oferece processamento e inferência multiprocessos mais de duas vezes mais rápidos que a FastAPI.

Usando a Ajuda

Processo de instalação

O LitServe é fácil de instalar com o tubulação A ferramenta fará o trabalho. Abaixo estão as etapas detalhadas:

1. preparação do ambiente

Certifique-se de que o Python 3.8 ou posterior esteja instalado em seu sistema; recomenda-se um ambiente virtual:

python -m venv venv
source venv/bin/activate # Linux/Mac
venv\Scripts\activate # Windows

2. instalação do LitServe

Execute o seguinte comando para instalar a versão estável:

pip install litserve

Se você precisar dos recursos mais recentes, poderá instalar a versão de desenvolvimento:

pip install git+https://github.com/Lightning-AI/litserve.git@main

3. inspeção das instalações

Verifique se a operação foi bem-sucedida:

python -c "import litserve; print(litserve.__version__)"

A saída bem-sucedida do número da versão conclui a instalação.

4. dependências opcionais

Se você precisar de suporte para GPU, instale a versão para GPU da estrutura correspondente, por exemplo:

pip install torch torchvision --index-url https://download.pytorch.org/whl/cu121

Como usar o LitServe

O LitServe transforma modelos de IA em serviços de inferência por meio de código limpo. Veja como ele funciona em detalhes:

1. criação do serviço de raciocínio simples

A seguir, um exemplo de um serviço de raciocínio composto com dois modelos:

import litserve as ls
classe SimpleLitAPI(ls.)
def setup(self, device).
# inicializar, carregar modelo ou dados
self.model1 = lambda x: x ** 2 # modelo quadrado
self.model2 = lambda x: x ** 3 # modelo cúbico
def decode_request(self, request).
# Decodificar dados da solicitação
return request["input"]
def predict(self, x).
# inferência composta
squared = self.model1(x)
cubed = self.model2(x)
return squared + cubed
def encode_response(self, output).
# Formatar o resultado da inferência
return {"output": output}
if __name__ == "__main__": server = ls.
server = ls.LitServer(SimpleLitAPI(), accelerator="auto")
server.run(port=8000)

• estar em movimento: Salvar como server.pyImplementação python server.py.
• teste (maquinário etc.)Uso de enrolar Envia uma solicitação de raciocínio:

  curl -X POST "http://127.0.0.1:8000/predict" -H "Content-Type: application/json" -d '{"input": 4.0}'
  

  Saída:{"output": 80.0}(16 + 64).

2) Ativação do raciocínio em massa

Modificar o código para dar suporte ao processamento em lote:

server = ls.LitServer(SimpleLitAPI(), max_batch_size=4, accelerator="auto")

• Instruções de operação::max_batch_size=4 Indica que até 4 solicitações de inferência são processadas ao mesmo tempo e mescladas automaticamente para aumentar a eficiência.
• Métodos de testeEnviar a solicitação várias vezes e observar a melhoria da taxa de transferência:

  curl -X POST "http://127.0.0.1:8000/predict" -H "Content-Type: application/json" -d '{"input": 5.0}'
  

3. configuração do raciocínio de fluxo

Para cenários de raciocínio em tempo real:

class StreamLitAPI(ls.LitAPI).
def setup(self, device): self.model = lambda x: [x * i for i in range(5)]]
self.model = lambda x: [x * i for i in range(5)]
def decode_request(self, request): return request["input"].
return request["input"]
def predict(self, x): for result in self.model(x)
for result in self.model(x): yield result
render resultado
def encode_response(self, output): return {"output": {"output": {"output": {"input"]].
return {"output": output}
server = ls.LitServer(StreamLitAPI(), stream=True, accelerator="auto")
server.run(port=8000)

• Instruções de operação::stream=True Habilitando o raciocínio de fluxo contínuo.prever fazer uso de rendimento Retorna os resultados um a um.
• Métodos de testeUse um cliente que ofereça suporte a respostas de streaming:

  curl --no-buffer -X POST "http://127.0.0.1:8000/predict" -H "Content-Type: application/json" -d '{"input": 2}'
  

4. expansão automática da GPU

Se uma GPU estiver disponível, o LitServe otimizará automaticamente a inferência:

• Instruções de operação::acelerador="auto" Detectar e priorizar GPUs.
• validar (uma teoria)Verificar os registros após a execução para confirmar o uso da GPU.
• Requisitos ambientaisVerifique se a versão da GPU da estrutura (por exemplo, PyTorch) está instalada.

5. implementação de raciocínio de modelo complexo (usando o BERT como exemplo)

Implante o serviço de inferência de modelo BERT da Hugging Face:

from transformers import BertTokenizer, BertModel
import litserve as ls
class BertLitAPI(ls.)
def setup(self, device): self.tokenizer = BertTokenizer.
self.tokeniser = BertTokenizer.from_pretrained("bert-base-uncased")
self.model = BertModel.from_pretrained("bert-base-uncased").to(device)
def decode_request(self, request).
return request["text"]
def predict(self, text).
inputs = self.tokeniser(text, return_tensors="pt").to(self.model.device)
outputs = self.model(**inputs)
return outputs.last_hidden_state.mean(dim=1).tolist()
def encode_response(self, outputs): {"embedding": outputs.last_hidden_state.mean(dim=1.tolist)
return {"embedding": output}
server = ls.LitServer(BertLitAPI(), accelerator="auto")
server.run(port=8000)

• estar em movimentoApós a execução do script, acesse o arquivo http://127.0.0.1:8000/predict.
• teste (maquinário etc.)::

  curl -X POST "http://127.0.0.1:8000/predict" -H "Content-Type: application/json" -d '{"text": "Hello, world!"}'
  

6. integrar o vLLM para implementar o raciocínio do LLM

Raciocínio eficiente para modelos de linguagem grandes:

import litserve as ls
de vllm importar LLM
class LLMLitAPI(ls.LitAPI): def setup(self, device).
def setup(self, device): self.model = LLM(model="meta-llama/Llama-3.2-1B")
self.model = LLM(model="meta-llama/Llama-3.2-1B", dtype="float16")
def decode_request(self, request):
return request["prompt"]
def predict(self, prompt).
outputs = self.model.generate(prompt, max_tokens=50)
return outputs[0].outputs[0].text
def encode_response(self, output): return {"response": outputs[0].
return {"response": output}
server = ls.LitServer(LLMLitAPI(), accelerator="auto")
server.run(port=8000)

• Instalação do vLLM::pip install vllm.
• teste (maquinário etc.)::

  curl -X POST "http://127.0.0.1:8000/predict" -H "Content-Type: application/json" -d '{"prompt": "What is AI?"}'
  

7. veja a documentação da API

• Instruções de operação: Acesso http://127.0.0.1:8000/docs, Interactive Test Reasoning Service (Serviço de teste interativo de raciocínio).
• Dicas de funçõesEndpoint: Baseado no padrão OpenAPI e contém todos os detalhes do endpoint.

8. opções de hospedagem

• auto-hospedadoExecute o código localmente ou no servidor.
• hospedagem na nuvemImplementado via Lightning Studios, requer registro de conta, oferece balanceamento de carga, dimensionamento automático e muito mais.

Dicas de operação

• ajustar os componentes durante o teste: Configurações tempo limite=60 Evite tempos limite de raciocínio.
• log (computação)Verifique os registros do terminal na inicialização para solucionar o problema.
• otimizaçãoConsulte a documentação oficial para ativar recursos avançados, como autenticação e implementação do Docker.

A LitServe oferece suporte a toda a gama de requisitos de processo, desde a prototipagem até aplicativos de classe empresarial, por meio da rápida implementação e otimização de serviços de inferência.