Por que escolher o Docker para implantar modelos de linguagem

A implantação manual de modelos de IA frequentemente envolve incompatibilidades de dependências e conflitos entre versões de Python, CUDA e bibliotecas do sistema. O Docker resolve este problema encapsulendo todo o ambiente necessário em um container isolado, eliminando a necessidade de configuração manual complexa.

O modelo GLM-4-9B-Chat-1M, que suporta contextos de até dois milhões de caracteres, é ideal para implantação via Docker devido à sua complexa cadeia de dependências. Sua capacidade excepcional em processsar documentos extensos o torna valioso para análise jurídica, resumo de artigos científicos e geração de relatórios.

Pré-requisitos do sistema

Antes de começar, verifique se seu ambiente atende aos requisitos mínimos:

• Sistema operacional: Linux (Ubuntu 20.04 ou superior) ou Windows com WSL2
• Memória RAM: 32 GB no mínimo
• GPU NVIDIA com pelo menos 16 GB de VRAM (RTX 4090 ou A100 recomendados)
• Docker versão 20.10 ou superior
• NVIDIA Container Toolkit para aceleração de GPU

Instale o Docker e o suporte NVIDIA utilizando os comandos abaixo:

# Instalação do Docker Engine
curl -fsSL https://get.docker.com -o install-docker.sh
sudo sh install-docker.sh

# Instalação do toolkit para containers NVIDIA
distro=$(. /etc/os-release; echo $ID$VERSION_ID)
curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
curl -s -L "https://nvidia.github.io/nvidia-docker/$distro/nvidia-docker.list" | sudo tee /etc/apt/sources.list.d/nvidia-docker.list
sudo apt-get update && sudo apt-get install -y nvidia-container-toolkit
sudo systemctl restart docker

Verifique a instalação com:

docker run --rm --gpus all nvidia/cuda:11.8.0-base nvidia-smi

Processo de implanatção

Comece criando um Dockerfile para configurar o ambiente:

FROM nvidia/cuda:12.1.1-runtime-ubuntu22.04

WORKDIR /ambiente_app

RUN apt-get update && apt-get install -y \
    python3.10 \
    python3-pip \
    git \
    && rm -rf /var/lib/apt/lists/*

COPY dependencias.txt .
RUN pip3 install --no-cache-dir -r dependencias.txt

EXPOSE 8000

CMD ["python3", "-m", "http.server", "8000"]

Arquivo de dependências:

torch>=2.0.0
transformers>=4.40.0
accelerate>=0.30.0
sentencepiece>=0.2.0
protobuf>=3.20.0

Construa a imagem Docker:

docker build -t glim-4-chat-1m:latest .

Inicie o container com suporte a GPU:

docker run -d --name instancia-glm4 \
  --gpus all \
  -p 8000:8000 \
  -v $(pwd)/modelos:/ambiente_app/modelos \
  -v $(pwd)/dados:/ambiente_app/dados \
  glim-4-chat-1m:latest

Verificação da implantação

Confirme o status do container:

docker ps -a

Para testar o modelo, execute um script dentro do container:

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

caminho_modelo = "/ambiente_app/modelos/glm-4-9b-chat-1m"
tokenizador = AutoTokenizer.from_pretrained(caminho_modelo, trust_remote_code=True)
modelo = AutoModelForCausalLM.from_pretrained(
    caminho_modelo,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True
)

mensagem = "Explique o conceito de computação em nuvem"
entrada = tokenizador.apply_chat_template(
    [{"role": "user", "content": mensagem}],
    add_generation_prompt=True,
    return_tensors="pt"
).to(modelo.device)

resposta = modelo.generate(entrada, max_length=150, do_sample=True)
resultado = tokenizador.decode(resposta[0], skip_special_tokens=True)
print(resultado)

Resolução de problemas comuns

Para erros de memória insuficiente (OOM), utilize quantização:

modelo = AutoModelForCausalLM.from_pretrained(
    caminho_modelo,
    load_in_4bit=True,
    device_map="auto",
    trust_remote_code=True
)

Acelere downloads definindo um mirror do Hugging Face:

export HF_ENDPOINT=https://hf-mirror.com

Para ambientes de produção, otimize o container:

docker run -d --name glm4-producao \
  --gpus all \
  --shm-size=2g \
  --ulimit memlock=-1 \
  --ulimit stack=67108864 \
  -p 8000:8000 \
  glim-4-chat-1m:latest