Cog: contêineres para aprendizado de máquina

Cog é uma ferramenta de código aberto que permite empacotar modelos de aprendizado de máquina em um contêiner padrão pronto para produção.

Você pode implantar seu modelo empacotado em sua própria infraestrutura ou em replicação.

Destaques

Contêineres Docker sem problemas. Escrever seu próprio Dockerfile pode ser um processo confuso. Com o Cog, você define seu ambiente com um arquivo de configuração simples e ele gera uma imagem Docker com todas as práticas recomendadas: imagens base da Nvidia, cache eficiente de dependências, instalação de versões específicas do Python, padrões de variáveis de ambiente sensatos e assim por diante.
Chega de inferno CUDA. Cog sabe quais combos CUDA/cuDNN/PyTorch/Tensorflow/Python são compatíveis e configurará tudo corretamente para você.
Defina as entradas e saídas do seu modelo com Python padrão. Em seguida, Cog gera um esquema OpenAPI e valida as entradas e saídas com Pydantic.
Servidor de previsão HTTP automático : os tipos do seu modelo são usados para gerar dinamicamente uma API RESTful HTTP usando FastAPI.
Trabalhador de fila automático. Modelos de aprendizagem profunda de longa duração ou processamento em lote são melhor arquitetados com uma fila. Os modelos Cog fazem isso imediatamente. Redis é atualmente suportado, com mais em desenvolvimento.
Armazenamento em nuvem. Os arquivos podem ser lidos e gravados diretamente no Amazon S3 e no Google Cloud Storage. (Em breve.)
Pronto para produção. Implante seu modelo em qualquer lugar onde as imagens do Docker sejam executadas. Sua própria infraestrutura ou Replicar.

Como funciona

Defina o ambiente Docker em que seu modelo é executado com cog.yaml :

 compilação: gpu: verdadeiro system_packages:
    - "libgl1-mesa-glx"
    - "libglib2.0-0" python_version: "3.12" python_packages:
    - "torch==2.3"predict: "predict.py:Predictor"

Defina como as previsões são executadas em seu modelo com predict.py :

 from cog import BasePredictor, Input, Pathimport torchclass Predictor(BasePredictor): def setup(self): """Carregue o modelo na memória para tornar a execução de múltiplas previsões eficiente""" self.model = torch.load("./weights. pth") # Os argumentos e tipos que o modelo toma como entrada def predizer(self, image: Path = Input(description="Grayscale input image")
    ) -> Caminho: """Executar uma única previsão no modelo""" processed_image = preprocess(image) output = self.model(processed_image) return postprocess(output)

Agora, você pode executar previsões neste modelo:

 $ cog predizer -i [email protected]> Construindo imagem do Docker...--> Predição em execução...--> Saída gravada em output.jpg

Ou crie uma imagem Docker para implantação:

 $ cog build -t my-colorization-model--> Construindo imagem Docker...--> Construído meu-modelo de colorização:mais recente$ docker run -d -p 5000:5000 --gpus all my-colorization-model$ curl http://localhost:5000/predictions -X POST  -H 'Tipo de conteúdo: aplicativo/json'  -d '{"input": {"imagem": "https://.../input.jpg"}}'

Por que estamos construindo isso?

É realmente difícil para os pesquisadores enviarem modelos de aprendizado de máquina para produção.

Parte da solução é o Docker, mas é muito complexo fazê-lo funcionar: Dockerfiles, pré/pós-processamento, servidores Flask, versões CUDA. Na maioria das vezes, o pesquisador precisa conversar com um engenheiro para implantar a maldita coisa.

Andreas e Ben criaram o Cog. Andreas trabalhava no Spotify, onde construiu ferramentas para construir e implantar modelos de ML com Docker. Ben trabalhou no Docker, onde criou o Docker Compose.

Percebemos que, além do Spotify, outras empresas também usavam o Docker para construir e implantar modelos de aprendizado de máquina. Uber e outros construíram sistemas semelhantes. Então, estamos fazendo uma versão de código aberto para que outras pessoas possam fazer isso também.

Contate-nos se estiver interessado em usá-lo ou quiser colaborar conosco. Estamos no Discord ou envie um email para [email protected].

Pré-requisitos

macOS, Linux ou Windows 11 . Cog funciona em macOS, Linux e Windows 11 com WSL 2
Docker . Cog usa Docker para criar um contêiner para seu modelo. Você precisará instalar o Docker antes de executar o Cog. Se você instalar o Docker Engine em vez do Docker Desktop, também precisará instalar o Buildx.

Instalar

Se estiver usando macOS, você pode instalar o Cog usando Homebrew:

 preparar a engrenagem de instalação

Você também pode baixar e instalar a versão mais recente usando nosso script de instalação:

 # fish shellsh (curl -fsSL https://cog.run/install.sh | psub)# bash, zsh e outros shellssh <(curl -fsSL https://cog.run/install.sh)# baixe com wget e execute em um comando separadowget -qO- https://cog.run/install.sh
sh ./install.sh

Você pode instalar manualmente a versão mais recente do Cog diretamente do GitHub executando os seguintes comandos em um terminal:

 sudo curl -o /usr/local/bin/cog -L "https://github.com/replicate/cog/releases/latest/download/cog_$(uname -s)_$(uname -m)"sudo chmod +x /usr/local/bin/cog

Alternativamente, você pode construir o Cog a partir do código-fonte e instalá-lo com estes comandos:

 makeudo fazer instalar

Ou se você estiver no docker:

RUN sh -c "INSTALL_DIR="/usr/local/bin" SUDO="" $(curl -fsSL https://cog.run/install.sh)"

Atualizar

Se você estiver usando macOS e instalou anteriormente o Cog com Homebrew, execute o seguinte:

 engrenagem de atualização de fermentação

Caso contrário, você pode atualizar para a versão mais recente executando os mesmos comandos usados para instalá-lo.

Próximas etapas

Comece com um modelo de exemplo
Comece com seu próprio modelo
Usando Cog com notebooks
Usando Cog com Windows 11
Dê uma olhada em alguns exemplos de uso do Cog
Implantar modelos com Cog
referência cog.yaml para aprender como definir o ambiente do seu modelo
Referência da interface de previsão para saber como funciona a interface Predictor
Referência da interface de treinamento para saber como adicionar uma API de ajuste fino ao seu modelo
Referência da API HTTP para saber como usar a API HTTP que os modelos atendem